### Install and Run Dependencies

Source: https://github.com/picovoice/eagle/blob/main/demo/web/README.md

Use yarn or npm to install project dependencies and start the local web server. This is the initial setup required to run the demo.

```console
yarn
yarn start
```

```console
npm install
npm run start
```

--------------------------------

### Start Web Demo (NPM)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Start the web demo server using NPM. Access the demo at http://localhost:5000.

```console
npm run start
```

--------------------------------

### Install Eagle Node.js Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Installs the Eagle Node.js demo package globally. Ensure you have Node.js 18+ installed.

```bash
npm install -g @picovoice/eagle-node-demo
```

--------------------------------

### Install iOS Dependencies

Source: https://github.com/picovoice/eagle/blob/main/README.md

Install the necessary dependencies for the iOS demo using CocoaPods. Run this command in the demo directory.

```console
pod install
```

--------------------------------

### Start Web Demo (Yarn)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Start the web demo server using Yarn. Access the demo at http://localhost:5000.

```console
yarn start
```

--------------------------------

### Install Web Demo Dependencies (NPM)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Install Node.js dependencies for the web demo using NPM. Run this command in the web demo directory.

```console
npm install
```

--------------------------------

### Install Web Demo Dependencies (Yarn)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Install Node.js dependencies for the web demo using Yarn. Run this command in the web demo directory.

```console
yarn
```

--------------------------------

### Install Eagle Web Binding with Yarn

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Install the Eagle Web Binding package using the yarn package manager.

```console
yarn add @picovoice/eagle-web
```

--------------------------------

### Install Eagle Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Install the Eagle demo package using pip. Ensure you are using Python 3.9 or later.

```console
pip3 install pveagledemo
```

--------------------------------

### Install Eagle Web Binding with npm

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Install the Eagle Web Binding package using the npm package manager.

```console
npm install --save @picovoice/eagle-web
```

--------------------------------

### Install Eagle Node.js Binding with npm

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Install the Eagle Node.js binding using the npm package manager.

```console
npm install --save @picovoice/eagle-node
```

--------------------------------

### Install Eagle Node.js Binding with Yarn

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Install the Eagle Node.js binding using the yarn package manager.

```console
yarn add @picovoice/eagle-node
```

--------------------------------

### Install Eagle Python Binding

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Install the Eagle Python package using pip. Ensure you are using Python 3.9 or later.

```console
pip3 install pveagle
```

--------------------------------

### Process Audio for Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Continuously process audio frames using the initialized Eagle engine and provided speaker profiles to get similarity scores.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

while (true) {
  const audioData = getAudioData(eagle.minProcessSamples);
  const scores: number[] = eagle.process(audioData, speakerProfile);
}
```

--------------------------------

### Run File Demo (Help)

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Displays help information for the file-based Eagle demo, listing all available arguments and their descriptions.

```bash
eagle-file-demo --help
```

--------------------------------

### Run Microphone Demo (Help)

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Displays help information for the microphone-based Eagle demo, listing all available arguments and their descriptions.

```bash
eagle-mic-demo --help
```

--------------------------------

### List Available Audio Input Devices

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Run the microphone demo executable with the -s argument to list all available audio input devices.

```console
./demo/c/build/eagle_demo_mic -s
```

--------------------------------

### Eagle File Demo Help

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Command to display the optional arguments and their descriptions for the Eagle file demo.

```console
eagle_demo_file --help
```

--------------------------------

### Speaker Enrollment with File Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Command to run the file demo in 'enroll' mode. It requires an access key, an output profile path, and paths to enroll audio files. Multiple audio files can be processed.

```console
eagle_demo_file enroll --access_key ${ACCESS_KEY} \
  --output_profile_path ${OUTPUT_PROFILE_PATH} --enroll_audio_paths ${ENROLL_AUDIO_PATH_1 ...}
```

--------------------------------

### Basic CMake Configuration

Source: https://github.com/picovoice/eagle/blob/main/demo/c/CMakeLists.txt

Sets the minimum CMake version, project name, C standard, and build type. Includes the pvrecorder subdirectory.

```cmake
cmake_minimum_required(VERSION 3.13)
project(eagle_demo_c)

set(CMAKE_C_STANDARD 99)
set(CMAKE_BUILD_TYPE Release)
add_subdirectory(pvrecorder/project)
```

--------------------------------

### Enroll Speaker with Audio Files (Node.js)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enroll a new speaker profile using pre-recorded audio files via the Node.js demo. Requires an access key, paths to enrollment audio, and an output path for the profile.

```console
eagle-file-demo --enroll \
    --access_key ${ACCESS_KEY} \
    --enroll_audio_paths ${ENROLL_AUDIO_PATH_1 ...} \
    --output_profile_path ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Initialize Eagle Profiler

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Create an instance of the EagleProfiler for speaker enrollment. Requires a valid Picovoice AccessKey.

```python
import pveagle

# AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
access_key = "${ACCESS_KEY}"
Eagle_profiler = pveagle.create_profiler(access_key)
```

--------------------------------

### Enroll Speaker with Audio Files (Python)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enroll a new speaker profile using pre-recorded audio files. Requires an access key, paths to enrollment audio, and an output path for the profile.

```console
eagle_demo_file enroll \
    --access_key ${ACCESS_KEY} \
    --enroll_audio_paths ${ENROLL_AUDIO_PATHS}
    --output_profile_path ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Build C Demos

Source: https://github.com/picovoice/eagle/blob/main/README.md

Build the C demos using CMake. This command compiles the demo executable.

```console
cmake -S demo/c/ -B demo/c/build && cmake --build demo/c/build --target eagle_demo_mic
```

--------------------------------

### Speaker Enrollment with Eagle File Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Runs the Eagle file demo in enrollment mode. Pass the -e argument with the path to the output file for the speaker profile.

```console
./demo/c/build/eagle_demo_file -l ${LIBRARY_PATH} -m ${MODEL_PATH} -a ${ACCESS_KEY} -e ${OUTPUT_PROFILE_PATH} ${WAV_AUDIO_PATH_1} ${WAV_AUDIO_PATH_2} ...
```

--------------------------------

### Run Eagle File Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Basic command to run the Eagle file demo in either 'enroll' or 'test' mode. Replace ${ACCESS_KEY} with your Picovoice Console access key.

```console
eagle_demo_file {enroll,test} --access_key ${ACCESS_KEY} ...
```

--------------------------------

### Show Help for Microphone Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Display all available arguments and their descriptions for the Eagle microphone demo. This is useful for understanding all configuration options.

```console
eagle_demo_mic --help
```

--------------------------------

### Initialize Eagle Profiler

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Instantiate the EagleProfiler to begin the speaker enrollment process. Ensure you have your Picovoice access key.

```typescript
const { EagleProfiler } = require("@picovoice/eagle-node");

const accessKey = "${ACCESS_KEY}"; // Obtained from the Picovoice Console (https://console.picovoice.ai/)
const eagleProfiler = new EagleProfiler(accessKey);
```

--------------------------------

### Initialize Eagle Engine

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Create an instance of the Eagle engine using your Picovoice AccessKey to perform speaker recognition.

```swift
let eagle = Eagle(accessKey: accessKey)
```

--------------------------------

### File Demo Executable Configuration

Source: https://github.com/picovoice/eagle/blob/main/demo/c/CMakeLists.txt

Defines the 'eagle_demo_file' executable and sets its private include directories.

```cmake
add_executable(
        eagle_demo_file
        eagle_demo_file.c)
target_include_directories(eagle_demo_file PRIVATE dr_libs)
```

--------------------------------

### Initialize Eagle Engine

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Instantiate the Eagle engine for speaker recognition. Provide your Picovoice access key.

```typescript
const { Eagle } = require("@picovoice/eagle-node");

const accessKey = "${ACCESS_KEY}"; // Obtained from the Picovoice Console (https://console.picovoice.ai/)
const eagle = new Eagle(accessKey);
```

--------------------------------

### Initialize Eagle Engine

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Creates an instance of the Eagle engine for speaker recognition. Requires the Picovoice access key.

```java
import ai.picovoice.eagle.*;

final String accessKey = "${ACCESS_KEY}";

try {
    Eagle eagle = new Eagle.Builder()
        .setAccessKey(accessKey)
        .build();
} catch (EagleException e) { }
```

--------------------------------

### Initialize Eagle Recognizer

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Create an instance of the Eagle recognizer for speaker identification. Requires a valid Picovoice AccessKey.

```python
eagle = pveagle.create_recognizer(access_key)
```

--------------------------------

### Enroll Speaker via Audio Files

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Enrolls a speaker using one or more provided audio files. Generates a speaker profile and saves it to the specified output path.

```bash
eagle-file-demo --enroll --access_key ${ACCESS_KEY} --enroll_audio_paths ${ENROLL_AUDIO_PATH_1 ...} --output_profile_path ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Enroll Speaker with Microphone (Node.js)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enroll a new speaker profile using microphone input via the Node.js demo. Requires an access key and an output path for the profile.

```console
eagle-mic-demo --enroll \
    --access_key ${ACCESS_KEY} \
    --output_profile_path ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Initialize Eagle Profiler (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Initializes the Eagle profiler instance. Ensure ACCESS_KEY and MODEL_PATH are correctly set. The device parameter can be set to 'best'.

```c
const char *access_key = "${ACCESS_KEY}";
const char *model_path = "${MODEL_PATH}";
const char *device = "best";
const int32_t min_enrollment_chunks = 1;
const float voice_threshold = 0.3f;

pv_eagle_profiler_t *eagle_profiler = NULL;
pv_status_t status = pv_eagle_profiler_init(
            access_key,
            model_path,
            device,
            min_enrollment_chunks,
            voice_threshold,
            &eagle_profiler);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

--------------------------------

### Eagle File Demo Usage

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Prints the usage information for the Eagle file demo executable when run without arguments.

```console
./demo/c/build/eagle_demo_file [-e OUTPUT_PROFILE_PATH | -t INPUT_PROFILE_PATH] [-l LIBRARY_PATH -m MODEL_PATH -a ACCESS_KEY WAV_AUDIO_PATH_1 WAV_AUDIO_PATH_2 ...]
```

--------------------------------

### Run Microphone Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Execute the microphone demo for Eagle speaker recognition. Use 'enroll' to create a speaker profile or 'test' to perform recognition. Replace ${ACCESS_KEY} with your Picovoice AccessKey.

```console
eagle_demo_mic {enroll, test} --access_key ${ACCESS_KEY} ...
```

--------------------------------

### Speaker Enrollment with Microphone Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Run the Eagle microphone demo in enrollment mode by passing the -e argument with the path for the output speaker profile.

```console
./demo/c/build/eagle_demo_mic -l ${LIBRARY_PATH} -m ${MODEL_PATH} -a ${ACCESS_KEY} -d ${AUDIO_DEVICE_INDEX} -e ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Initialize EagleProfiler

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Creates an instance of EagleProfiler for speaker enrollment. Requires the Picovoice access key.

```java
import ai.picovoice.eagle.*;

final String accessKey = "${ACCESS_KEY}";

try {
    EagleProfiler eagleProfiler = new EagleProfiler.Builder()
            .setAccessKey(accessKey)
            .build();
} catch (EagleException e) { }
```

--------------------------------

### Initialize EagleProfiler (Web)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Creates an instance of the EagleProfiler for web-based speaker enrollment. Requires an AccessKey and model configuration (publicPath or base64).

```typescript
const eagleModel = {
  publicPath: ${MODEL_RELATIVE_PATH},
  // or
  base64: ${MODEL_BASE64_STRING},
}

const eagleProfiler = await EagleProfiler.create(
        ${ACCESS_KEY},
        eagleModel);
```

--------------------------------

### Speaker Recognition with File Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Command to run the file demo in 'test' mode for speaker recognition. It requires an access key, paths to input speaker profiles, and the path to the test audio file.

```console
eagle_demo_file test --access_key ${ACCESS_KEY} \
  --input_profile_paths ${INPUT_PROFILE_PATH_1 ...} --test_audio_path ${TEST_AUDIO_PATH}
```

--------------------------------

### Microphone Demo Executable Configuration

Source: https://github.com/picovoice/eagle/blob/main/demo/c/CMakeLists.txt

Defines the 'eagle_demo_mic' executable, including source files and pv_recorder objects, and sets its private include directories.

```cmake
add_executable(
        eagle_demo_mic
        eagle_demo_mic.c
        $<TARGET_OBJECTS:pv_recorder_object>)
target_include_directories(eagle_demo_mic PRIVATE pvrecorder/project/include)
```

--------------------------------

### Build Eagle Microphone Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Use CMake to build the Eagle microphone demo target. The PV_RECORDER_PLATFORM variable sets compilation flags for the given platform.

```console
cmake -S demo/c/ -B demo/c/build -DPV_RECORDER_PLATFORM={PV_RECORDER_PLATFORM}
cmake --build demo/c/build --target eagle_demo_mic
```

--------------------------------

### Build Eagle File Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Builds the Eagle file demo target using CMake. The PV_RECORDER_PLATFORM variable can be set for specific platform compilation flags.

```console
cmake -S demo/c/ -B demo/c/build -DPV_RECORDER_PLATFORM={PV_RECORDER_PLATFORM}
cmake --build demo/c/build --target eagle_demo_file
```

--------------------------------

### Initialize Eagle Profiler

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Create an instance of EagleProfiler for speaker enrollment. This can be done on the main thread or a worker thread. Ensure you provide a valid AccessKey and the Eagle model.

```typescript
const eagleModel = {
  publicPath: ${MODEL_RELATIVE_PATH},
  // or
  base64: ${MODEL_BASE64_STRING},
}

// Main thread
const eagleProfiler = await EagleProfiler.create(
        ${ACCESS_KEY},
        eagleModel);

// or on worker thread
const eagleProfiler = await EagleProfilerWorker.create(
        ${ACCESS_KEY},
        eagleModel);
```

--------------------------------

### Enroll Speaker via Microphone

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Initiates the speaker enrollment process using microphone input. Saves the generated speaker profile to the specified path.

```bash
eagle-mic-demo --enroll --access_key ${ACCESS_KEY} --output_profile_path ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Initialize Eagle Engine (Web)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Creates an instance of the Eagle engine for web-based speaker recognition. It requires an AccessKey, model configuration, and one or more pre-created speaker profiles.

```typescript
const eagle = await Eagle.create(
        ${ACCESS_KEY},
        eagleModel,
        speakerProfile);
```

--------------------------------

### Initialize EagleProfiler

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Instantiate the EagleProfiler with your Picovoice AccessKey to begin the speaker enrollment process. Ensure the AccessKey is kept secret.

```swift
import Eagle

let accessKey : String = // .. AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
do {
    let eagleProfiler = try EagleProfiler(accessKey: accessKey)
} catch { }
```

--------------------------------

### Initialize Eagle Engine (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Initializes the Eagle engine for speaker recognition. Requires ACCESS_KEY, MODEL_PATH, and a voice threshold. The engine can then process audio using an exported speaker profile.

```c
pv_eagle_t *eagle = NULL;
pv_status_t status = pv_eagle_init(
        access_key,
        model_path,
        device,
        voice_threshold,
        &eagle);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

--------------------------------

### Enroll Speaker (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enroll a new speaker profile using the C demo. Requires library path, model path, access key, and output profile path.

```console
./demo/c/build/eagle_demo_mic -l ${LIBRARY_PATH} -m ${MODEL_PATH} -a ${ACCESS_KEY} -e ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Test Speaker Recognition with Audio Files (Node.js)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Test the speaker recognition engine using pre-recorded audio files via the Node.js demo. Requires an access key, paths to test audio, and paths to speaker profiles.

```console
eagle-file-demo --test \
    --access_key ${ACCESS_KEY} \
    --test_audio_path ${TEST_AUDIO_PATH} \
    --input_profile_paths ${INPUT_PROFILE_PATH_1 ...}
```

--------------------------------

### Initialize Eagle Engine

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Create an instance of the Eagle engine for speaker recognition. This can be done on the main thread or a worker thread. Provide a valid AccessKey and the Eagle model.

```typescript
// Main thread
const eagle = await Eagle.create(
        ${ACCESS_KEY},
        eagleModel);

// or, on a worker thread
const eagle = await EagleWorker.create(
        ${ACCESS_KEY},
        eagleModel);
```

--------------------------------

### Speaker Recognition with Eagle File Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Runs the Eagle file demo in test mode. Pass the -t argument with the path to the input file containing the speaker profile.

```console
./demo/c/build/eagle_demo_file -l ${LIBRARY_PATH} -m ${MODEL_PATH} -a ${ACCESS_KEY} -t ${INPUT_PROFILE_PATH} ${WAV_AUDIO_PATH_1} ${WAV_AUDIO_PATH_2} ...
```

--------------------------------

### Local Server Availability

Source: https://github.com/picovoice/eagle/blob/main/demo/web/README.md

The output indicates the local development server address. Access the demo by navigating to this URL in your web browser.

```console
Available on:
  http://localhost:5000
Hit CTRL-C to stop the server
```

--------------------------------

### Test Speaker Recognition with Audio Files (Python)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Test the speaker recognition engine using pre-recorded audio files. Requires an access key, paths to speaker profiles, and paths to test audio files.

```console
eagle_demo_file test \
    --access_key ${ACCESS_KEY} \
    --input_profile_paths ${INPUT_PROFILE_PATH}
    --test_audio_paths ${TEST_AUDIO_PATHS}
```

--------------------------------

### Enroll Speaker with Specific Audio Device

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Enroll a speaker profile using a specific audio input device. First, list available devices with --show_audio_devices, then specify the device index. Replace ${ACCESS_KEY}, ${OUTPUT_PROFILE_PATH}, and the index.

```console
eagle_demo_mic enroll --access_key ${ACCESS_KEY} --output_profile_path ${OUTPUT_PROFILE_PATH} --audio_device_index 2
```

--------------------------------

### Enroll Speaker Profile in Android

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enroll a speaker profile by repeatedly calling the `enroll` method with audio frames until the enrollment percentage reaches 100%. Handle potential EagleExceptions.

```java
public short[] getNextAudioFrame() {
    // get audio frame
}

EagleProfilerEnrollResult result = null;
try {
    while (result != null && result.getPercentage() < 100.0) {
        result = eagleProfiler.enroll(getNextAudioFrame());
    }
} catch (EagleException e) { }
```

--------------------------------

### Enroll Speaker Profile

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Run the Eagle microphone demo in enrollment mode to create a speaker profile. The profile is saved to the specified output path. Replace ${ACCESS_KEY} and ${OUTPUT_PROFILE_PATH}.

```console
eagle_demo_mic enroll --access_key ${ACCESS_KEY} --output_profile_path ${OUTPUT_PROFILE_PATH}
```

--------------------------------

### Create Python Eagle Recognizer

Source: https://github.com/picovoice/eagle/blob/main/README.md

Create an instance of the Eagle recognizer using your AccessKey and an exported speaker profile.

```python
eagle = pveagle.create_recognizer(access_key, speaker_profile)
```

--------------------------------

### Run Instrumented Tests

Source: https://github.com/picovoice/eagle/blob/main/demo/android/EagleDemo/README.md

Execute instrumented tests for the Eagle Android demo. Replace 'YOUR_ACCESS_KEY_HERE' with your actual Picovoice AccessKey. Ensure an Android device or simulator is running.

```bash
cd demo/android/EagleDemo
./gradlew connectedAndroidTest -PpvTestingAccessKey="YOUR_ACCESS_KEY_HERE"
```

--------------------------------

### Test Speaker Recognition with Microphone (Node.js)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Test the speaker recognition engine using microphone input via the Node.js demo. Requires an access key and paths to the speaker profiles.

```console
eagle-mic-demo --test \
    --access_key ${ACCESS_KEY} \
    --input_profile_paths ${INPUT_PROFILE_PATH_1 ...}
```

--------------------------------

### Enroll Speaker Profile (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enrolls a speaker by processing audio frames. Continues until enrollment is complete (100%) or no more audio is available. Exports the speaker profile upon completion.

```c
extern const int16_t *get_next_enroll_audio_frame(int32_t frame_length);
extern const bool has_next_enroll_audio_frame(int32_t frame_length);
const int32_t frame_length = pv_eagle_profiler_frame_length();

float enroll_percentage = 0.0f;

while (enroll_percentage < 100.0f && has_next_enroll_audio_frame(frame_length)) {
  status = pv_eagle_profiler_enroll(
          eagle_profiler,
          get_next_enroll_audio_frame(frame_length),
          &enroll_percentage);
  if (status != PV_STATUS_SUCCESS) {
      // error handling logic
  }
}

status = pv_eagle_profiler_flush(
        eagle_profiler,
        &enroll_percentage);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}

int32_t profile_size_bytes = 0;
status = pv_eagle_profiler_export_size(eagle_profiler, &profile_size_bytes);
void *speaker_profile = malloc(profile_size_bytes);
status = pv_eagle_profiler_export(
        eagle_profiler,
        speaker_profile);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

--------------------------------

### Create iOS Eagle Profiler

Source: https://github.com/picovoice/eagle/blob/main/README.md

Initialize the Eagle profiler in Swift using your AccessKey. This operation can throw an error, so it should be handled within a do-catch block.

```swift
import pveagle

let accessKey : String = // .. AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
let eagleProfiler = try EagleProfiler(accessKey: accessKey)
```

--------------------------------

### C Speaker Enrollment

Source: https://github.com/picovoice/eagle/blob/main/README.md

This snippet demonstrates how to initialize the Eagle profiler, enroll a speaker by processing audio frames, and export the resulting speaker profile.

```APIDOC
## C Speaker Enrollment

### Description
Initializes the Eagle profiler, enrolls a speaker by processing audio frames, and exports the speaker profile.

### Initialization
```c
const char *access_key = "${ACCESS_KEY}";
const char *model_path = "${MODEL_PATH}";
const char *device = "best";
const int32_t min_enrollment_chunks = 1;
const float voice_threshold = 0.3f;

pv_eagle_profiler_t *eagle_profiler = NULL;
pv_status_t status = pv_eagle_profiler_init(
            access_key,
            model_path,
            device,
            min_enrollment_chunks,
            voice_threshold,
            &eagle_profiler);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

### Enrollment
```c
extern const int16_t *get_next_enroll_audio_frame(int32_t frame_length);
extern const bool has_next_enroll_audio_frame(int32_t frame_length);
const int32_t frame_length = pv_eagle_profiler_frame_length();

float enroll_percentage = 0.0f;

while (enroll_percentage < 100.0f && has_next_enroll_audio_frame(frame_length)) {
  status = pv_eagle_profiler_enroll(
          eagle_profiler,
          get_next_enroll_audio_frame(frame_length),
          &enroll_percentage);
  if (status != PV_STATUS_SUCCESS) {
      // error handling logic
  }
}

status = pv_eagle_profiler_flush(
        eagle_profiler,
        &enroll_percentage);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

### Export Profile
```c
int32_t profile_size_bytes = 0;
status = pv_eagle_profiler_export_size(eagle_profiler, &profile_size_bytes);
void *speaker_profile = malloc(profile_size_bytes);
status = pv_eagle_profiler_export(
        eagle_profiler,
        speaker_profile);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

### Cleanup
```c
pv_eagle_profiler_delete(eagle_profiler);
```
```

--------------------------------

### Speaker Recognition with Microphone Demo

Source: https://github.com/picovoice/eagle/blob/main/demo/c/README.md

Run the Eagle microphone demo in test mode by passing the -t argument with the path to the input speaker profile.

```console
./demo/c/build/eagle_demo_mic -l ${LIBRARY_PATH} -m ${MODEL_PATH} -a ${ACCESS_KEY} -d ${AUDIO_DEVICE_INDEX} -t ${INPUT_PROFILE_PATH}
```

--------------------------------

### Test Speaker Recognition (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Test the speaker recognition engine using the C demo. Requires library path, model path, access key, and input profile path.

```console
./demo/c/build/eagle_demo_mic -l ${LIBRARY_PATH} -m ${MODEL_PATH} -a ${ACCESS_KEY} -i ${INPUT_PROFILE_PATH}
```

--------------------------------

### Linking Libraries for Non-Windows Platforms

Source: https://github.com/picovoice/eagle/blob/main/demo/c/CMakeLists.txt

Links common libraries, pthread, and potentially atomic for the microphone demo on Unix-like systems. Also links common libraries for the file demo.

```cmake
if (NOT WIN32)
    target_link_libraries(
            eagle_demo_mic
            pthread
            ${COMMON_LIBS})
    target_link_libraries(eagle_demo_file ${COMMON_LIBS})
    if ((${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm" OR ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64") AND (UNIX AND NOT APPLE))
        target_link_libraries(eagle_demo_mic atomic)
    endif ()
endif ()
```

--------------------------------

### Speaker Recognition with CSV Output

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Command to run the file demo in 'test' mode with an additional option to generate a CSV file for further analysis. It requires an access key, input profile paths, test audio path, and a CSV output path.

```console
eagle_demo_file test --access_key ${ACCESS_KEY} \
  --input_profile_paths ${INPUT_PROFILE_PATH_1 ...} --test_audio_path ${TEST_AUDIO_PATH} \
  --csv_output_path ${CSV_OUTPUT_PATH}
```

--------------------------------

### Common Libraries and Include Directories

Source: https://github.com/picovoice/eagle/blob/main/demo/c/CMakeLists.txt

Defines common libraries and includes necessary header directories for the project.

```cmake
set(COMMON_LIBS dl m)
include_directories("${PROJECT_SOURCE_DIR}/../../include")
```

--------------------------------

### Enroll Speaker Profile

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enroll a speaker by processing audio data in chunks until the profile is complete. Ensure you have audio data available before proceeding.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

function hasAudioData(numSamples): Boolean {
  // check if there are any remaining samples in the stream
}

let percentage = 0;
while (percentage < 100 && hasAudioData(eagleProfiler.frameLength)) {
  const audioData = getAudioData(eagleProfiler.frameLength);
  percentage = eagleProfiler.enroll(audioData);
}

percentage = eagleProfiler.flush();
```

--------------------------------

### Enroll Speaker Profile (Web)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Enrolls a speaker profile using audio data obtained from the browser. The enrollment process provides feedback on audio quality and returns the enrollment percentage.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

let percentage = 0;
while (percentage < 100) {
  const audioData = getAudioData(eagleProfiler.minEnrollSamples);

  const result: EagleProfilerEnrollResult = await eagleProfiler.enroll(audioData);
  if (result.feedback === EagleProfilerEnrollFeedback.AUDIO_OK) {
      // audio is good!
  } else {
      // feedback code will tell you why audio was not used in enrollment
  }
  percentage = result.percentage;
}

// export speaker profile
const speakerProfile: EagleProfile = eagleProfiler.export();
```

--------------------------------

### C Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/README.md

This snippet shows how to initialize the Eagle engine, process audio frames for speaker recognition, and release resources.

```APIDOC
## C Speaker Recognition

### Description
Initializes the Eagle engine, processes incoming audio frames for speaker recognition, and releases acquired resources.

### Initialization
```c
pv_eagle_t *eagle = NULL;
pv_status_t status = pv_eagle_init(
        access_key,
        model_path,
        device,
        voice_threshold,
        &eagle);
if (status != PV_STATUS_SUCCESS) {
    // error handling logic
}
```

### Processing
```c
extern const int16_t *get_next_audio_frame(void);
extern const int32_t get_next_audio_num_samples(void);

float *scores = NULL;
while (true) {
    const int16_t *pcm = ; // Placeholder for actual audio data retrieval
    const pv_status_t status = pv_eagle_process(
            eagle,
            get_next_audio_frame(),
            get_next_audio_num_samples(),
            &speaker_profile, // Assumes speaker_profile is available from enrollment
            1, // Number of speaker profiles to compare against
            &scores);
    if (status != PV_STATUS_SUCCESS) {
        // error handling logic
    }
    // Process scores array
}
```

### Cleanup
```c
pv_eagle_scores_delete(scores);
pv_eagle_delete(eagle); // Assuming 'handle' in the source was meant to be 'eagle'
```
```

--------------------------------

### Test Speaker Recognition with Microphone (Python)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Test the speaker recognition engine using microphone input. Requires an access key and paths to the speaker profiles.

```console
eagle_demo_mic test \
    --access_key ${ACCESS_KEY} \
    --input_profile_paths ${INPUT_PROFILE_PATH}
```

--------------------------------

### Eagle Model Configuration Object

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Configure the Eagle model by specifying either its public path or base64 encoded string. Optional parameters like customWritePath and forceWrite can also be set.

```typescript
const eagleModel = {
  publicPath: ${MODEL_RELATIVE_PATH},
  // or
  base64: ${MODEL_BASE64_STRING},

  // Optionals
  customWritePath: "eagle_model",
  forceWrite: false,
  version: 1,
}
```

--------------------------------

### Web Speaker Enrollment

Source: https://github.com/picovoice/eagle/blob/main/README.md

This TypeScript snippet demonstrates creating an EagleProfiler instance, enrolling a speaker using audio data, and exporting the speaker profile.

```APIDOC
## Web Speaker Enrollment

### Description
Creates an `EagleProfiler` instance, enrolls a speaker using audio data, and exports the speaker profile.

### Initialization
```typescript
const eagleModel = {
  publicPath: ${MODEL_RELATIVE_PATH},
  // or
  base64: ${MODEL_BASE64_STRING},
}

const eagleProfiler = await EagleProfiler.create(
        ${ACCESS_KEY},
        eagleModel);
```

### Enrollment
```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
  // Replace with actual audio data retrieval logic
  return new Int16Array(numSamples);
}

let percentage = 0;
while (percentage < 100) {
  const audioData = getAudioData(eagleProfiler.minEnrollSamples);

  const result: EagleProfilerEnrollResult = await eagleProfiler.enroll(audioData);
  if (result.feedback === EagleProfilerEnrollFeedback.AUDIO_OK) {
      // audio is good!
  } else {
      // feedback code will tell you why audio was not used in enrollment
  }
  percentage = result.percentage;
}
```

### Export Profile
```typescript
const speakerProfile: EagleProfile = eagleProfiler.export();
```
```

--------------------------------

### Enroll Speaker Audio

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Processes audio frames for speaker enrollment. Continues until enrollment reaches 100%. Requires a method to fetch audio frames.

```java
public short[] getNextAudioFrame() {
    // get audio frame
}

EagleProfilerEnrollResult result = null;
try {
    while (result != null && result.getPercentage() < 100.0) {
        result = eagleProfiler.enroll(getNextEnrollAudioData());
    }
} catch (EagleException e) { }
```

--------------------------------

### Import Eagle Package using CocoaPods

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Add the 'Eagle-iOS' pod to your Podfile to integrate the Eagle SDK into your iOS project.

```ruby
pod 'Eagle-iOS'
```

--------------------------------

### Import Eagle Package using Swift Package Manager

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Add the Eagle repository URL to your project's Package Dependencies in Xcode to import the package.

```text
https://github.com/Picovoice/eagle.git
```

--------------------------------

### Required Android Permissions

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Add RECORD_AUDIO and INTERNET permissions to your AndroidManifest.xml to enable microphone access and AccessKey validation.

```xml
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.INTERNET" />
```

--------------------------------

### Perform Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/demo/python/README.md

Run the Eagle microphone demo in test mode to perform speaker recognition. Provide paths to one or more enrolled speaker profiles using --input_profile_paths. Replace ${ACCESS_KEY} and ${INPUT_PROFILE_PATH_1 ...}.

```console
eagle_demo_mic test --access_key ${ACCESS_KEY} --input_profile_paths ${INPUT_PROFILE_PATH_1 ...}
```

--------------------------------

### Enroll Speaker Audio

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Continuously feed audio frames to the profiler until enrollment reaches 100%. Call `flush` after all audio from a single source is submitted.

```typescript
const { EnrollProgress } = require("@picovoice/eagle-node");

function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

function hasAudioData(numSamples): Boolean {
  // check if there are any remaining samples in the stream
}

let percentage = 0;
while (percentage < 100 && hasAudioData(eagleProfiler.frameLength)) {
  const audioData = getAudioData(eagleProfiler.frameLength);
  percentage = eagleProfiler.enroll(audioData);
}

percentage = eagleProfiler.flush();
```

--------------------------------

### Test Speaker Recognition via Audio File

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Performs speaker recognition using a test audio file against one or more pre-existing speaker profiles. Results are displayed in the terminal.

```bash
eagle-file-demo --test --access_key ${ACCESS_KEY} --test_audio_path ${TEST_AUDIO_PATH} --input_profile_paths ${INPUT_PROFILE_PATH_1 ...}
```

--------------------------------

### Process Audio for Speaker Recognition (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Processes incoming audio frames using the initialized Eagle engine and a speaker profile. It returns scores indicating the likelihood of the speaker. This is typically run in a loop.

```c
extern const int16_t *get_next_audio_frame(void);
extern const int32_t get_next_audio_num_samples(void);

float *scores = NULL;
while (true) {
    const int16_t *pcm = ;
    const pv_status_t status = pv_eagle_process(
            eagle,
            get_next_audio_frame(),
            get_next_audio_num_samples(),
            &speaker_profile,
            1,
            &scores);
    if (status != PV_STATUS_SUCCESS) {
        // error handling logic
    }
}
```

--------------------------------

### Base64 Encode Eagle Model

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Use the pvbase64 script to convert an Eagle model file into a base64 encoded JavaScript file. This method is useful when not hosting a server.

```bash
npx pvbase64 -i ${EAGLE_MODEL_PATH} -o ${BASE64_MODEL_PATH}.js
```

```bash
npx pvbase64 -h
```

--------------------------------

### Process Audio for Speaker Recognition (Web)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Processes audio frames in real-time using the Eagle engine. It returns an array of scores indicating the likelihood of each enrolled speaker being the one speaking.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

while (true) {
  const audioData = getAudioData(eagle.frameLength);
  const scores: number[] = await eagle.process(audioData);
}
```

--------------------------------

### Process Audio for Recognition

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Processes audio frames for speaker recognition against provided speaker profiles. The loop continues indefinitely, processing audio as it becomes available.

```java
public short[] getNextProcessAudioData() {
    // get audio sample
}

try {
    EagleProfile[] speakerProfiles = {speakerProfile};

    while (true) {
        float[] scores = eagle.process(getNextProcessAudioData(), speakerProfiles);
    }
} catch (EagleException e) { }
```

--------------------------------

### Enroll Speaker Audio

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Process audio frames to enroll a speaker's voiceprint. The process returns the enrollment percentage. Ensure audio is 16-bit linearly-encoded, single-channel PCM with a sample rate matching eagle_profiler.sample_rate.

```python
def get_next_enroll_audio_frame(frame_length):
    pass

def has_next_enroll_audio_frame(frame_length):
    pass


percentage = 0.0
while percentage < 100.0 and has_next_enroll_audio_frame(eagle_profiler.frame_length):
    percentage = eagle_profiler.enroll(get_next_enroll_audio_frame(eagle_profiler.frame_length))
percentage = eagle_profiler.flush()
```

--------------------------------

### Process Audio for Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Process incoming audio frames using the Eagle engine and an enrolled speaker profile. The engine expects single-channel, 16-bit linear PCM audio with a minimum frame size defined by eagle.minProcessSamples. The function returns similarity scores or null if no speaker is detected.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

while (true) {
  const audioData = getAudioData(eagle.minProcessSamples);
  const scores: number[] | null = await eagle.process(
    audioData,
    speakerProfile
  );
  if (scores) {
    // do something with the scores
  }
}
```

--------------------------------

### Export Speaker Profile

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Generate a binary representation of the enrolled speaker's voiceprint. This profile can be saved and reused later.

```typescript
const speakerProfile: Uint8Array = eagleProfiler.export();
```

--------------------------------

### Web Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/README.md

This TypeScript snippet shows how to create an Eagle engine instance with speaker profiles and process audio frames for real-time speaker scoring.

```APIDOC
## Web Speaker Recognition

### Description
Creates an `Eagle` engine instance with one or more speaker profiles and processes audio frames for real-time speaker scoring.

### Initialization
```typescript
const eagleModel = {
  publicPath: ${MODEL_RELATIVE_PATH},
  // or
  base64: ${MODEL_BASE64_STRING},
}

// Assumes speakerProfile is available from enrollment
const speakerProfile: EagleProfile = { /* ... exported profile ... */ }; 

const eagle = await Eagle.create(
        ${ACCESS_KEY},
        eagleModel,
        speakerProfile);
```

### Processing
```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
  // Replace with actual audio data retrieval logic
  return new Int16Array(numSamples);
}

while (true) {
  const audioData = getAudioData(eagle.frameLength);
  const scores: number[] = await eagle.process(audioData);
  // Process scores array
}
```
```

--------------------------------

### Test Speaker Recognition via Microphone

Source: https://github.com/picovoice/eagle/blob/main/demo/nodejs/README.md

Performs speaker recognition using microphone input against one or more pre-existing speaker profiles.

```bash
eagle-mic-demo --test --access_key ${ACCESS_KEY} --input_profile_paths ${INPUT_PROFILE_PATH_1 ...}
```

--------------------------------

### Enroll Speaker Audio

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Enroll audio data for a speaker using the EagleProfiler. The audio must be 16-bit linearly-encoded, single-channel PCM, and the number of samples must equal eagleProfiler.frameLength. The process returns enrollment progress percentage.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

let percentage = 0;
while (percentage < 100) {
  const audioData = getAudioData(eagleProfiler.frameLength);

  percentage = EagleProfilerEnrollResult = await eagleProfiler.enroll(audioData);
}
```

--------------------------------

### Release Eagle Resources (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Releases the resources allocated for speaker recognition scores and the Eagle engine handle. This should be called when the engine is no longer needed.

```c
pv_eagle_scores_delete(scores);
pv_eagle_delete(handle);
```

--------------------------------

### Process Audio for Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Process audio frames using the Eagle engine and compare them against provided speaker profiles. The audio must be single-channel, 16-bit linear PCM, with a frame size defined by Eagle.frameLength.

```swift
func get_next_process_audio_data(numSamples: Int) -> [Int16] {
    // ...
}

do {
    let profileScores = try eagle.process(pcm: get_next_process_audio_data(eagle.minProcessSamples()), speakerProfiles: [speakerProfile])
} catch { }
```

--------------------------------

### Add Eagle Android Dependency

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Include the Eagle Android SDK in your app's build.gradle file. Ensure mavenCentral() is also included in your top-level build.gradle.

```groovy
dependencies {
    // ...
    implementation 'ai.picovoice:eagle-android:${LATEST_VERSION}'
}
```

--------------------------------

### Export Speaker Profile

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Export the enrolled speaker's voiceprint as an EagleProfile object after enrollment is complete. This profile can be converted to bytes for storage.

```python
speaker_profile = eagle_profiler.export()
```

--------------------------------

### Enroll Speaker Audio

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Continuously feed audio frames to the EagleProfiler until enrollment reaches 100%. The audio must be 16-bit linearly-encoded, single-channel PCM, with the number of samples matching eagleProfiler.frameLength.

```swift
func get_next_audio_frame(frameLength: Int) -> [Int16] {
    // ...
}

do {
    var percentage = 0.0
    while (percentage < 100.0) {
        percentage = try eagleProfiler.enroll(pcm: get_next_audio_frame())
    }
} catch { }
```

--------------------------------

### Reset Eagle Profiler

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Reset the EagleProfiler to clear all enrollment data and begin a new enrollment session for a different speaker.

```python
eagle_profiler.reset()
```

--------------------------------

### Export Eagle Profile

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Exports the enrolled speaker profile after enrollment is complete. The profile can be converted to bytes for storage.

```java
try {
    EagleProfile speakerProfile = eagleProfiler.export();
} catch (EagleException e) { }
```

--------------------------------

### Process Audio for Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Process audio chunks to compare against enrolled speaker profiles. Returns similarity scores or None if no speaker is confidently recognized. Ensure audio is 16-bit linearly-encoded, single-channel PCM with a sample rate matching eagle.sample_rate.

```python
def get_next_audio_chunk(num_samples):
    pass


while True:
    scores = eagle.process(get_next_audio_chunk(eagle.min_process_samples), speaker_profiles)
```

--------------------------------

### Process Audio for Speaker Recognition

Source: https://github.com/picovoice/eagle/blob/main/README.md

Process audio data using the Eagle engine and one or more speaker profiles. The function returns scores or null if no match is found.

```typescript
function getAudioData(numSamples): Int16Array {
  // get audio frame of size `numSamples`
}

while (true) {
  const audioData = getAudioData(eagle.minProcessSamples);
  const scores: number[] | null = await eagle.process(
    audioData.
    speakerProfile
  );
  if (scores) {
    // do something with the scores
  }
}
```

--------------------------------

### Reset EagleProfiler

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Use the reset() method to clear all existing data and begin a new speaker enrollment session.

```swift
eagleProfiler.reset()
```

--------------------------------

### Export Enrolled Speaker Profile

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

After enrollment is complete (100%), export the generated voiceprint as an EagleProfile object. This profile can then be used for recognition.

```swift
let speakerProfile = try eagleProfiler.export()
```

--------------------------------

### Release Eagle Profiler Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/web/README.md

Explicitly release resources used by the EagleProfiler when enrollment is complete or no longer needed. Use terminate() if running on a worker thread.

```typescript
eagleProfiler.release();

// if on worker thread
etjeagleProfiler.terminate();
```

--------------------------------

### Release Eagle Engine Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Explicitly release the resources held by the Eagle engine when recognition is complete to free up system memory.

```typescript
eagle.release();
```

--------------------------------

### Delete Eagle Profiler (C)

Source: https://github.com/picovoice/eagle/blob/main/README.md

Releases the resources acquired by the Eagle profiler instance. This should be called after the speaker profile has been exported.

```c
pv_eagle_profiler_delete(eagle_profiler);
```

--------------------------------

### Release Eagle Profiler Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/nodejs/README.md

Explicitly release the resources held by the EagleProfiler when it is no longer needed to prevent memory leaks.

```typescript
eagleProfiler.release();
```

--------------------------------

### Delete Eagle Recognizer Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Explicitly release the resources used by the Eagle recognizer when it is no longer needed to prevent memory leaks.

```python
eagle.delete()
```

--------------------------------

### Release EagleProfiler Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/android/README.md

Explicitly releases resources used by the EagleProfiler. This should be called when the profiler is no longer needed.

```java
eagleProfiler.delete();
```

--------------------------------

### Delete Eagle Profiler Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/python/README.md

Explicitly release the resources used by the EagleProfiler when it is no longer needed to prevent memory leaks.

```python
eagle_profiler.delete()
```

--------------------------------

### Delete EagleProfiler Resources

Source: https://github.com/picovoice/eagle/blob/main/binding/ios/README.md

Explicitly release the resources used by the EagleProfiler when it is no longer needed to prevent memory leaks.

```swift
eagleProfiler.delete()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.