added the Transcriber module

modules/transcription/audioRecorder.js

@@ -0,0 +1,306 @@
+/* global APP, MediaRecorder, MediaStream, webkitMediaStream*/
+var RecordingResult = require("./recordingResult");
+
+/**
+ * Possible audio formats MIME types
+ */
+var AUDIO_WEBM = "audio/webm";    // Supported in chrome
+var AUDIO_OGG  = "audio/ogg";     // Supported in firefox
+
+/**
+ * A TrackRecorder object holds all the information needed for recording a
+ * single JitsiTrack (either remote or local)
+ * @param track The JitsiTrack the object is going to hold
+ */
+var TrackRecorder = function(track){
+    // The JitsiTrack holding the stream
+    this.track = track;
+    // The MediaRecorder recording the stream
+    this.recorder = null;
+    // The array of data chunks recorded from the stream
+    // acts as a buffer until the data is stored on disk
+    this.data = null;
+    //the name of the person of the JitsiTrack. This can be undefined and/or
+    //not unique
+    this.name = null;
+    //the time of the start of the recording
+    this.startTime = null;
+};
+
+/**
+ * Starts the recording of a JitsiTrack in a TrackRecorder object.
+ * This will also define the timestamp and try to update the name
+ * @param trackRecorder the TrackRecorder to start
+ */
+function startRecorder(trackRecorder) {
+    if(trackRecorder.recorder === undefined) {
+        throw new Error("Passed an object to startRecorder which is not a " +
+            "TrackRecorder object");
+    }
+    trackRecorder.recorder.start();
+    trackRecorder.startTime = new Date();
+}
+
+/**
+ * Stops the recording of a JitsiTrack in a TrackRecorder object.
+ * This will also try to update the name
+ * @param trackRecorder the TrackRecorder to stop
+ */
+function stopRecorder(trackRecorder){
+    if(trackRecorder.recorder === undefined) {
+        throw new Error("Passed an object to stopRecorder which is not a " +
+            "TrackRecorder object");
+    }
+    trackRecorder.recorder.stop();
+}
+
+/**
+ * Creates a TrackRecorder object. Also creates the MediaRecorder and
+ * data array for the trackRecorder.
+ * @param track the JitsiTrack holding the audio MediaStream(s)
+ */
+function instantiateTrackRecorder(track) {
+    var trackRecorder = new TrackRecorder(track);
+    // Create a new stream which only holds the audio track
+    var originalStream = trackRecorder.track.getOriginalStream();
+    var stream = createEmptyStream();
+    originalStream.getAudioTracks().forEach(function(track){
+        stream.addTrack(track);
+    });
+    // Create the MediaRecorder
+    trackRecorder.recorder = new MediaRecorder(stream,
+        {mimeType: audioRecorder.fileType});
+    //array for holding the recorder data. Resets it when
+    //audio already has been recorder once
+    trackRecorder.data = [];
+    // function handling a dataEvent, e.g the stream gets new data
+    trackRecorder.recorder.ondataavailable = function (dataEvent) {
+        if(dataEvent.data.size > 0) {
+            trackRecorder.data.push(dataEvent.data);
+        }
+    };
+
+    return trackRecorder;
+}
+
+/**
+ * Determines which kind of audio recording the browser supports
+ * chrome supports "audio/webm" and firefox supports "audio/ogg"
+ */
+function determineCorrectFileType() {
+    if(MediaRecorder.isTypeSupported(AUDIO_WEBM)) {
+        return AUDIO_WEBM;
+    }
+    else if(MediaRecorder.isTypeSupported(AUDIO_OGG)) {
+        return AUDIO_OGG;
+    }
+    else {
+        throw new Error("unable to create a MediaRecorder with the" +
+            "right mimetype!");
+    }
+}
+
+/**
+ * main exported object of the file, holding all
+ * relevant functions and variables for the outside world
+ * @param jitsiConference the jitsiConference which this object
+ * is going to record
+ */
+var audioRecorder = function(jitsiConference){
+    // array of TrackRecorders, where each trackRecorder
+    // holds the JitsiTrack, MediaRecorder and recorder data
+    this.recorders = [];
+
+    //get which file type is supported by the current browser
+    this.fileType = determineCorrectFileType();
+
+    //boolean flag for active recording
+    this.isRecording = false;
+
+    //the jitsiconference the object is recording
+    this.jitsiConference = jitsiConference;
+};
+
+/**
+ * Add the the exported module so that it can be accessed by other files
+ */
+audioRecorder.determineCorrectFileType = determineCorrectFileType;
+
+/**
+ * Adds a new TrackRecorder object to the array.
+ *
+ * @param track the track potentially holding an audio stream
+ */
+audioRecorder.prototype.addTrack = function (track) {
+    if(track.isAudioTrack()) {
+        //create the track recorder
+        var trackRecorder = instantiateTrackRecorder(track);
+        //push it to the local array of all recorders
+        this.recorders.push(trackRecorder);
+        //update the name of the trackRecorders
+        this.updateNames();
+        //if we're already recording, immediately start recording this new track
+        if(this.isRecording){
+            startRecorder(trackRecorder);
+        }
+    }
+};
+
+/**
+ * Notifies the module that a specific track has stopped, e.g participant left
+ * the conference.
+ * if the recording has not started yet, the TrackRecorder will be removed from
+ * the array. If the recording has started, the recorder will stop recording
+ * but not removed from the array so that the recorded stream can still be
+ * accessed
+ *
+ * @param jitsiTrack the JitsiTrack to remove from the recording session
+ */
+audioRecorder.prototype.removeTrack = function(jitsiTrack){
+    var array = this.recorders;
+    var i;
+    for(i = 0; i < array.length; i++) {
+        if(array[i].track.getParticipantId() === jitsiTrack.getParticipantId()){
+            var recorderToRemove = array[i];
+            if(this.isRecording){
+                stopRecorder(recorderToRemove);
+            }
+            else {
+                //remove the TrackRecorder from the array
+                array.splice(i, 1);
+            }
+        }
+    }
+
+    //make sure the names are up to date
+    this.updateNames();
+};
+
+/**
+ * Tries to update the name value of all TrackRecorder in the array.
+ * If it hasn't changed,it will keep the exiting name. If it changes to a
+ * undefined value, the old value will also be kept.
+ */
+audioRecorder.prototype.updateNames = function(){
+    var conference = this.jitsiConference;
+    this.recorders.forEach(function(trackRecorder){
+        if(trackRecorder.track.isLocal()){
+            trackRecorder.name = "the transcriber";
+        }
+        else {
+            var id = trackRecorder.track.getParticipantId();
+            var participant = conference.getParticipantById(id);
+            var newName = participant.getDisplayName();
+            if(newName !== 'undefined') {
+                trackRecorder.name = newName;
+            }
+        }
+    });
+};
+
+/**
+ * Starts the audio recording of every local and remote track
+ */
+audioRecorder.prototype.start = function () {
+    if(this.isRecording) {
+        throw new Error("audiorecorder is already recording");
+    }
+    // set boolean isRecording flag to true so if new participants join the
+    // conference, that track can instantly start recording as well
+    this.isRecording = true;
+    //start all the mediaRecorders
+    this.recorders.forEach(function(trackRecorder){
+        startRecorder(trackRecorder);
+    });
+    //log that recording has started
+    console.log("Started the recording of the audio. There are currently " +
+        this.recorders.length + " recorders active.");
+};
+
+/**
+ * Stops the audio recording of every local and remote track
+ */
+audioRecorder.prototype.stop = function() {
+    //set the boolean flag to false
+    this.isRecording = false;
+    //stop all recorders
+    this.recorders.forEach(function(trackRecorder){
+       stopRecorder(trackRecorder);
+    });
+    console.log("stopped recording");
+};
+
+/**
+ * link hacking to download all recorded audio streams
+ */
+audioRecorder.prototype.download = function () {
+    var t = this;
+    this.recorders.forEach(function (trackRecorder) {
+        var blob = new Blob(trackRecorder.data, {type: t.fileType});
+        var url = URL.createObjectURL(blob);
+        var a = document.createElement('a');
+        document.body.appendChild(a);
+        a.style = "display: none";
+        a.href = url;
+        a.download = 'test.' + t.fileType.split("/")[1];
+        a.click();
+        window.URL.revokeObjectURL(url);
+    });
+};
+
+/**
+ * returns the audio files of all recorders as an array of objects,
+ * which include the name of the owner of the track and the starting time stamp
+ * @returns {Array} an array of RecordingResult objects
+ */
+audioRecorder.prototype.getRecordingResults = function () {
+    if(this.isRecording) {
+        throw new Error("cannot get blobs because the AudioRecorder is still" +
+            "recording!");
+    }
+    //make sure the names are up to date before sending them off
+    this.updateNames();
+
+    var array = [];
+    var t = this;
+    this.recorders.forEach(function (recorder) {
+        array.push(
+            new RecordingResult(
+            new Blob(recorder.data, {type: t.fileType}),
+            recorder.name,
+            recorder.startTime)
+        );
+    });
+    return array;
+};
+
+/**
+ * Gets the mime type of the recorder audio
+ * @returns {String} the mime type of the recorder audio
+ */
+audioRecorder.prototype.getFileType = function () {
+    return this.fileType;
+};
+
+/**
+ * Creates a empty MediaStream object which can be used
+ * to add MediaStreamTracks to
+ * @returns MediaStream
+ */
+function createEmptyStream() {
+    // Firefox supports the MediaStream object, Chrome webkitMediaStream
+    if(typeof(MediaStream) !== 'undefined') {
+        return new MediaStream();
+    }
+    else if(typeof(webkitMediaStream) !== 'undefined') {
+        return new webkitMediaStream();
+    }
+    else {
+        throw new Error("cannot create a clean mediaStream");
+    }
+}
+
+/**
+ * export the main object audioRecorder
+ */
+module.exports = audioRecorder;

modules/transcription/recordingResult.js

@@ -0,0 +1,18 @@
+/**
+ * This object stores variables needed around the recording of an audio stream
+ * and passing this recording along with additional information along to
+ * different processes
+ * @param blob the recording audio stream as a single blob
+ * @param name the name of the person of the audio stream
+ * @param startTime the time in UTC when recording of the audiostream started
+ * @param wordArray the recorder audio stream transcribed as an array of Word
+ *                  objects
+ */
+var RecordingResult = function(blob, name, startTime, wordArray){
+    this.blob = blob;
+    this.name = name;
+    this.startTime = startTime;
+    this.wordArray = wordArray;
+};
+
+module.exports = RecordingResult;

modules/transcription/transcriber.js

@@ -0,0 +1,317 @@
+var AudioRecorder = require( './audioRecorder');
+var SphinxService = require(
+    './transcriptionServices/SphinxTranscriptionService');
+
+var BEFORE_STATE = "before";
+var RECORDING_STATE = "recording";
+var TRANSCRIBING_STATE = "transcribing";
+var FINISHED_STATE = "finished";
+
+//the amount of characters each line in the transcription will have
+var MAXIMUM_SENTENCE_LENGTH = 80;
+
+/**
+ * This is the main object for handing the Transcription. It interacts with
+ * the audioRecorder to record every person in a conference and sends the
+ * recorder audio to a transcriptionService. The returned speech-to-text result
+ * will be merged to create a transcript
+ * @param {AudioRecorder} audioRecorder An audioRecorder recording a conference
+ */
+var transcriber = function(audioRecorder) {
+    //the object which can record all audio in the conference
+    this.audioRecorder = audioRecorder;
+    //this object can send the recorder audio to a speech-to-text service
+    this.transcriptionService =  new SphinxService();
+    //holds a counter to keep track if merging can start
+    this.counter = null;
+    //holds the date when transcription started which makes it possible
+    //to calculate the offset between recordings
+    this.startTime = null;
+    //will hold the transcription once it is completed
+    this.transcription = null;
+    //this will be a method which will be called once the transcription is done
+    //with the transcription as parameter
+    this.callback =  null;
+    //stores all the retrieved speech-to-text results to merge together
+    //this value will store an Array<Word> object
+    this.results = [];
+    // Stores the current state of the transcription process
+    this.state = BEFORE_STATE;
+    //Used in the updateTranscription method to add a new line when the
+    //sentence becomes to long
+    this.lineLength = 0;
+};
+
+/**
+ * Method to start the transcription process. It will tell the audioRecorder
+ * to start storing all audio streams and record the start time for merging
+ * purposes
+ */
+transcriber.prototype.start = function start() {
+    if(this.state !== BEFORE_STATE){
+        throw new Error("The transcription can only start when it's in the" +
+            "\"" + BEFORE_STATE + "\" state. It's currently in the " +
+            "\"" + this.state + "\" state");
+    }
+    this.state = RECORDING_STATE;
+    this.audioRecorder.start();
+    this.startTime = new Date();
+};
+
+/**
+ * Method to stop the transcription process. It will tell the audioRecorder to
+ * stop, and get all the recorded audio to send it to the transcription service
+
+ * @param callback a callback which will receive the transcription
+ */
+transcriber.prototype.stop = function stop(callback) {
+    if(this.state !== RECORDING_STATE){
+        throw new Error("The transcription can only stop when it's in the" +
+            "\"" + RECORDING_STATE + "\" state. It's currently in the " +
+            "\"" + this.state + "\" state");
+    }
+    //stop the recording
+    console.log("stopping recording and sending audio files");
+    this.audioRecorder.stop();
+    //and send all recorded audio the the transcription service
+    var t = this;
+
+    var callBack = blobCallBack.bind(this);
+    this.audioRecorder.getRecordingResults().forEach(function(recordingResult){
+        t.transcriptionService.send(recordingResult, callBack);
+        t.counter++;
+    });
+    //set the state to "transcribing" so that maybeMerge() functions correctly
+    this.state = TRANSCRIBING_STATE;
+    //and store the callback for later
+    this.callback = callback;
+};
+
+/**
+ * This method gets the answer from the transcription service, calculates the
+ * offset and adds is to every Word object. It will also start the merging
+ * when every send request has been received
+ *
+ * note: Make sure to bind this as a Transcription object
+ *
+ * @param {RecordingResult} answer a RecordingResult object with a defined
+ * WordArray
+ */
+var blobCallBack = function(answer){
+    console.log("retrieved an answer from the transcription service. The" +
+        " answer has an array of length: " + answer.wordArray.length);
+    //first add the offset between the start of the transcription and
+    //the start of the recording to all start and end times
+    if(answer.wordArray.length > 0) {
+        var offset = answer.startTime.getUTCMilliseconds() -
+            this.startTime.getUTCMilliseconds();
+        //transcriber time will always be earlier
+        if (offset < 0) {
+            offset = 0; //presume 0 if it somehow not earlier
+        }
+
+        var array = "[";
+        answer.wordArray.forEach(function(wordObject) {
+            wordObject.begin += offset;
+            wordObject.end += offset;
+            array += wordObject.word+",";
+        });
+        array += "]";
+        console.log(array);
+        //give a name value to the Array object so that the merging can access
+        //the name value without having to use the whole recordingResult object
+        //in the algorithm
+        answer.wordArray.name = answer.name;
+    }
+    //then store the array and decrease the counter
+    this.results.push(answer.wordArray);
+    this.counter--;
+    console.log("current counter: " + this.counter);
+    //and check if all results have been received.
+    this.maybeMerge();
+};
+
+/**
+ * this method will check if the counter is zero. If it is, it will call
+ * the merging method
+ */
+transcriber.prototype.maybeMerge = function(){
+    if(this.state === TRANSCRIBING_STATE && this.counter === 0){
+        //make sure to include the events in the result arrays before
+        //merging starts
+        this.merge();
+    }
+};
+
+/**
+ * This method will merge all speech-to-text arrays together in one
+ * readable transcription string
+ */
+transcriber.prototype.merge = function() {
+    console.log("starting merge process!\n The length of the array: " +
+        this.results.length);
+    this.transcription = "";
+    //the merging algorithm will look over all Word objects who are at pos 0 in
+    //every array. It will then select the one closest in time to the
+    //previously placed word, while removing the selected word from its array
+    //note: words can be skipped the skipped word's begin and end time somehow
+    //end up between the closest word start and end time
+    var arrays = this.results;
+    //arrays of Word objects
+    var potentialWords = []; //array of the first Word objects
+    //check if any arrays are already empty and remove them
+    hasPopulatedArrays(arrays);
+
+    //populate all the potential Words for a first time
+    arrays.forEach(function (array){
+        pushWordToSortedArray(potentialWords, array);
+    });
+
+    //keep adding words to transcription until all arrays are exhausted
+    var lowestWordArray;
+    var wordToAdd;
+    var foundSmaller;
+    while(hasPopulatedArrays(arrays)){
+        //first select the lowest array;
+        lowestWordArray = arrays[0];
+        arrays.forEach(function(wordArray){
+           if(wordArray[0].begin < lowestWordArray[0].begin){
+               lowestWordArray = wordArray;
+           }
+        });
+        //put the word in the transcription
+        wordToAdd = lowestWordArray.shift();
+        this.updateTranscription(wordToAdd,lowestWordArray.name);
+
+        //keep going until a word in another array has a smaller time
+        //or the array is empty
+        while(!foundSmaller && lowestWordArray.length > 0){
+            arrays.forEach(function(wordArray){
+                if(wordArray[0].begin < lowestWordArray[0].begin){
+                    foundSmaller = true;
+                }
+            });
+            //add next word if no smaller time has been found
+            if(!foundSmaller){
+                wordToAdd = lowestWordArray.shift();
+                this.updateTranscription(wordToAdd, null);
+            }
+        }
+
+    }
+
+    //set the state to finished and do the necessary left-over tasks
+    this.state = FINISHED_STATE;
+    if(this.callback){
+        this.callback(this.transcription);
+    }
+};
+
+/**
+ * Appends a word object to the transcription. It will make a new line with a
+ * name if a name is specified
+ * @param {Word} word the Word object holding the word to append
+ * @param {String|null} name the name of a new speaker. Null if not applicable
+ */
+transcriber.prototype.updateTranscription = function(word, name){
+    if(name !== undefined && name !== null){
+        this.transcription += "\n" + name + ":";
+        this.lineLength = name.length + 1; //+1 for the semi-colon
+    }
+    if(this.lineLength + word.word.length > MAXIMUM_SENTENCE_LENGTH){
+        this.transcription += "\n    ";
+        this.lineLength = 4; //because of the 4 spaces after the new line
+    }
+    this.transcription += " " + word.word;
+    this.lineLength += word.word.length + 1; //+1 for the space
+};
+
+/**
+ * Check if the given 2 dimensional array has any non-zero Word-arrays in them.
+ * All zero-element arrays inside will be removed
+ * If any non-zero-element arrays are found, the method will return true.
+ * otherwise it will return false
+ * @param {Array<Array>} twoDimensionalArray the array to check
+ * @returns {boolean} true if any non-zero arrays inside, otherwise false
+ */
+var hasPopulatedArrays = function(twoDimensionalArray){
+    var i;
+    for(i = 0; i < twoDimensionalArray.length; i++){
+        if(twoDimensionalArray[i].length === 0){
+            twoDimensionalArray.splice(i, 1);
+        }
+    }
+    return twoDimensionalArray.length > 0;
+};
+
+/**
+ * Push a word to the right location in a sorted array. The array is sorted
+ * from lowest to highest start time. Every word is stored in an object which
+ * includes the name of the person saying the word.
+ *
+ * @param {Array<Word>} array the sorted array to push to
+ * @param {Word} word the word to push into the array
+ */
+var pushWordToSortedArray = function(array, word){
+    if(array.length === 0) {
+        array.push(word);
+    }
+    else{
+        if(array[array.length - 1].begin <= word.begin){
+            array.push(word);
+            return;
+        }
+        var i;
+        for(i = 0; i < array.length; i++){
+            if(word.begin < array[i].begin){
+                array.splice(i, 0, word);
+                return;
+            }
+        }
+        array.push(word); //fail safe
+    }
+};
+
+/**
+ * Returns the AudioRecorder module to add and remove tracks to
+ */
+transcriber.getAudioRecorder = function getAudioRecorder() {
+    return this.audioRecorder;
+};
+
+/**
+ * Will return the created transcription if it's avialable or throw an error
+ * when it's not done yet
+ * @returns {String} the transcription as a String
+ */
+transcriber.prototype.getTranscription = function(){
+    if(this.state !== FINISHED_STATE){
+        throw new Error("The transcription can only be retrieved when it's in" +
+            " the\"" + FINISHED_STATE + "\" state. It's currently in the " +
+            "\"" + this.state + "\" state");
+    }
+    return this.transcription;
+};
+
+/**
+ * Returns the current state of the transcription process
+ */
+transcriber.prototype.getState = function(){
+    return this.state;
+};
+
+/**
+ * Resets the state to the "before" state, such that it's again possible to
+ * call the start method
+ */
+transcriber.prototype.reset = function() {
+    this.state = BEFORE_STATE;
+    this.counter = null;
+    this.transcription = null;
+    this.startTime = null;
+    this.callback = null;
+    this.results = [];
+    this.lineLength = 0;
+};
+
+module.exports = transcriber;

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

@@ -0,0 +1,77 @@
+/**
+ * Abstract class representing an interface to implement a speech-to-text
+ * service on.
+ */
+var TranscriptionService = function() {
+    throw new Error("TranscriptionService is abstract and cannot be" +
+        "created");
+};
+
+/**
+ * This method can be used to send the recorder audio stream and
+ * retrieve the answer from the transcription service from the callback
+ *
+ * @param {RecordingResult} recordingResult a recordingResult object which
+ * includes the recorded audio stream as a blob
+ * @param {Function} callback  which will retrieve the a RecordingResult with
+ *        the answer as a WordArray
+ */
+TranscriptionService.prototype.send = function send(recordingResult, callback){
+    var t = this;
+    this.sendRequest(recordingResult.blob, function(response){
+        if(!t.verify(response)){
+               console.log("the retrieved response from the server" +
+                   " is not valid!");
+            recordingResult.wordArray = [];
+            callback(recordingResult);
+        }
+        else{
+            recordingResult.wordArray = t.formatResponse(response);
+            callback(recordingResult);
+        }
+    });
+};
+
+/**
+ * Abstract method which will rend the recorder audio stream to the implemented
+ * transcription service and will retrieve an answer, which will be
+ * called on the given callback method
+ *
+ * @param {Blob} audioBlob the recorded audio stream as a single Blob
+ * @param {function} callback function which will retrieve the answer
+ *                            from the service
+ */
+TranscriptionService.prototype.sendRequest = function(audioBlob, callback) {
+    throw new Error("TranscriptionService.sendRequest is abstract");
+};
+
+/**
+ * Abstract method which will parse the output from the implemented
+ * transcription service to the expected format
+ *
+ * The transcriber class expect an array of word objects, where each word
+ * object is one transcribed word by the service.
+ *
+ * The expected output of this method is an array of word objects, in
+ * the correct order. That is, the first object in the array is the first word
+ * being said, and the last word in the array is the last word being said
+ *
+ * @param response the answer from the speech-to-text server which needs to be
+ *                 formatted
+ * @return {Array<Word>} an array of Word objects
+ */
+TranscriptionService.prototype.formatResponse = function(response){
+    throw new Error("TranscriptionService.format is abstract");
+};
+
+/**
+ * Abstract method which will verify that the response from the server is valid
+ *
+ * @param response the response from the server
+ * @return {boolean} true if response is valid, false otherwise
+ */
+TranscriptionService.prototype.verify = function(response){
+      throw new Error("TranscriptionService.verify is abstract");
+};
+
+module.exports = TranscriptionService;

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

@@ -0,0 +1,130 @@
+/* global config,  XMLHttpRequest, console, APP, JSON */
+
+var TranscriptionService = require("./AbstractTranscriptionService");
+var Word = require( "../word");
+var audioRecorder = require("./../audioRecorder");
+
+/**
+ * Implements a TranscriptionService for a Sphinx4 http server
+ */
+var SphinxService = function() {
+    //set the correct url
+    this.url = getURL();
+};
+
+/**
+ * Subclass of AbstractTranscriptionService
+ */
+SphinxService.prototype = Object.create(TranscriptionService.prototype);
+
+/**
+ * Set the right constructor
+ */
+SphinxService.constructor = SphinxService;
+
+/**
+ * Overrides the sendRequest method from AbstractTranscriptionService
+ * it will send the audio stream the a Sphinx4 server to get the transcription
+ *
+ * @param audioFileBlob the recorder audio stream an a single Blob
+ * @param callback the callback function retrieving the server response
+ */
+SphinxService.prototype.sendRequest = function(audioFileBlob, callback) {
+    console.log("sending an audio file  to " + this.url);
+    console.log("the audio file being sent: " + audioFileBlob);
+    var request = new XMLHttpRequest();
+    request.onreadystatechange = function() {
+        if(request.readyState === XMLHttpRequest.DONE && request.status === 200)
+        {
+            callback(request.responseText);
+        }
+        else if (request.readyState === XMLHttpRequest.DONE) {
+            throw new Error("unable to accept response from sphinx server." +
+                "status: " + request.status);
+        }
+        //if not ready no point to throw an error
+    };
+    request.open("POST", this.url);
+    request.setRequestHeader("Content-Type",
+        audioRecorder.determineCorrectFileType());
+    request.send(audioFileBlob);
+    console.log("send " + audioFileBlob);
+};
+
+/**
+ * Overrides the formatResponse method from AbstractTranscriptionService
+ * It will parse the answer from the server in the expected format
+ *
+ * @param response the JSON body retrieved from the Sphinx4 server
+ */
+SphinxService.prototype.formatResponse = function(response) {
+    var result = JSON.parse(response).objects;
+    //make sure to delete the session id object, which is always
+    //the first value in the JSON array
+    result.shift();
+    var array = [];
+    result.forEach(function(word){
+        if(!word.filler) {
+            array.push(new Word(word.word, word.start, word.end));
+        }
+    });
+    return array;
+};
+
+/**
+ * checks wether the reply is empty, or doesn't contain a correct JSON object
+ * @param response the server response
+ * @return {boolean} whether the response is valid
+ */
+SphinxService.prototype.verify = function(response){
+    console.log("response from server:" + response.toString());
+    //test if server responded with a string object
+    if(typeof(response) !== "string"){
+        return false;
+    }
+    //test if the string can be parsed into valid JSON
+    var json;
+    try{
+        json = JSON.parse(response);
+    }
+    catch (error){
+        console.log(error);
+        return false;
+    }
+    //check if the JSON has a "objects" value
+    if(json.objects === undefined){
+        return false;
+    }
+    //get the "objects" value and check for a session ID
+    var array = json.objects;
+    if(!(array[0] && array[0]["session-id"])){
+        return false;
+    }
+    //everything seems to be in order
+    return true;
+};
+
+/**
+ * Gets the URL to the Sphinx4 server from the config file. If it's not there,
+ * it will throw an error
+ *
+ * @returns {string} the URL to the sphinx4 server
+ */
+function getURL() {
+    var message = "config does not contain an url to a " +
+    "Sphinx4 https server";
+    if(config.sphinxURL === undefined){
+        throw new Error(message);
+    }
+    else {
+        var toReturn = config.sphinxURL;
+        if(toReturn.includes !== undefined && toReturn.includes("https://")){
+            return toReturn;
+        }
+        else{
+            throw new Error(message);
+        }
+    }
+}
+
+module.exports = SphinxService;

modules/transcription/word.js

@@ -0,0 +1,37 @@
+/**
+ * An object representing a transcribed word, with some additional information
+ * @param word the word 
+ * @param begin the time the word was started being uttered
+ * @param end the tome the word stopped being uttered
+ */
+var Word = function (word, begin, end, name) {
+    this.word = word;
+    this.begin = begin;
+    this.end = end;
+};
+
+/**
+ * Get the string representation of the word
+ * @returns {*} the word as a string
+ */
+Word.prototype.getWord = function() {
+    return this.word;  
+};
+
+/**
+ * Get the time the word started being uttered
+ * @returns {*} the start time as an integer
+ */
+Word.prototype.getBeginTime = function () {
+    return this.begin;
+};
+
+/**
+ * Get the time the word stopped being uttered
+ * @returns {*} the end time as an integer
+ */
+Word.prototype.getEndTime = function () {
+    return this.end;
+};
+
+module.exports = Word;