Merge pull request #60 from mutablelogic/v1

Added the beginning of the API

Author: djthorpe

Makefile

@@ -30,7 +30,7 @@ ifeq ($(GGML_CUDA),1)
 endif
 
 # Targets
-all: whisper
+all: whisper api
 
 # Generate the pkg-config files
 generate: mkdir go-tidy
@@ -42,6 +42,11 @@ whisper: mkdir generate go-tidy libwhisper libggml
 	@echo "Building whisper"
 	@PKG_CONFIG_PATH=${ROOT_PATH}/${BUILD_DIR} ${GO} build ${BUILD_FLAGS} -o ${BUILD_DIR}/whisper ./cmd/whisper
 
+# Make api
+api: mkdir go-tidy
+	@echo "Building api"
+	@${GO} build ${BUILD_FLAGS} -o ${BUILD_DIR}/api ./cmd/api
+
 # Build docker container
 docker: docker-dep submodule
 	@echo build docker image: ${BUILD_TAG} for ${OS}/${ARCH}

cmd/api/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"syscall"
+
+	// Packages
+	kong "github.com/alecthomas/kong"
+	tablewriter "github.com/djthorpe/go-tablewriter"
+	opt "github.com/mutablelogic/go-client"
+	ctx "github.com/mutablelogic/go-server/pkg/context"
+	client "github.com/mutablelogic/go-whisper/pkg/client"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Globals struct {
+	Url   string `name:"url" help:"URL of whisper service (can be set from WHISPER_URL env)" default:"${WHISPER_URL}"`
+	Debug bool   `name:"debug" help:"Enable debug output"`
+
+	// Writer, service and context
+	writer *tablewriter.Writer
+	client *client.Client
+	ctx    context.Context
+}
+
+type CLI struct {
+	Globals
+
+	Ping PingCmd `cmd help:"Ping the whisper service"`
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	defaultEndpoint = "http://localhost:8080/api/v1"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// MAIN
+
+func main() {
+	// The name of the executable
+	name, err := os.Executable()
+	if err != nil {
+		panic(err)
+	} else {
+		name = filepath.Base(name)
+	}
+
+	// Create a cli parser
+	cli := CLI{}
+	cmd := kong.Parse(&cli,
+		kong.Name(name),
+		kong.Description("speech transcription and translation service client"),
+		kong.UsageOnError(),
+		kong.ConfigureHelp(kong.HelpOptions{Compact: true}),
+		kong.Vars{
+			"WHISPER_URL": envOrDefault("WHISPER_URL", defaultEndpoint),
+		},
+	)
+
+	// Set whisper client options
+	opts := []opt.ClientOpt{}
+	if cli.Globals.Debug {
+		opts = append(opts, opt.OptTrace(os.Stderr, true))
+	}
+
+	// Create a whisper client
+	client, err := client.New(cli.Globals.Url, opts...)
+	if err != nil {
+		cmd.FatalIfErrorf(err)
+		return
+	} else {
+		cli.Globals.client = client
+	}
+
+	// Create a tablewriter object with text output
+	writer := tablewriter.New(os.Stdout, tablewriter.OptOutputText())
+	cli.Globals.writer = writer
+
+	// Create a context
+	cli.Globals.ctx = ctx.ContextForSignal(os.Interrupt, syscall.SIGQUIT)
+
+	// Run the command
+	if err := cmd.Run(&cli.Globals); err != nil {
+		cmd.FatalIfErrorf(err)
+	}
+}
+
+func envOrDefault(name, def string) string {
+	if value := os.Getenv(name); value != "" {
+		return value
+	} else {
+		return def
+	}
+}

cmd/api/ping.go

@@ -0,0 +1,10 @@
+package main
+
+type PingCmd struct{}
+
+func (cmd *PingCmd) Run(ctx *Globals) error {
+	if err := ctx.client.Ping(ctx.ctx); err != nil {
+		return err
+	}
+	return ctx.writer.Write("OK")
+}

cmd/whisper/transcribe.go

@@ -36,7 +36,8 @@ func (cmd *TranscribeCmd) Run(ctx *Globals) error {
 	defer f.Close()
 
 	// Create a segmenter - read segments based on requested segment size
-	segmenter, err := segmenter.New(f, 0, whisper.SampleRate)
+	// TODO
+	segmenter, err := segmenter.NewReader(f, 0, whisper.SampleRate)
 	if err != nil {
 		return err
 	}

etc/Dockerfile

@@ -1,4 +1,4 @@
-ARG BASE_TAG=0.0.10-4-g6421fd2
+ARG BASE_TAG=1.0.0
 ARG BASE_DEV_CONTAINER=ghcr.io/mutablelogic/cuda-dev:${BASE_TAG}
 ARG BASE_RUN_CONTAINER=ghcr.io/mutablelogic/cuda-rt:${BASE_TAG}
 ARG CUDA_DOCKER_ARCH=all
@@ -14,7 +14,7 @@ ARG ARCH
 ARG OS
 
 RUN apt-get -y update \
- && apt-get -y install software-properties-common curl libgomp1 \
+ && apt-get -y install software-properties-common curl \
  && add-apt-repository -y ppa:ubuntuhandbook1/ffmpeg6 \
  && apt-get -y update \
  && apt-get -y install libavformat-dev libavcodec-dev libavdevice-dev libavfilter-dev libavutil-dev libswscale-dev libswresample-dev
@@ -35,12 +35,12 @@ RUN make -j$(nproc)
 # Setup runtime container
 FROM ${BASE_RUN_CONTAINER} AS runtime
 RUN apt-get -y update \
- && apt-get -y install software-properties-common libgomp1 \
+ && apt-get -y install software-properties-common \
  && add-apt-repository -y ppa:ubuntuhandbook1/ffmpeg6 \
  && apt-get -y update \
  && apt-get -y install libavformat60 libavcodec60 libavdevice60 libavfilter9 libavutil58 libswscale7 libswresample4 
 COPY --from=build --chmod=755 /app/build/whisper /usr/local/bin/whisper
-COPY --from=build /app/build/whisper /usr/local/bin/whisper
+COPY --from=build --chmod=755 /app/build/api /usr/local/bin/api
 COPY --chmod=755 etc/entrypoint.sh .
 
 # Entrypoint when running the server

pkg/api/transcribe.go

@@ -101,7 +101,7 @@ func TranscribeFile(ctx context.Context, service *whisper.Whisper, w http.Respon
 	defer f.Close()
 
 	// Create a segmenter - read segments based on requested segment size
-	segmenter, err := segmenter.New(f, req.SegmentDur(), whisper.SampleRate)
+	segmenter, err := segmenter.NewReader(f, req.SegmentDur(), whisper.SampleRate)
 	if err != nil {
 		httpresponse.Error(w, http.StatusBadRequest, err.Error())
 		return

pkg/client/client.go

@@ -34,6 +34,13 @@ func New(endpoint string, opts ...client.ClientOpt) (*Client, error) {
 	}
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// PING
+
+func (c *Client) Ping(ctx context.Context) error {
+	return c.DoWithContext(ctx, client.MethodGet, nil, client.OptPath("health"))
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // MODELS
 

pkg/segmenter/segmenter.go

@@ -31,13 +31,15 @@ type SegmentFunc func(time.Duration, []float32) error
 //////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-// Create a new segmenter for a specific "dur" duration of samples with
-// a reader r. If dur is zero then no segmenting is performed, the whole
+// Create a new segmenter with a reader r which segments raw audio of 'dur'
+// length. If dur is zero then no segmenting is performed, the whole
 // audio file is read, which could cause some memory issues.
+//
 // The sample rate is the number of samples per second.
+//
 // At the moment, the audio format is auto-detected, but there should be
 // a way to specify the audio format.
-func New(r io.Reader, dur time.Duration, sample_rate int) (*Segmenter, error) {
+func NewReader(r io.Reader, dur time.Duration, sample_rate int) (*Segmenter, error) {
 	segmenter := new(Segmenter)
 
 	// Check arguments
@@ -136,12 +138,3 @@ func (s *Segmenter) Decode(ctx context.Context, fn SegmentFunc) error {
 	// Return success
 	return nil
 }
-
-// Return the file duration from the file or timestamp
-func (s *Segmenter) Duration() time.Duration {
-	if s.reader != nil {
-		return s.reader.Duration()
-	} else {
-		return s.ts + time.Duration(len(s.buf))*time.Second/time.Duration(s.sample_rate)
-	}
-}

pkg/segmenter/silence.go

@@ -0,0 +1,61 @@
+package segmenter
+
+import (
+	"math"
+	"time"
+	// Packages
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+// silence is a silence detector and audio booster for raw samples
+// typical values are gain=20, threshold=0.003, timeout=2s
+type silence struct {
+	Gain      float64       // gain in decibels
+	Threshold float64       // threshold for silence
+	Timeout   time.Duration // duration of silence before stopping recording
+
+	// When we last started recording
+	t time.Time
+	r bool
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Increase gain and compute energy of a frame of audio data, return true
+// if the frame of data should be recorded, false if it should be ignored
+func (s *silence) Process(data []float32) bool {
+	energy := process(data, float32(math.Pow(10, s.Gain/20.0)))
+
+	// Compute the gain
+	if energy > s.Threshold {
+		if s.t.IsZero() {
+			// Transition from silence to recording
+			s.r = true
+		}
+		s.t = time.Now()
+	} else if !s.t.IsZero() {
+		if time.Since(s.t) > s.Timeout {
+			// Transition from recording to silence
+			s.t = time.Time{}
+			s.r = false
+		}
+	}
+	return s.r
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+// Increase gain and compute energy of a frame of audio data, return the
+// energy of the frame of data
+func process(data []float32, gain float32) float64 {
+	energy := float64(0)
+	for i := 0; i < len(data); i++ {
+		data[i] *= gain
+		energy += float64(data[i]) * float64(data[i])
+	}
+	return energy / math.Sqrt(float64(len(data)))
+}