Prepare Round 1 model profile QA baseline

Ariver

2026-06-02 3fbceec8de833416bf1ae049f959f222c3f1a4a0

 privatevoice.src/internal/engine/engine_darwin.go

File was renamed from VoiceSnapGo/internal/engine/engine_darwin.go
@@ -5,9 +5,10 @@
import (
   "fmt"
   "voicesnap/internal/logger"
   "voicesnap/internal/model"

   sherpa "github.com/k2-fsa/sherpa-onnx-go/sherpa_onnx"
   _ "github.com/k2-fsa/sherpa-onnx-go-macos"
   sherpa "github.com/k2-fsa/sherpa-onnx-go/sherpa_onnx"
)

type sherpaEngine struct {
@@ -15,27 +16,17 @@
   hwInfo     string
}

func newPlatformEngine() (Engine, error) {
   modelPath := ModelPath()
   tokensPath := TokensPath()

   // Try CoreML first, then CPU fallback
   providers := []struct {
      name     string
      provider string
   }{
      {"CoreML (Apple Neural Engine)", "coreml"},
      {"CPU", "cpu"},
   }
func newPlatformEngine(resolved model.ResolvedModel) (Engine, error) {
   providers := darwinProviders(resolved.ProviderOrder)

   for _, p := range providers {
      config := sherpa.OfflineRecognizerConfig{}
      config.FeatConfig.SampleRate = 16000
      config.FeatConfig.FeatureDim = 80
      config.ModelConfig.SenseVoice.Model = modelPath
      config.ModelConfig.SenseVoice.Model = resolved.Files["model"]
      config.ModelConfig.SenseVoice.UseInverseTextNormalization = 1
      config.ModelConfig.Tokens = tokensPath
      config.ModelConfig.NumThreads = 4
      config.ModelConfig.Tokens = resolved.Files["tokens"]
      config.ModelConfig.NumThreads = resolved.Profile.NumThreads
      config.ModelConfig.Provider = p.provider
      config.DecodingMethod = "greedy_search"

@@ -54,6 +45,37 @@
   return nil, fmt.Errorf("failed to initialize sherpa-onnx with any provider")
}

func darwinProviders(providerOrder []string) []struct {
   name     string
   provider string
} {
   names := map[string]string{
      "coreml": "CoreML (Apple Neural Engine)",
      "cpu":    "CPU",
   }
   providers := make([]struct {
      name     string
      provider string
   }, 0, len(providerOrder))
   for _, provider := range providerOrder {
      name, ok := names[provider]
      if !ok {
         continue
      }
      providers = append(providers, struct {
         name     string
         provider string
      }{name: name, provider: provider})
   }
   if len(providers) == 0 {
      providers = append(providers, struct {
         name     string
         provider string
      }{name: "CPU", provider: "cpu"})
   }
   return providers
}

func (e *sherpaEngine) Recognize(samples []float32) (string, error) {
   stream := sherpa.NewOfflineStream(e.recognizer)
   defer sherpa.DeleteOfflineStream(stream)