speechflow 1.3.1 → 1.3.2

package/src/speechflow-node-t2t-sentence.ts

@@ -29,12 +29,12 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
     public static name = "sentence"
 
     /*  internal state  */
-    private static speexInitialized = false
     private queue      = new utils.Queue<TextQueueElement>()
     private queueRecv  = this.queue.pointerUse("recv")
     private queueSplit = this.queue.pointerUse("split")
     private queueSend  = this.queue.pointerUse("send")
     private destroyed  = false
+    private workingOffTimer: ReturnType<typeof setTimeout> | null = null
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -53,11 +53,7 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
         /*  clear destruction flag  */
         this.destroyed = false
 
-        /*  pass-through logging  */
-        const log = (level: string, msg: string) => { this.log(level, msg) }
-
         /*  work off queued audio frames  */
-        let workingOffTimer: ReturnType<typeof setTimeout> | null = null
         let workingOff = false
         const workOffQueue = async () => {
             if (this.destroyed)
@@ -67,14 +63,14 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
             if (workingOff)
                 return
             workingOff = true
-            if (workingOffTimer !== null) {
-                clearTimeout(workingOffTimer)
-                workingOffTimer = null
+            if (this.workingOffTimer !== null) {
+                clearTimeout(this.workingOffTimer)
+                this.workingOffTimer = null
             }
             this.queue.off("write", workOffQueue)
 
             /*  try to work off one or more chunks  */
-            while (true) {
+            while (!this.destroyed) {
                 const element = this.queueSplit.peek()
                 if (element === undefined)
                     break
@@ -136,10 +132,12 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
                 }
             }
 
-            /*  re-initiate working off round  */
+            /*  re-initiate working off round (if still not destroyed)  */
             workingOff = false
-            workingOffTimer = setTimeout(workOffQueue, 100)
-            this.queue.once("write", workOffQueue)
+            if (!this.destroyed) {
+                this.workingOffTimer = setTimeout(workOffQueue, 100)
+                this.queue.once("write", workOffQueue)
+            }
         }
         this.queue.once("write", workOffQueue)
 
@@ -153,12 +151,14 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
 
             /*  receive text chunk (writable side of stream)  */
             write (chunk: SpeechFlowChunk, encoding, callback) {
-                if (Buffer.isBuffer(chunk.payload))
+                if (self.destroyed)
+                    callback(new Error("stream already destroyed"))
+                else if (Buffer.isBuffer(chunk.payload))
                     callback(new Error("expected text input as string chunks"))
                 else if (chunk.payload.length === 0)
                     callback()
                 else {
-                    log("info", `received text: ${JSON.stringify(chunk.payload)}`)
+                    self.log("info", `received text: ${JSON.stringify(chunk.payload)}`)
                     self.queueRecv.append({ type: "text-frame", chunk })
                     callback()
                 }
@@ -166,6 +166,10 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
 
             /*  receive no more text chunks (writable side of stream)  */
             final (callback) {
+                if (self.destroyed) {
+                    callback()
+                    return
+                }
                 /*  signal end of file  */
                 self.queueRecv.append({ type: "text-eof" })
                 callback()
@@ -173,8 +177,12 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
 
             /*  send text chunk(s) (readable side of stream)  */
             read (_size) {
-                /*  flush pending audio chunks  */
+                /*  flush pending text chunks  */
                 const flushPendingChunks = () => {
+                    if (self.destroyed) {
+                        this.push(null)
+                        return
+                    }
                     const element = self.queueSend.peek()
                     if (element !== undefined
                         && element.type === "text-eof") {
@@ -196,13 +204,13 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
                             else if (element.type === "text-frame"
                                 && element.complete !== true)
                                 break
-                            log("info", `send text: ${JSON.stringify(element.chunk.payload)}`)
+                            self.log("info", `send text: ${JSON.stringify(element.chunk.payload)}`)
                             this.push(element.chunk)
                             self.queueSend.walk(+1)
                             self.queue.trim()
                         }
                     }
-                    else
+                    else if (!self.destroyed)
                         self.queue.once("write", flushPendingChunks)
                 }
                 flushPendingChunks()
@@ -212,13 +220,22 @@ export default class SpeechFlowNodeSentence extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
+        /*  indicate destruction  */
+        this.destroyed = true
+
+        /*  clean up timer  */
+        if (this.workingOffTimer !== null) {
+            clearTimeout(this.workingOffTimer)
+            this.workingOffTimer = null
+        }
+
+        /*  remove any pending event listeners  */
+        this.queue.removeAllListeners("write")
+
         /*  close stream  */
         if (this.stream !== null) {
             this.stream.destroy()
             this.stream = null
         }
-
-        /*  indicate destruction  */
-        this.destroyed = true
     }
 }

package/src/speechflow-node-t2t-transformers.ts

@@ -104,7 +104,7 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
-        let model: string = ""
+        let model = ""
 
         /*  track download progress when instantiating Transformers engine and model  */
         const progressState = new Map<string, number>()
@@ -138,7 +138,6 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                 progress_callback: progressCallback
             })
             this.translator = await pipeline
-            clearInterval(interval)
             if (this.translator === null)
                 throw new Error("failed to instantiate translator pipeline")
         }
@@ -151,13 +150,15 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                 progress_callback: progressCallback
             })
             this.generator = await pipeline
-            clearInterval(interval)
             if (this.generator === null)
                 throw new Error("failed to instantiate generator pipeline")
         }
         else
             throw new Error("invalid model")
 
+        /*  clear progress interval again  */
+        clearInterval(interval)
+
         /*  provide text-to-text translation  */
         const translate = async (text: string) => {
             if (this.params.model === "OPUS") {

package/src/speechflow-node-x2x-filter.ts

@@ -94,13 +94,13 @@ export default class SpeechFlowNodeFilter extends SpeechFlowNode {
                 const m = self.params.var.match(/^meta:(.+)$/)
                 if (m !== null)
                     val1 = chunk.meta.get(m[1]) ?? ""
-                else if (self.params.key === "payload:length")
+                else if (self.params.var === "payload:length")
                     val1 = chunk.payload.length
-                else if (self.params.key === "payload:text")
+                else if (self.params.var === "payload:text")
                     val1 = (self.params.type === "text" ? chunk.payload as string : "")
-                else if (self.params.key === "time:start")
+                else if (self.params.var === "time:start")
                     val1 = chunk.timestampStart.toMillis()
-                else if (self.params.key === "time:end")
+                else if (self.params.var === "time:end")
                     val1 = chunk.timestampEnd.toMillis()
                 if (comparison(val1, self.params.op, val2)) {
                     self.log("info", `[${self.params.name}]: passing through ${chunk.type} chunk`)

package/src/speechflow-node-x2x-trace.ts

@@ -75,7 +75,7 @@ export default class SpeechFlowNodeTrace extends SpeechFlowNode {
                 }
                 else {
                     if (type === "text")
-                        log("debug", `${type} chunk: type=${chunk.type} ` +
+                        log("debug", `chunk: type=${chunk.type} ` +
                             `kind=${chunk.kind} ` +
                             `start=${fmtTime(chunk.timestampStart)} ` +
                             `end=${fmtTime(chunk.timestampEnd)} ` +

package/src/speechflow-node-xio-device.ts

@@ -159,8 +159,7 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
 
             /*  convert regular stream into object-mode stream  */
             const wrapper = utils.createTransformStreamForReadableSide("audio", () => this.timeZero)
-            this.stream.pipe(wrapper)
-            this.stream = wrapper
+            this.stream = Stream.compose(this.stream, wrapper)
         }
         else if (this.params.mode === "w") {
             /*  output device  */
@@ -180,8 +179,7 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
 
             /*  convert regular stream into object-mode stream  */
             const wrapper = utils.createTransformStreamForWritableSide()
-            wrapper.pipe(this.stream)
-            this.stream = wrapper
+            this.stream = Stream.compose(wrapper, this.stream)
         }
         else
             throw new Error(`device "${device.id}" does not have any input or output channels`)
@@ -200,13 +198,19 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
         /*  shutdown PortAudio  */
         if (this.io !== null) {
             await new Promise<void>((resolve, reject) => {
-                this.io!.abort(() => {
-                    resolve()
+                this.io!.abort((err?: Error) => {
+                    if (err)
+                        reject(err)
+                    else
+                        resolve()
                 })
             })
             await new Promise<void>((resolve, reject) => {
-                this.io!.quit(() => {
-                    resolve()
+                this.io!.quit((err?: Error) => {
+                    if (err)
+                        reject(err)
+                    else
+                        resolve()
                 })
             })
             this.io = null

package/src/speechflow-node-xio-file.ts

@@ -178,9 +178,15 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
     async close () {
         /*  shutdown stream  */
         if (this.stream !== null) {
-            await new Promise<void>((resolve) => {
-                if (this.stream instanceof Stream.Writable || this.stream instanceof Stream.Duplex)
-                    this.stream.end(() => { resolve() })
+            await new Promise<void>((resolve, reject) => {
+                if (this.stream instanceof Stream.Writable || this.stream instanceof Stream.Duplex) {
+                    this.stream.end((err?: Error) => {
+                        if (err)
+                            reject(err)
+                        else
+                            resolve()
+                    })
+                }
                 else
                     resolve()
             })

package/src/speechflow-node-xio-mqtt.ts

@@ -83,7 +83,10 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
         this.broker.on("connect", (packet: MQTT.IConnackPacket) => {
             this.log("info", `connection opened to MQTT ${this.params.url}`)
             if (this.params.mode !== "w" && !packet.sessionPresent)
-                this.broker!.subscribe([ this.params.topicRead ], () => {})
+                this.broker!.subscribe([ this.params.topicRead ], (err) => {
+                    if (err)
+                        this.log("error", `failed to subscribe to MQTT topic "${this.params.topicRead}": ${err.message}`)
+                })
         })
         this.broker.on("reconnect", () => {
             this.log("info", `connection re-opened to MQTT ${this.params.url}`)
@@ -141,7 +144,7 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
-        /*  close Websocket server  */
+        /*  close MQTT broker  */
         if (this.broker !== null) {
             if (this.broker.connected)
                 this.broker.end()

package/src/speechflow-node-xio-websocket.ts

@@ -64,15 +64,15 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             const url = new URL(this.params.listen)
             const websockets = new Set<ws.WebSocket>()
             const chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
-            const server = new ws.WebSocketServer({
+            this.server = new ws.WebSocketServer({
                 host: url.hostname,
                 port: Number.parseInt(url.port),
                 path: url.pathname
             })
-            server.on("listening", () => {
+            this.server.on("listening", () => {
                 this.log("info", `listening on URL ${this.params.listen}`)
             })
-            server.on("connection", (ws, request) => {
+            this.server.on("connection", (ws, request) => {
                 const peer = `${request.socket.remoteAddress}:${request.socket.remotePort}`
                 this.log("info", `connection opened on URL ${this.params.listen} by peer ${peer}`)
                 websockets.add(ws)
@@ -105,7 +105,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                     chunkQueue.write(chunk)
                 })
             })
-            server.on("error", (error) => {
+            this.server.on("error", (error) => {
                 this.log("error", `error of some connection on URL ${this.params.listen}: ${error.message}`)
             })
             const type = this.params.type
@@ -124,7 +124,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                         callback(new Error("still no Websocket connections available"))
                     else {
                         const data = utils.streamChunkEncode(chunk)
-                        const results = []
+                        const results: Promise<void>[] = []
                         for (const websocket of websockets.values()) {
                             results.push(new Promise<void>((resolve, reject) => {
                                 websocket.send(data, (error) => {
@@ -175,12 +175,12 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             const chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
             this.client.addEventListener("message", (ev: MessageEvent) => {
                 if (this.params.mode === "w") {
-                    this.log("warning", `connection to URL ${this.params.listen}: ` +
+                    this.log("warning", `connection to URL ${this.params.connect}: ` +
                         "received remote data on write-only node")
                     return
                 }
                 if (!(ev.data instanceof ArrayBuffer)) {
-                    this.log("warning", `connection to URL ${this.params.listen}: ` +
+                    this.log("warning", `connection to URL ${this.params.connect}: ` +
                         "received non-binary message")
                     return
                 }
@@ -204,15 +204,15 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                         callback(new Error(`written chunk is not of ${type} type`))
                     else if (!client.OPEN)
                         callback(new Error("still no Websocket connection available"))
-                    const data = utils.streamChunkEncode(chunk)
-                    client.send(data)
-                    callback()
+                    else {
+                        const data = utils.streamChunkEncode(chunk)
+                        client.send(data)
+                        callback()
+                    }
                 },
                 read (size: number) {
                     if (mode === "w")
                         throw new Error("read operation on write-only node")
-                    if (!client.OPEN)
-                        throw new Error("still no Websocket connection available")
                     chunkQueue.read().then((chunk) => {
                         this.push(chunk, "binary")
                     })

package/src/speechflow-utils.ts

@@ -24,11 +24,19 @@ export function audioBufferDuration (
     channels     = 1,
     littleEndian = true
 ) {
+    /*  sanity check parameters  */
     if (!Buffer.isBuffer(buffer))
         throw new Error("invalid input (Buffer expected)")
     if (littleEndian !== true)
         throw new Error("only Little Endian supported")
+    if (sampleRate <= 0)
+        throw new Error("sample rate must be positive")
+    if (bitDepth <= 0 || bitDepth % 8 !== 0)
+        throw new Error("bit depth must be positive and multiple of 8")
+    if (channels <= 0)
+        throw new Error("channels must be positive")
 
+    /*  calculate duration  */
     const bytesPerSample = bitDepth / 8
     const totalSamples = buffer.length / (bytesPerSample * channels)
     return totalSamples / sampleRate
@@ -40,12 +48,23 @@ export function audioArrayDuration (
     sampleRate   = 48000,
     channels     = 1
 ) {
+    /*  sanity check parameters  */
+    if (arr.length === 0)
+        return 0
+    if (sampleRate <= 0)
+        throw new Error("sample rate must be positive")
+    if (channels <= 0)
+        throw new Error("channels must be positive")
+
+    /*  calculate duration  */
     const totalSamples = arr.length / channels
     return totalSamples / sampleRate
 }
 
 /*  helper function: convert Buffer in PCM/I16 to Float32Array in PCM/F32 format  */
 export function convertBufToF32 (buf: Buffer, littleEndian = true) {
+    if (buf.length % 2 !== 0)
+        throw new Error("buffer length must be even for 16-bit samples")
     const dataView = new DataView(buf.buffer)
     const arr = new Float32Array(buf.length / 2)
     for (let i = 0; i < arr.length; i++)
@@ -55,9 +74,15 @@ export function convertBufToF32 (buf: Buffer, littleEndian = true) {
 
 /*  helper function: convert Float32Array in PCM/F32 to Buffer in PCM/I16 format  */
 export function convertF32ToBuf (arr: Float32Array) {
+    if (arr.length === 0)
+        return Buffer.alloc(0)
     const int16Array = new Int16Array(arr.length)
-    for (let i = 0; i < arr.length; i++)
-        int16Array[i] = Math.max(-32768, Math.min(32767, Math.round(arr[i] * 32768)))
+    for (let i = 0; i < arr.length; i++) {
+        let sample = arr[i]
+        if (Number.isNaN(sample))
+            sample = 0
+        int16Array[i] = Math.max(-32768, Math.min(32767, Math.round(sample * 32768)))
+    }
     return Buffer.from(int16Array.buffer)
 }
 
@@ -274,26 +299,19 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
     }
     position (index?: number): number {
         if (index !== undefined) {
-            this.index = index
-            if (this.index < 0)
-                this.index = 0
-            else if (this.index >= this.queue.elements.length)
-                this.index = this.queue.elements.length
+            this.index = Math.max(0, Math.min(index, this.queue.elements.length))
             this.emit("position", this.index)
         }
         return this.index
     }
     walk (num: number) {
-        if (num > 0) {
-            for (let i = 0; i < num && this.index < this.queue.elements.length; i++)
-                this.index++
+        const indexOld = this.index
+        if (num > 0)
+            this.index = Math.min(this.index + num, this.queue.elements.length)
+        else if (num < 0)
+            this.index = Math.max(this.index + num, 0)
+        if (this.index !== indexOld)
             this.emit("position", { start: this.index })
-        }
-        else if (num < 0) {
-            for (let i = 0; i < Math.abs(num) && this.index > 0; i++)
-                this.index--
-            this.emit("position", { start: this.index })
-        }
     }
     walkForwardUntil (type: T["type"]) {
         while (this.index < this.queue.elements.length
@@ -330,12 +348,7 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
     peek (position?: number) {
         if (position === undefined)
             position = this.index
-        else {
-            if (position < 0)
-                position = 0
-            else if (position > this.queue.elements.length)
-                position = this.queue.elements.length
-        }
+        position = Math.max(0, Math.min(position, this.queue.elements.length))
         const element = this.queue.elements[position]
         this.queue.emit("read", { start: position, end: position })
         return element
@@ -351,11 +364,8 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
         let slice: T[]
         const start = this.index
         if (size !== undefined) {
-            if (size < 0)
-                size = 0
-            else if (size > this.queue.elements.length - this.index)
-                size = this.queue.elements.length - this.index
-            slice = this.queue.elements.slice(this.index, size)
+            size = Math.max(0, Math.min(size, this.queue.elements.length - this.index))
+            slice = this.queue.elements.slice(this.index, this.index + size)
             this.index += size
         }
         else {
@@ -415,45 +425,58 @@ export class Queue<T extends QueueElement> extends EventEmitter {
                 min = pointer.position()
 
         /*  trim the maximum amount of first elements  */
-        this.elements.splice(0, min)
+        if (min > 0) {
+            this.elements.splice(0, min)
 
-        /*  shift all pointers  */
-        for (const pointer of this.pointers.values())
-            pointer.position(pointer.position() - min)
+            /*  shift all pointers  */
+            for (const pointer of this.pointers.values())
+                pointer.position(pointer.position() - min)
+        }
     }
 }
 
 /*  utility class for wrapping a custom stream into a regular Transform stream  */
 export class StreamWrapper extends Stream.Transform {
     private foreignStream: any
+    private onData  = (chunk: any) => { this.push(chunk) }
+    private onError = (err: Error) => { this.emit("error", err) }
+    private onEnd   = ()           => { this.push(null) }
     constructor (foreignStream: any, options: Stream.TransformOptions = {}) {
         options.readableObjectMode = true
         options.writableObjectMode = true
         super(options)
         this.foreignStream = foreignStream
-        this.foreignStream.on("data", (chunk: any) => {
-            this.push(chunk)
-        })
-        this.foreignStream.on("error", (err: Error) => {
-            this.emit("error", err)
-        })
-        this.foreignStream.on("end", () => {
-            this.push(null)
-        })
+        if (typeof this.foreignStream.on === "function") {
+            this.foreignStream.on("data",  this.onData)
+            this.foreignStream.on("error", this.onError)
+            this.foreignStream.on("end",   this.onEnd)
+        }
     }
     _transform (chunk: any, encoding: BufferEncoding, callback: Stream.TransformCallback): void {
+        if (this.destroyed) {
+            callback(new Error("stream already destroyed"))
+            return
+        }
         try {
-            const canContinue = this.foreignStream.write(chunk)
-            if (canContinue)
-                callback()
+            if (typeof this.foreignStream.write === "function") {
+                const canContinue = this.foreignStream.write(chunk)
+                if (canContinue)
+                    callback()
+                else
+                    this.foreignStream.once("drain", callback)
+            }
             else
-                this.foreignStream.once("drain", callback)
+                throw new Error("foreign stream lacks write method")
         }
         catch (err) {
             callback(err as Error)
         }
     }
     _flush (callback: Stream.TransformCallback): void {
+        if (this.destroyed) {
+            callback(new Error("stream already destroyed"))
+            return
+        }
         try {
             if (typeof this.foreignStream.end === "function")
                 this.foreignStream.end()
@@ -463,6 +486,14 @@ export class StreamWrapper extends Stream.Transform {
             callback(err as Error)
         }
     }
+    _destroy (error: Error | null, callback: Stream.TransformCallback): void {
+        if (typeof this.foreignStream.removeListener === "function") {
+            this.foreignStream.removeListener("data",  this.onData)
+            this.foreignStream.removeListener("error", this.onError)
+            this.foreignStream.removeListener("end",   this.onEnd)
+        }
+        super._destroy(error, callback)
+    }
 }
 
 /*  meta store  */
@@ -485,4 +516,7 @@ export class TimeStore<T> extends EventEmitter {
             if (interval.low < before && interval.high < before)
                 this.tree.remove(interval)
     }
+    clear (): void {
+        this.tree = new IntervalTree.IntervalTree<TimeStoreInterval<T>>()
+    }
 }