~mhall119/ubuntu-app-reviews/qtranscribe

/*
 *  Copyright © 2012 Matt Pharoah (mr.exuberant@gmail.com)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef DICTATION_H_
#define DICTATION_H_

#include <sox.h>
#include <cstring>
#include <thread>
#include <mutex>
#include <stdexcept>

extern "C" {
#include <pulse/stream.h>
#include <pulse/sample.h>
#include <pulse/def.h>
#include <pulse/mainloop.h>
}

#include "AudioFileReader.hh"

using namespace std;

enum __REWIND_FASTFORWARD_OR_NEITHER {
	REWIND,
	NORMAL,
	FAST_FORWARD
};

static __REWIND_FASTFORWARD_OR_NEITHER mode;

static unsigned short REWIND_SPEED = 4; //x4 speed
static unsigned short FAST_FORWARD_SPEED = 8; //x8 speed
static bool SFX = true; //sound effects for fast forward and rewind?

static int dontcare;

class Dictation {
  private:
	unsigned int SAMPLE_RATE;
	unsigned short CHANNELS;
	unsigned int SIZE;

	unsigned int BUFFER_SIZE;
	unsigned int BUFFER_FRAMES;

	thread *loopThread;
	pa_stream *audioStream;
	sox_format_t *audioFile;
	unsigned int position;
	float speed;
	AudioFileReader *reader;
	SlowBuffer *stretcher;
	bool paused;
	char *fileName;

	pa_mainloop *PALoop;
	pa_context *context;

	float *SFX_REWIND; //rewind sound effect
	float *SFX_FFORWARD; //fast forward sound effect

	mutex positionLock;

	float *nil;

	static void fetchAudioData(pa_stream *stream, int success, void *me) {
		((Dictation *) me)->fetchAD();
	}

	inline void fetchAD() {
		positionLock.lock();
		if (position > SIZE)  {
			position = SIZE;
			pause();
		}

		if (mode == REWIND) {
			if (SFX) {
				pa_stream_write(audioStream, (void *) SFX_REWIND, BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
			} else {
				pa_stream_write(audioStream, (void *) nil, BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
			}
			if (position < BUFFER_FRAMES * REWIND_SPEED) {
				position = 0;
			} else {
				position -= BUFFER_FRAMES * REWIND_SPEED;
			}
		} else if (mode == FAST_FORWARD) {
			if (SFX) {
				pa_stream_write(audioStream, (void *) SFX_FFORWARD, BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
			} else {
				pa_stream_write(audioStream, (void *) nil, BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
			}
			position += BUFFER_FRAMES * FAST_FORWARD_SPEED;
		} else if (paused) {
			//write zeroes (silence)
			pa_stream_write(audioStream, (void *) nil, BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
		} else if (speed == 1.0) {
			pa_stream_write(audioStream, (*reader)[position], BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
			position += BUFFER_FRAMES;
		} else {
			float temp[BUFFER_FRAMES];
			position += stretcher->fetchInto(position, temp);
			pa_stream_write(audioStream, (void *) temp, BUFFER_SIZE, NULL, 0, PA_SEEK_RELATIVE);
		}
		positionLock.unlock();
	}

	//generate sawtooth sound effects for rewinding and fast forwarding
	inline void generateRewindEffect() {
		SFX_REWIND = new float[BUFFER_FRAMES];
		for (unsigned int i = 0; i < BUFFER_FRAMES; i += CHANNELS) {
			for (unsigned short j = 0; j < CHANNELS; j++) {
				SFX_REWIND[i+j] = 0.25f * (i % 100 / 100.f - 0.5);
			}
		}
	}

	inline void generateFastForwardEffect() {
		SFX_FFORWARD = new float[BUFFER_FRAMES];
		for (unsigned int i = 0; i < BUFFER_FRAMES; i += CHANNELS) {
			for (unsigned short j = 0; j < CHANNELS; j++) {
				SFX_FFORWARD[i+j] = 0.25f * (i % 80 / 80.f - 0.5);
			}
		}
	}

	/*
	 * well, I made a function for generating the sound effects,so I
	 * should make one for freeing them for the purpose of symmetry
	 */
	inline void freeSFX() {
		delete[] SFX_REWIND;
		delete[] SFX_FFORWARD;
	}

  public:
	static void setRewindSpeed(unsigned short mult) {
		REWIND_SPEED = mult;
	}

	static void setFastForwardSpeed(unsigned short mult) {
		FAST_FORWARD_SPEED = mult;
	}

	static unsigned int getRewindSpeed() {
		return REWIND_SPEED;
	}

	static unsigned int getFastForwardSpeed() {
		return FAST_FORWARD_SPEED;
	}

	static void setEffectsEnabled(bool yes) {
		SFX = yes;
	}

	Dictation(const string &file, volatile bool *errorCheck) {
		position = 0;
		speed = 1.0;
		mode = NORMAL;

		fileName = new char[file.length() + 1];
		strcpy(fileName, file.c_str());

		//load audio file
		audioFile = sox_open_read(fileName, NULL, NULL, NULL);

		if (audioFile == NULL || audioFile->encoding.encoding == SOX_ENCODING_UNKNOWN) {
			throw invalid_argument("Could not open audio file. Either the file is not an audio file or SoX does not support its format.");
		} else if (!audioFile->seekable) {
			throw invalid_argument("Audio file is not seekable. Aborting.");
		}

		//load file information
		SAMPLE_RATE = (unsigned int) audioFile->signal.rate;
		CHANNELS = audioFile->signal.channels;
		SIZE = audioFile->signal.length;

		//set buffer settings
		BUFFER_FRAMES = 1024 * CHANNELS;
		BUFFER_SIZE = BUFFER_FRAMES * sizeof(float);

		//initialize the zero'd memory used for when the stream is paused
		nil = new float[BUFFER_FRAMES];
		memset((void *) nil, 0, BUFFER_SIZE);
		paused = true;

		//generate sound effects for rewinding and fast forwarding
		generateRewindEffect();
		generateFastForwardEffect();

		//initialize audio file reader
		reader = new AudioFileReader(audioFile, fileName, errorCheck, CHANNELS, SIZE, BUFFER_FRAMES, SAMPLE_RATE * CHANNELS, (SAMPLE_RATE * CHANNELS * 5) + BUFFER_FRAMES);
		stretcher = new SlowBuffer(reader, SAMPLE_RATE, CHANNELS);

		/*
		 * connect to Pulseaduio server and set up buffer
		 */

		//set buffer settings
		pa_buffer_attr bufferInfo;
		bufferInfo.maxlength = BUFFER_SIZE * 2;
		bufferInfo.tlength = BUFFER_SIZE * 2;
		bufferInfo.minreq = BUFFER_SIZE;
		bufferInfo.prebuf = BUFFER_SIZE;

		//set sample settings
		pa_sample_spec sampleFormat;
		sampleFormat.format = PA_SAMPLE_FLOAT32LE;
		sampleFormat.rate = SAMPLE_RATE;
		sampleFormat.channels = CHANNELS;

		//create default pulseAudio main loop
		PALoop = pa_mainloop_new();

		//initialize pulseAudio context and stream
		context = pa_context_new(pa_mainloop_get_api(PALoop), "QTranscribe Context");
		if (context == NULL) throw runtime_error("Error connecting to PulseAudio server:\nCould not create context.\n");
		pa_context_connect(context, NULL, PA_CONTEXT_NOFLAGS, NULL);

		audioStream = pa_stream_new(context, "QTranscribe Audio Stream", &sampleFormat, NULL);
		if (audioStream == NULL) throw runtime_error("Error connecting to PulseAudio server:\nCould not create audio stream.\n");

		//wait for context to become ready
		while (pa_context_get_state(context) != PA_CONTEXT_READY) pa_mainloop_iterate(PALoop, true, &dontcare);

		//setup audio stream
		pa_stream_connect_playback(audioStream, NULL, &bufferInfo, PA_STREAM_NOFLAGS, NULL, NULL);
		pa_stream_set_write_callback(audioStream, (pa_stream_request_cb_t) fetchAudioData, (void *) this);
		while (pa_stream_get_state(audioStream) != PA_STREAM_READY) pa_mainloop_iterate(PALoop, true, &dontcare);

		//run the pulseAudio main loop in a new thread
		loopThread = new thread(pa_mainloop_run, PALoop, &dontcare);
	}

	void setSpeed(float rate) {
		if (speed != rate) {
			positionLock.lock();
			stretcher->setSpeed(rate);
			speed = rate;
			positionLock.unlock();
		}
	}

	inline void setPositionMilliseconds(unsigned int ms) {
		positionLock.lock();
		pa_stream_flush(audioStream, NULL, NULL);
		position = (unsigned int) (SAMPLE_RATE * CHANNELS * (((double) ms) / (double) 1000));
		positionLock.unlock();
	}

	inline void skipForward(int ms) {
		if (ms == 0) return;
		positionLock.lock();
		pa_stream_flush(audioStream, NULL, NULL);
		int diff = (int) (SAMPLE_RATE * CHANNELS * (((double) ms) / (double) 1000));
		if (ms < 0 && (unsigned int) (-1 * diff) > position) {
			position = 0;
		} else {
			position += diff;
		}
		positionLock.unlock();
	}

	//don't really need to use positionLock for setting play/pause or mode, so I won't

	inline void play() {
		paused = false;
	}

	inline void pause() {
		paused = true;
	}

	inline bool isPaused() {
		return paused;
	}

	inline bool isSlowed() {
		return (speed != 1.0);
	}

	inline void stopRewind() {
		if (mode == REWIND) mode = NORMAL;
	}

	inline void stopFastForward() {
		if (mode == FAST_FORWARD) mode = NORMAL;
	}

	inline void startRewind() {
		mode = REWIND;
	}

	inline void startFastForward() {
		mode = FAST_FORWARD;
	}

	inline bool isRewinding() {
		return (mode == REWIND);
	}

	inline bool isFastForwarding() {
		return (mode == FAST_FORWARD);
	}

	unsigned int getPositionMilliseconds() {
		positionLock.lock();
		unsigned int ret = (unsigned int) ((double) 1000 * ((double) position / (double) (SAMPLE_RATE * CHANNELS)));
		positionLock.unlock();
		return ret;
	}

	unsigned int getLengthMilliseconds() {
		return (unsigned int) ((double) 1000 * ((double) SIZE / (double) (SAMPLE_RATE * CHANNELS)));
	}

	~Dictation() {
		pa_stream_drain(audioStream, NULL, NULL);
		positionLock.lock();
		pa_mainloop_quit(PALoop, 0);
		pa_stream_disconnect(audioStream);
		pa_stream_unref(audioStream);
		pa_context_disconnect(context);
		pa_context_unref(context);
		pa_mainloop_free(PALoop);
		loopThread->join();
		delete loopThread;
		delete stretcher;
		delete reader;
		sox_close(audioFile);
		delete[] nil;
		delete[] fileName;
		freeSFX();
		positionLock.unlock();
	};
};

#endif /* DICTATION_H_ */