- Add exceptions to some decoder metods to better handle errors.

- Chenge some 'if' statements for 'guards', mostely in the tests
- Use STrue | SFalse instead of 1 | 0 to denote true | false when applicable

Author: Bruno Berisso

TLSphinx/Config.swift

@@ -22,7 +22,7 @@ public final class Config {
             return [strdup(name),strdup(value)]
         }
 
-        cmdLnConf = cmd_ln_parse_r(nil, ps_args(), CInt(cArgs.count), &cArgs, STrue)
+        cmdLnConf = cmd_ln_parse_r(nil, ps_args(), CInt(cArgs.count), &cArgs, STrue32)
 
         if cmdLnConf == nil {
             return nil

TLSphinx/Decoder.swift

@@ -33,9 +33,10 @@ fileprivate enum SpeechStateEnum : CustomStringConvertible {
 
 fileprivate extension AVAudioPCMBuffer {
 
-    func toDate() -> Data {
+    func toData() -> Data {
         let channels = UnsafeBufferPointer(start: int16ChannelData, count: 1)
-        let ch0Data = Data(bytes: UnsafeMutablePointer<Int16>(channels[0]), count:Int(frameCapacity * format.streamDescription.pointee.mBytesPerFrame))
+        let ch0Data = Data(bytes: UnsafeMutablePointer<int16>(channels[0]),
+                           count: Int(frameCapacity * format.streamDescription.pointee.mBytesPerFrame))
         return ch0Data
     }
 
@@ -60,16 +61,9 @@ public final class Decoder {
     public init?(config: Config) {
 
         speechState = .silence
-        
-        if config.cmdLnConf != nil{
-            psDecoder = ps_init(config.cmdLnConf)
-            
-            if psDecoder == nil {
-                return nil
-            }
-            
-        } else {
-            psDecoder = nil
+        psDecoder = config.cmdLnConf.flatMap(ps_init)
+
+        if psDecoder == nil {
             return nil
         }
     }
@@ -80,9 +74,11 @@ public final class Decoder {
     }
 
     @discardableResult fileprivate func process_raw(_ data: Data) -> CInt {
-        //Sphinx expect words of 2 bytes but the NSFileHandle read one byte at time so the lenght of the data for sphinx is the half of the real one.
+
         let dataLenght = data.count / 2
-        let numberOfFrames = ps_process_raw(psDecoder, (data as NSData).bytes.bindMemory(to: int16.self, capacity: data.count), dataLenght, SFalse, SFalse)
+        let numberOfFrames = data.withUnsafeBytes { (bytes : UnsafePointer<Int16>) -> Int32 in
+            ps_process_raw(psDecoder, bytes, dataLenght, SFalse32, SFalse32)
+        }
         let hasSpeech = in_speech()
 
         switch (speechState) {
@@ -100,7 +96,7 @@ public final class Decoder {
     }
 
     fileprivate func in_speech() -> Bool {
-        return ps_get_in_speech(psDecoder) == 1
+        return ps_get_in_speech(psDecoder) == STrue
     }
 
     @discardableResult fileprivate func start_utt() -> Bool {
@@ -114,79 +110,75 @@ public final class Decoder {
     fileprivate func get_hyp() -> Hypothesis? {
         var score: int32 = 0
 
-        if let string = ps_get_hyp(psDecoder, &score) {
-            if let text = String(validatingUTF8: string) {
-                return Hypothesis(text: text, score: Int(score))
-            } else {
-                return nil
-            }
+        guard let string = ps_get_hyp(psDecoder, &score) else {
+            return nil
+        }
+
+        if let text = String(validatingUTF8: string) {
+            return Hypothesis(text: text, score: Int(score))
         } else {
             return nil
         }
     }
-    
-    fileprivate func hypotesisForSpeechAtPath (_ filePath: String) -> Hypothesis? {
-        
-        if let fileHandle = FileHandle(forReadingAtPath: filePath) {
-            
-            start_utt()
-            
-            let hypothesis = fileHandle.reduceChunks(bufferSize, initial: nil, reducer: { [unowned self] (data: Data, partialHyp: Hypothesis?) -> Hypothesis? in
-                
-                self.process_raw(data)
-                
-                var resultantHyp = partialHyp
-                if self.speechState == .utterance {
-                    
-                    self.end_utt()
-                    resultantHyp = partialHyp + self.get_hyp()
-                    self.start_utt()
-                }
-                
-                return resultantHyp
-            })
-            
-            end_utt()
-            fileHandle.closeFile()
-            
-            //Process any pending speech
-            if speechState == .speech {
-                return hypothesis + get_hyp()
-            } else {
-                return hypothesis
+
+    fileprivate func hypotesisForSpeech (inFile fileHandle: FileHandle) -> Hypothesis? {
+
+        start_utt()
+
+        let hypothesis = fileHandle.reduceChunks(2048, initial: nil, reducer: {
+            (data: Data, partialHyp: Hypothesis?) -> Hypothesis? in
+
+            process_raw(data)
+
+            var resultantHyp = partialHyp
+            if speechState == .utterance {
+
+                end_utt()
+                resultantHyp = partialHyp + get_hyp()
+                start_utt()
             }
-            
+
+            return resultantHyp
+        })
+
+        end_utt()
+
+        //Process any pending speech
+        if speechState == .speech {
+            return hypothesis + get_hyp()
         } else {
-            return nil
+            return hypothesis
         }
     }
-    
-    open func decodeSpeechAtPath (_ filePath: String, complete: @escaping (Hypothesis?) -> ()) {
-        
+
+    public func decodeSpeech (atPath filePath: String, complete: @escaping (Hypothesis?) -> ()) throws {
+
+        guard let fileHandle = FileHandle(forReadingAtPath: filePath) else {
+            throw DecodeErrors.CantReadSpeachFile(filePath)
+        }
+
         DispatchQueue.global().async {
-            
-            let hypothesis = self.hypotesisForSpeechAtPath(filePath)
-            
+            let hypothesis = self.hypotesisForSpeech(inFile:fileHandle)
+            fileHandle.closeFile()
             DispatchQueue.main.async {
                 complete(hypothesis)
             }
         }
     }
 
-    open func startDecodingSpeech (_ utteranceComplete: @escaping (Hypothesis?) -> ()) {
+    public func startDecodingSpeech (_ utteranceComplete: @escaping (Hypothesis?) -> ()) throws {
 
         do {
             try AVAudioSession.sharedInstance().setCategory(AVAudioSessionCategoryRecord)
         } catch let error as NSError {
             print("Error setting the shared AVAudioSession: \(error)")
-            return
+            throw DecodeErrors.CantSetAudioSession(error)
         }
 
         engine = AVAudioEngine()
 
         guard let input = engine.inputNode else {
-            print("Can't get input node")
-            return
+            throw DecodeErrors.NoAudioInputAvailable
         }
 
         let formatIn = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 44100, channels: 1, interleaved: false)
@@ -202,9 +194,9 @@ public final class Decoder {
                 self.end_utt()
                 let hypothesis = self.get_hyp()
 
-                DispatchQueue.main.async(execute: { 
+                DispatchQueue.main.async {
                     utteranceComplete(hypothesis)
-                })
+                }
 
                 self.start_utt()
             }
@@ -220,6 +212,7 @@ public final class Decoder {
         } catch let error as NSError {
             end_utt()
             print("Can't start AVAudioEngine: \(error)")
+            throw DecodeErrors.CantStartAudioEngine(error)
         }
     }
 

TLSphinx/Globals.swift

@@ -8,8 +8,11 @@
 
 import Foundation
 
-let STrue: CInt = 1
-let SFalse: CInt = 0
+let STrue: uint8 = 1
+let SFalse: uint8 = 0
+
+let STrue32: CInt = 1
+let SFalse32: CInt = 0
 
 extension FileHandle {
 

TLSphinx/Hypotesis.swift

@@ -23,8 +23,10 @@ extension Hypothesis : CustomStringConvertible {
 
 }
 
-func +(lhs: Hypothesis, rhs: Hypothesis) -> Hypothesis {
-    return Hypothesis(text: lhs.text + " " + rhs.text, score: (lhs.score + rhs.score) / 2)
+extension Hypothesis {
+    static func +(lhs: Hypothesis, rhs: Hypothesis) -> Hypothesis {
+        return Hypothesis(text: lhs.text + " " + rhs.text, score: (lhs.score + rhs.score) / 2)
+    }
 }
 
 func +(lhs: Hypothesis?, rhs: Hypothesis?) -> Hypothesis? {
@@ -37,4 +39,4 @@ func +(lhs: Hypothesis?, rhs: Hypothesis?) -> Hypothesis? {
             return rhs
         }
     }
-}
+}

TLSphinxTests/Basic.swift

@@ -13,49 +13,82 @@ import TLSphinx
 
 class BasicTests: XCTestCase {
 
-    func getModelPath() -> String? {
-        return Bundle(for: BasicTests.self).path(forResource: "en-us", ofType: nil)
+    func getModelPath() -> NSString? {
+        return Bundle(for: BasicTests.self).path(forResource: "en-us", ofType: nil) as NSString?
     }
 
     func testConfig() {
-        
-        if let modelPath = getModelPath() {
-            
-            let hmm = (modelPath as NSString).appendingPathComponent("en-us")
-            let lm = (modelPath as NSString).appendingPathComponent("en-us.lm.dmp")
-            let dict = (modelPath as NSString).appendingPathComponent("cmudict-en-us.dict")
-            
-            let config = Config(args: ("-hmm", hmm), ("-lm", lm), ("-dict", dict))
-            
-            XCTAssert(config != nil, "Pass")
-            
-        } else {
+
+        guard let modelPath = getModelPath() else {
             XCTFail("Can't access pocketsphinx model. Bundle root: \(Bundle.main)")
+            return
         }
+
+        let hmm = modelPath.appendingPathComponent("en-us")
+        let lm = modelPath.appendingPathComponent("en-us.lm.dmp")
+        let dict = modelPath.appendingPathComponent("cmudict-en-us.dict")
+        
+        let config = Config(args: ("-hmm", hmm), ("-lm", lm), ("-dict", dict))
+        XCTAssert(config != nil, "Pass")
     }
 
     func testDecoder() {
 
-        if let modelPath = getModelPath() {
+        guard let modelPath = getModelPath() else {
+            XCTFail("Can't access pocketsphinx model. Bundle root: \(Bundle.main)")
+            return
+        }
 
-            let hmm = (modelPath as NSString).appendingPathComponent("en-us")
-            let lm = (modelPath as NSString).appendingPathComponent("en-us.lm.dmp")
-            let dict = (modelPath as NSString).appendingPathComponent("cmudict-en-us.dict")
+        let hmm = modelPath.appendingPathComponent("en-us")
+        let lm = modelPath.appendingPathComponent("en-us.lm.dmp")
+        let dict = modelPath.appendingPathComponent("cmudict-en-us.dict")
+        
+        guard let config = Config(args: ("-hmm", hmm), ("-lm", lm), ("-dict", dict)) else {
+            XCTFail("Can't run test without a valid config")
+            return
+        }
+
+        let decoder = Decoder(config:config)
+        XCTAssert(decoder != nil, "Pass")
+    }
+
+    func testSpeechFromFile() {
+        
+        guard let modelPath = getModelPath() else {
+            XCTFail("Can't access pocketsphinx model. Bundle root: \(Bundle.main)")
+            return
+        }
+
+        let hmm = modelPath.appendingPathComponent("en-us")
+        let lm = modelPath.appendingPathComponent("en-us.lm.dmp")
+        let dict = modelPath.appendingPathComponent("cmudict-en-us.dict")
+        
+        guard let config = Config(args: ("-hmm", hmm), ("-lm", lm), ("-dict", dict)) else {
+            XCTFail("Can't run test without a valid config")
+            return
+        }
+
+        guard let decoder = Decoder(config:config) else {
+            XCTFail("Can't run test without a decoder")
+            return
+        }
+
+        let audioFile = modelPath.appendingPathComponent("goforward.raw")
+        let expectation = self.expectation(description: "Decode finish")
+        
+        try! decoder.decodeSpeech(atPath: audioFile) {
 
-            if let config = Config(args: ("-hmm", hmm), ("-lm", lm), ("-dict", dict)) {
-                let decoder = Decoder(config:config)
+            if let hyp = $0 {
+                
+                print("Text: \(hyp.text) - Score: \(hyp.score)")
+                XCTAssert(hyp.text == "go forward ten meters", "Pass")
 
-                XCTAssert(decoder != nil, "Pass")
             } else {
-                XCTFail("Can't run test without a valid config")
+                XCTFail("Fail to decode audio")
             }
 
-        } else {
-            XCTFail("Can't access pocketsphinx model. Bundle root: \(Bundle.main)")
+            expectation.fulfill()
         }
-    }
-    
-    func testSpeechFromFile() {
 
         if let modelPath = getModelPath() {