Implement recording functionality

.gitignore

@@ -127,3 +127,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+*.tflite

client.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, division, print_function
+
+import argparse
+import numpy as np
+import shlex
+import subprocess
+import sys
+import wave
+import json
+
+from deepspeech import Model, version
+from timeit import default_timer as timer
+
+try:
+    from shhlex import quote
+except ImportError:
+    from pipes import quote
+
+
+def convert_samplerate(audio_path, desired_sample_rate):
+    sox_cmd = 'sox {} --type raw --bits 16 --channels 1 --rate {} --encoding signed-integer --endian little --compression 0.0 --no-dither - '.format(
+        quote(audio_path), desired_sample_rate)
+    try:
+        output = subprocess.check_output(
+            shlex.split(sox_cmd), stderr=subprocess.PIPE)
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError('SoX returned non-zero status: {}'.format(e.stderr))
+    except OSError as e:
+        raise OSError(e.errno, 'SoX not found, use {}hz files or install it: {}'.format(
+            desired_sample_rate, e.strerror))
+
+    return desired_sample_rate, np.frombuffer(output, np.int16)
+
+
+def metadata_to_string(metadata):
+    return ''.join(token.text for token in metadata.tokens)
+
+
+def words_from_candidate_transcript(metadata):
+    word = ""
+    word_list = []
+    word_start_time = 0
+    # Loop through each character
+    for i, token in enumerate(metadata.tokens):
+        # Append character to word if it's not a space
+        if token.text != " ":
+            if len(word) == 0:
+                # Log the start time of the new word
+                word_start_time = token.start_time
+
+            word = word + token.text
+        # Word boundary is either a space or the last character in the array
+        if token.text == " " or i == len(metadata.tokens) - 1:
+            word_duration = token.start_time - word_start_time
+
+            if word_duration < 0:
+                word_duration = 0
+
+            each_word = dict()
+            each_word["word"] = word
+            each_word["start_time "] = round(word_start_time, 4)
+            each_word["duration"] = round(word_duration, 4)
+
+            word_list.append(each_word)
+            # Reset
+            word = ""
+            word_start_time = 0
+
+    return word_list
+
+
+def metadata_json_output(metadata):
+    json_result = dict()
+    json_result["transcripts"] = [{
+        "confidence": transcript.confidence,
+        "words": words_from_candidate_transcript(transcript),
+    } for transcript in metadata.transcripts]
+    return json.dumps(json_result, indent=2)
+
+
+class VersionAction(argparse.Action):
+    def __init__(self, *args, **kwargs):
+        super(VersionAction, self).__init__(nargs=0, *args, **kwargs)
+
+    def __call__(self, *args, **kwargs):
+        print('DeepSpeech ', version())
+        exit(0)
+
+
+def client(audio_file):
+    model_load_start = timer()
+    # sphinx-doc: python_ref_model_start
+    ds = Model("./uk.tflite")
+    # sphinx-doc: python_ref_model_stop
+    model_load_end = timer() - model_load_start
+    print('Loaded model in {:.3}s.'.format(model_load_end), file=sys.stderr)
+
+    desired_sample_rate = ds.sampleRate()
+
+    fin = wave.open(audio_file, 'rb')
+    fs_orig = fin.getframerate()
+    audio = np.frombuffer(fin.readframes(fin.getnframes()), np.int16)
+
+    audio_length = fin.getnframes() * (1/fs_orig)
+    fin.close()
+
+    print('Running inference.', file=sys.stderr)
+    inference_start = timer()
+    # sphinx-doc: python_ref_inference_start
+
+    result = ds.stt(audio)
+    print(result)
+    # sphinx-doc: python_ref_inference_stop
+    inference_end = timer() - inference_start
+    print('Inference took %0.3fs for %0.3fs audio file.' %
+          (inference_end, audio_length), file=sys.stderr)
+    return result

main.py

@@ -1,5 +1,8 @@
-from flask import Flask, render_template
-app = Flask(__name__)
+from flask import Flask, render_template, request
+from io import BytesIO
+from client import client
+
+app = Flask(__name__,)
 
 
 @app.route('/')
@@ -9,4 +12,9 @@ def index():
 
 @app.route('/recognize', methods=["POST"])
 def recognize():
-    return 'Hello, World!'
+    file = request.files['file']
+    audio = BytesIO()
+    file.save(audio)
+    audio.seek(0)
+    result = client(audio)
+    return result

requirements.txt

@@ -1,2 +1,3 @@
 Flask==1.1.2
-deepspeech-tflite==0.7.3
+deepspeech-tflite==0.7.3
+numpy==1.17.0

templates/hello.html

@@ -13,49 +13,83 @@
     <h1>Audio Recording Test</h1>
     <p>Talk for 3 seconds, then you will hear your recording played back</p>
     <button class="btn btn-primary" id="action" onclick="handleAction()">Start recording...</button>
+    <div id="result"></div>
+    <script src="https://cdn.rawgit.com/mattdiamond/Recorderjs/08e7abd9/dist/recorder.js"></script>
     <script>
-        const recordAudio = () =>
-            new Promise(async resolve => {
-                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-                const mediaRecorder = new MediaRecorder(stream, { audioBitsPerSecond: 16000 });
-                const audioChunks = [];
+        var gumStream; 						//stream from getUserMedia()
+        var rec; 							//Recorder.js object
+        var input; 							//MediaStreamAudioSourceNode we'll be recording
 
-                mediaRecorder.addEventListener("dataavailable", event => {
-                    audioChunks.push(event.data);
-                });
+        // shim for AudioContext when it's not avb. 
+        var AudioContext = window.AudioContext || window.webkitAudioContext;
+        var audioContext; //audio context to help us record
+        var resultNode = document.getElementById('result');
 
-                const start = () => mediaRecorder.start();
+        function resultProcess(data) {
+            resultNode.textContent = `Довжина тексту: ${data.length} \n
+                Текст: ${data}
+            `
+        }
+
+        function exportWAV(blob) {
+            var data = new FormData()
+            data.append('file', blob);
+            fetch(`./recognize`, { method: "POST", body: data })
+                .then(response => response.text())
+                .then(resultProcess);
+        }
+        function record() {
+            var constraints = { audio: true, video: false }
+            navigator.mediaDevices.getUserMedia(constraints).then(function (stream) {
+                console.log("getUserMedia() success, stream created, initializing Recorder.js ...");
+
+                /*
+                    create an audio context after getUserMedia is called
+                    sampleRate might change after getUserMedia is called, like it does on macOS when recording through AirPods
+                    the sampleRate defaults to the one set in your OS for your playback device
+                */
+                audioContext = new AudioContext();
 
-                const stop = () =>
-                    new Promise(resolve => {
-                        mediaRecorder.addEventListener("stop", () => {
-                            const audioBlob = new Blob(audioChunks);
+                /*  assign to gumStream for later use  */
+                gumStream = stream;
 
-                            const audioUrl = URL.createObjectURL(audioBlob);
-                            fetch(`./recognize`, { method: "POST", body: audioBlob })
-                                .then(response => console.log(response.text()))
-                            const audio = new Audio(audioUrl);
-                            const play = () => audio.play();
-                            resolve({ audioBlob, audioUrl, play });
-                        });
+                /* use the stream */
+                input = audioContext.createMediaStreamSource(stream);
 
-                        mediaRecorder.stop();
-                    });
+                /* 
+                    Create the Recorder object and configure to record mono sound (1 channel)
+                    Recording 2 channels  will double the file size
+                */
+                rec = new Recorder(input, { numChannels: 1 })
+
+                //start the recording process
+                rec.record()
+
+                console.log("Recording started");
+                sleep(3000).then(stop);
+            })
+        }
+
+
+        function stop() {
+            rec.stop();
+
+            //stop microphone access
+            gumStream.getAudioTracks()[0].stop();
+
+            //create the wav blob and pass it on to createDownloadLink
+            rec.exportWAV(exportWAV);
+            console.log("Recording stopped")
+
+        }
 
-                resolve({ start, stop });
-            });
 
         const sleep = time => new Promise(resolve => setTimeout(resolve, time));
 
-        const handleAction = async () => {
-            const recorder = await recordAudio();
+        async function handleAction() {
             const actionButton = document.getElementById('action');
             actionButton.disabled = true;
-            recorder.start();
-            await sleep(3000);
-            const audio = await recorder.stop();
-            audio.play();
-            await sleep(3000);
+            record();
             actionButton.disabled = false;
         }
     </script>