### Understand Speech Segment Structure in Go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

The `Segment` struct provides timing information for detected speech. `SpeechStartAt` and `SpeechEndAt` indicate the start and end times in seconds. A `SpeechEndAt` of 0 signifies ongoing speech.

```go
package main

import (
    "fmt"
    "log"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    cfg := speech.DetectorConfig{
        ModelPath:            "/path/to/silero_vad.onnx",
        SampleRate:           16000,
        Threshold:            0.5,
        MinSilenceDurationMs: 100,
        SpeechPadMs:          30,
    }

    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }
    defer detector.Destroy()

    samples := loadAudioSamples("/path/to/audio.pcm")
    segments, _ := detector.Detect(samples)

    for _, seg := range segments {
        // speech.Segment has:
        //   SpeechStartAt float64 - relative timestamp in seconds when speech begins
        //   SpeechEndAt float64   - relative timestamp in seconds when speech ends

        if seg.SpeechEndAt == 0 {
            fmt.Printf("Ongoing speech starting at %.3f seconds\n", seg.SpeechStartAt)
        } else {
            duration := seg.SpeechEndAt - seg.SpeechStartAt
            fmt.Printf("Speech from %.3f to %.3f (duration: %.3f seconds)\n",
                seg.SpeechStartAt, seg.SpeechEndAt, duration)
        }
    }
}

func loadAudioSamples(path string) []float32 {
    return nil
}
```

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

### Detect Speech Segments using Silero VAD Go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Processes audio samples to detect speech segments and returns their start and end timestamps. It operates on audio windows and uses a configurable threshold. The function returns a slice of Segment structs with timestamps in seconds. Requires the ONNX model file and PCM audio data.

```go
package main

import (
    "encoding/binary"
    "fmt"
    "log"
    "math"
    "os"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    cfg := speech.DetectorConfig{
        ModelPath:            "/path/to/silero_vad.onnx",
        SampleRate:           16000,
        Threshold:            0.5,
        MinSilenceDurationMs: 100,
        SpeechPadMs:          30,
    }

    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }
    defer detector.Destroy()

    // Load PCM audio samples (32-bit float, little-endian)
    samples, err := loadPCMSamples("/path/to/audio.pcm")
    if err != nil {
        log.Fatalf("Failed to load samples: %v", err)
    }

    // Detect speech segments
    segments, err := detector.Detect(samples)
    if err != nil {
        log.Fatalf("Detection failed: %v", err)
    }

    // Process detected segments
    for i, segment := range segments {
        fmt.Printf("Segment %d: %.3f - %.3f seconds\n",
            i+1, segment.SpeechStartAt, segment.SpeechEndAt)
    }
    // Example output:
    // Segment 1: 1.056 - 1.632 seconds
    // Segment 2: 2.880 - 3.232 seconds
    // Segment 3: 4.448 - 0.000 seconds (ongoing speech, no end detected yet)
}

func loadPCMSamples(path string) ([]float32, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, err
    }

    samples := make([]float32, 0, len(data)/4)
    for i := 0; i < len(data); i += 4 {
        samples = append(samples, math.Float32frombits(binary.LittleEndian.Uint32(data[i:i+4])))
    }
    return samples, nil
}
```

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

### Reset Detector State in Silero VAD Go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Resets the internal state of the speech detector, clearing any accumulated context or segment tracking. This is crucial when processing new, independent audio streams to ensure accurate results. Call this method before starting a new detection session.

```go
package main

import (
    "fmt"
    "log"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    cfg := speech.DetectorConfig{
        ModelPath:  "/path/to/silero_vad.onnx",
        SampleRate: 16000,
        Threshold:  0.5,
    }

    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }
    defer detector.Destroy()

    // Process first audio stream
    samples1 := loadAudioSamples("/path/to/audio1.pcm")
    segments1, _ := detector.Detect(samples1)
    fmt.Printf("Stream 1: Found %d segments\n", len(segments1))

    // Reset state before processing new stream
    if err := detector.Reset(); err != nil {
        log.Fatalf("Reset failed: %v", err)
    }

    // Process second audio stream with clean state
    samples2 := loadAudioSamples("/path/to/audio2.pcm")
    segments2, _ := detector.Detect(samples2)
    fmt.Printf("Stream 2: Found %d segments\n", len(segments2))
}

func loadAudioSamples(path string) []float32 {
    // Implementation to load PCM samples
    return nil
}
```

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

### Create Speech Detector Instance - silero-vad-go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Initializes a new speech detector instance using the provided configuration. This function loads the Silero VAD ONNX model and sets up the ONNX Runtime session. It requires a valid model path, sample rate, and optional parameters for detection sensitivity and padding.

```go
package main

import (
    "fmt"
    "log"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    // Configure the speech detector
    cfg := speech.DetectorConfig{
        ModelPath:            "/path/to/silero_vad.onnx", // Path to Silero VAD v5 model
        SampleRate:           16000,                       // 8000 or 16000 Hz
        Threshold:            0.5,                         // Speech probability threshold (0-1)
        MinSilenceDurationMs: 250,                         // Silence duration before splitting segments
        SpeechPadMs:          30,                          // Padding to avoid aggressive cutting
        LogLevel:             speech.LogLevelWarn,         // ONNX Runtime log level
    }

    // Create the detector
    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }
    defer detector.Destroy()

    fmt.Println("Speech detector initialized successfully")
}
```

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

### Validate Detector Configuration - silero-vad-go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Checks if the provided detector configuration is valid before creating a detector instance. It verifies parameters like model path, sample rate, and threshold to ensure they meet the library's requirements. Returns an error if any configuration value is invalid.

```go
package main

import (
    "fmt"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    // Valid configuration
    validCfg := speech.DetectorConfig{
        ModelPath:            "/path/to/silero_vad.onnx",
        SampleRate:           16000,
        Threshold:            0.5,
        MinSilenceDurationMs: 100,
        SpeechPadMs:          20,
    }

    if err := validCfg.IsValid(); err != nil {
        fmt.Printf("Invalid config: %v\n", err)
    } else {
        fmt.Println("Configuration is valid")
    }

    // Invalid configuration examples
    invalidCfg := speech.DetectorConfig{
        ModelPath:  "/path/to/model.onnx",
        SampleRate: 48000, // Invalid: only 8000 and 16000 supported
        Threshold:  0.5,
    }

    if err := invalidCfg.IsValid(); err != nil {
        fmt.Printf("Validation error: %v\n", err)
        // Output: Validation error: invalid SampleRate: valid values are 8000 and 16000
    }
}
```

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

### Adjust Detector Sensitivity with SetThreshold in Go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Dynamically adjusts the speech detection threshold of an existing detector. Higher values increase sensitivity, while lower values reduce it. This method allows fine-tuning without reinitializing the detector.

```go
package main

import (
    "fmt"
    "log"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    cfg := speech.DetectorConfig{
        ModelPath:  "/path/to/silero_vad.onnx",
        SampleRate: 16000,
        Threshold:  0.5, // Initial threshold
    }

    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }
    defer detector.Destroy()

    samples := loadAudioSamples("/path/to/audio.pcm")

    // Detect with default threshold
    segments, _ := detector.Detect(samples)
    fmt.Printf("With threshold 0.5: %d segments detected\n", len(segments))

    detector.Reset()

    // Increase threshold for stricter detection
    detector.SetThreshold(0.7)
    segments, _ = detector.Detect(samples)
    fmt.Printf("With threshold 0.7: %d segments detected\n", len(segments))

    detector.Reset()

    // Decrease threshold for more sensitive detection
    detector.SetThreshold(0.3)
    segments, _ = detector.Detect(samples)
    fmt.Printf("With threshold 0.3: %d segments detected\n", len(segments))
}

func loadAudioSamples(path string) []float32 {
    return nil
}
```

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

### Run Single Inference with Silero VAD Go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Performs a single inference pass on an audio window to determine speech probability. This is a lower-level function useful for custom pipelines. It requires audio samples in specific window sizes (512 for 16kHz, 256 for 8kHz). Returns a float between 0 and 1 representing speech probability.

```go
package main

import (
    "fmt"
    "log"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    cfg := speech.DetectorConfig{
        ModelPath:  "/path/to/silero_vad.onnx",
        SampleRate: 16000,
        Threshold:  0.5,
    }

    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }
    defer detector.Destroy()

    // Process audio in 512-sample windows for 16kHz
    windowSize := 512
    audioSamples := make([]float32, windowSize) // Your audio data here

    // Run inference on a single window
    probability, err := detector.Infer(audioSamples)
    if err != nil {
        log.Fatalf("Inference failed: %v", err)
    }

    fmt.Printf("Speech probability: %.4f\n", probability)

    if probability >= 0.5 {
        fmt.Println("Speech detected!")
    } else {
        fmt.Println("No speech detected")
    }
}
```

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

### Release Detector Resources with Destroy in Go

Source: https://context7.com/streamer45/silero-vad-go/llms.txt

Releases all resources allocated by the detector, including ONNX Runtime sessions and memory. It is crucial to call this method when the detector is no longer needed to prevent memory leaks. The `defer` statement is recommended for automatic cleanup.

```go
package main

import (
    "log"

    "github.com/streamer45/silero-vad-go/speech"
)

func main() {
    cfg := speech.DetectorConfig{
        ModelPath:  "/path/to/silero_vad.onnx",
        SampleRate: 16000,
        Threshold:  0.5,
    }

    detector, err := speech.NewDetector(cfg)
    if err != nil {
        log.Fatalf("Failed to create detector: %v", err)
    }

    // Use detector for processing...
    // Always destroy when done
    if err := detector.Destroy(); err != nil {
        log.Printf("Warning: Failed to destroy detector: %v", err)
    }

    // Or use defer for automatic cleanup
    detector2, _ := speech.NewDetector(cfg)
    defer func() {
        if err := detector2.Destroy(); err != nil {
            log.Printf("Cleanup error: %v", err)
        }
    }()
    // detector2 will be destroyed when function exits
}
```

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