haiku.git

/*
 * Copyright 2006-2014, Haiku.
 *
 * Copyright (c) 2004-2005 Matthijs Hollemans
 * Copyright (c) 2003 Jerome Leveque
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 * 		Jérôme Duval
 *		Jérôme Leveque
 *		Matthijs Hollemans
 *		Pete Goodeve
 */

#include <MidiRoster.h>
#include <MidiConsumer.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <Node.h>
#include <NodeInfo.h>
#include <Path.h>
#include <PathFinder.h>

#include <string.h>
#include <stdlib.h>

#include <MidiSettings.h>

#include "debug.h"
#include "MidiGlue.h"   // for MAKE_BIGTIME
#include "SoftSynth.h"

using namespace BPrivate;

struct ReverbSettings {
	double room, damp, width, level;
} gReverbSettings[] = {
		 {0.0, 0.0, 0.0, 0.0},   //  B_REVERB_NONE
		 {0.2, 0.0, 0.5, 0.9},   //  B_REVERB_CLOSET
		 {0.5, 0.0, 0.9, 0.9},   //  B_REVERB_GARAGE
		 {0.7, 0.25, 0.9, 0.95}, //  B_REVERB_BALLROOM
		 {0.99, 0.3, 1.0, 1.0},  //  B_REVERB_CAVERN
		 {1.03, 0.6, 1.0, 1.0}   //  B_REVERB_DUNGEON
};


BSoftSynth::BSoftSynth()
: 	fInitCheck(false),
	fSynth(NULL),
	fSettings(NULL),
	fSoundPlayer(NULL),
	fMonitor(NULL),
	fMonitorSize(0),
	fMonitorChans(-1)
{
	fInstrumentsFile = NULL;
	SetDefaultInstrumentsFile();

	fSampleRate = 44100;
	fInterpMode = B_LINEAR_INTERPOLATION;
	fMaxVoices = 256;
	fLimiterThreshold = 7;
	fReverbEnabled = true;
	fReverbMode = B_REVERB_BALLROOM;
}


BSoftSynth::~BSoftSynth()
{
	// Note: it is possible that we don't get deleted. When BSynth is
	// created, it is assigned to the global variable be_synth. While
	// BSynth is alive, it keeps a copy of BSoftSynth around too. Not
	// a big deal, but the Midi Kit will complain (on stdout) that we 
	// didn't release our endpoints.

	delete[] fMonitor;
	Unload();
}


bool 
BSoftSynth::InitCheck()
{
	if (!fSynth)
		_Init();
	return fInitCheck;
}


void 
BSoftSynth::Unload(void)
{
	_Done();
	free(fInstrumentsFile);
	fInstrumentsFile = NULL;
}


bool 
BSoftSynth::IsLoaded(void) const
{
	return fInstrumentsFile != NULL;
}


status_t 
BSoftSynth::SetDefaultInstrumentsFile()
{
	// TODO: Duplicated code, check MidiSettingsView::_LoadSettings() and
	// MidiSettingsView::_RetrieveSoftSynthList()
	// We first search for a setting file (or symlink to it)
	// in the user settings directory

	struct BPrivate::midi_settings settings;
	if (BPrivate::read_midi_settings(&settings) == B_OK) {
		if (SetInstrumentsFile(settings.soundfont_file) == B_OK)
			return B_OK;
	}

	// Try a well-known (and usually present on a default install) soft synth
	BPath path;
	if (find_directory(B_SYNTH_DIRECTORY, &path, false, NULL) == B_OK) {
		path.Append("synth/TimGM6mb.sf2");
		if (SetInstrumentsFile(path.Path()) == B_OK)
			return B_OK;
	}

	// Just use the first soundfont we find
	BStringList paths;
	status_t status = BPathFinder::FindPaths(B_FIND_PATH_DATA_DIRECTORY,
			"synth", paths);

	if (status != B_OK)
		return B_ERROR;

	for (int32 i = 0; i < paths.CountStrings(); i++) {
		BDirectory directory(paths.StringAt(i).String());
		BEntry entry;
		if (directory.InitCheck() != B_OK)
			continue;
		while (directory.GetNextEntry(&entry) == B_OK) {
			BNode node(&entry);
			BNodeInfo nodeInfo(&node);
			char mimeType[B_MIME_TYPE_LENGTH];
			// TODO: For some reason the mimetype check fails.
			// maybe because the file hasn't yet been sniffed and recognized?
			if (nodeInfo.GetType(mimeType) == B_OK
				/*&& !strcmp(mimeType, "audio/x-soundfont")*/) {
				BPath fullPath = paths.StringAt(i).String();
				fullPath.Append(entry.Name());
				if (SetInstrumentsFile(fullPath.Path()) == B_OK)
					return B_OK;
			}
		}
	}

	// TODO: Write the settings file ?
	
	return B_ERROR;
}


status_t 
BSoftSynth::SetInstrumentsFile(const char* path)
{
	if (path == NULL)
		return B_BAD_VALUE;
	
	if (!BEntry(path).Exists())
		return B_ENTRY_NOT_FOUND;

	if (IsLoaded())
		Unload();
	
	fInstrumentsFile = strdup(path);
	return B_OK;
}


status_t 
BSoftSynth::LoadAllInstruments()
{
	InitCheck();
	return B_OK;
}


status_t 
BSoftSynth::LoadInstrument(int16 instrument)
{
	UNIMPLEMENTED
	return B_OK;
}


status_t 
BSoftSynth::UnloadInstrument(int16 instrument)
{
	UNIMPLEMENTED
	return B_OK;
}


status_t 
BSoftSynth::RemapInstrument(int16 from, int16 to)
{
	UNIMPLEMENTED
	return B_OK;
}


void 
BSoftSynth::FlushInstrumentCache(bool startStopCache)
{
	// TODO: we may decide not to support this function because it's weird!
	
	UNIMPLEMENTED
}


void 
BSoftSynth::SetVolume(double volume)
{
	if (InitCheck())
		if (volume >= 0.0) {
			fluid_synth_set_gain(fSynth, volume);
		}
}


double 
BSoftSynth::Volume(void) const
{
	return fluid_synth_get_gain(fSynth);
}


status_t 
BSoftSynth::SetSamplingRate(int32 rate)
{
	if (rate == 22050 || rate == 44100 || rate == 48000) {
		fSampleRate = rate;
		return B_OK;
	}
	
	return B_BAD_VALUE;
}


int32 
BSoftSynth::SamplingRate() const
{
	return fSampleRate;
}


status_t 
BSoftSynth::SetInterpolation(interpolation_mode mode)
{
	// not used because our synth uses the same format than the soundplayer
	fInterpMode = mode;
	return B_OK;
}


interpolation_mode 
BSoftSynth::Interpolation() const
{
	return fInterpMode;
}


status_t 
BSoftSynth::EnableReverb(bool enabled)
{
	fReverbEnabled = enabled;
	fluid_synth_set_reverb_on(fSynth, enabled);
	return B_OK;
}


bool 
BSoftSynth::IsReverbEnabled() const
{
	return fReverbEnabled;
}


void 
BSoftSynth::SetReverb(reverb_mode mode)
{
	if (mode < B_REVERB_NONE || mode > B_REVERB_DUNGEON)
		return;

	fReverbMode = mode;
	if (fSynth) {
		// We access the table using "mode - 1" because B_REVERB_NONE == 1
		ReverbSettings *rvb = &gReverbSettings[mode - 1];
		fluid_synth_set_reverb(fSynth, rvb->room, rvb->damp, rvb->width,
				rvb->level);
	}
}


reverb_mode 
BSoftSynth::Reverb() const
{
	return fReverbMode;
}


status_t 
BSoftSynth::SetMaxVoices(int32 max)
{
	if (max > 0 && max <= 4096) {
		fMaxVoices = max;
		return B_OK;
	}
	
	return B_BAD_VALUE;
}


int16 
BSoftSynth::MaxVoices(void) const
{
	return fMaxVoices;
}


status_t 
BSoftSynth::SetLimiterThreshold(int32 threshold)
{
	// not used
	if (threshold > 0 && threshold <= 32) {
		fLimiterThreshold = threshold;
		return B_OK;
	}
	
	return B_BAD_VALUE;
}


int16 
BSoftSynth::LimiterThreshold(void) const
{
	return fLimiterThreshold;
}


void 
BSoftSynth::Pause(void)
{
	UNIMPLEMENTED
}


void 
BSoftSynth::Resume(void)
{
	UNIMPLEMENTED
}


void 
BSoftSynth::NoteOff(
	uchar channel, uchar note, uchar velocity, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		fluid_synth_noteoff(fSynth, channel - 1, note);	// velocity isn't used in FS
	}
}


void 
BSoftSynth::NoteOn(
	uchar channel, uchar note, uchar velocity, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		fluid_synth_noteon(fSynth, channel - 1, note, velocity);
	}
}


void 
BSoftSynth::KeyPressure(
	uchar channel, uchar note, uchar pressure, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		// unavailable
	}
}


void 
BSoftSynth::ControlChange(
	uchar channel, uchar controlNumber, uchar controlValue, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		fluid_synth_cc(fSynth, channel - 1, controlNumber, controlValue);
	}
}


void 
BSoftSynth::ProgramChange(
	uchar channel, uchar programNumber, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		fluid_synth_program_change(fSynth, channel - 1, programNumber);
	}
}


void 
BSoftSynth::ChannelPressure(uchar channel, uchar pressure, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		//unavailable
	}
}


void 
BSoftSynth::PitchBend(uchar channel, uchar lsb, uchar msb, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		// fluid_synth only accepts an int
		fluid_synth_pitch_bend(fSynth, channel - 1,
			((uint32)(msb & 0x7f) << 7) | (lsb & 0x7f));
	}
}


void 
BSoftSynth::SystemExclusive(void* data, size_t length, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		// unsupported
	}
}


void 
BSoftSynth::SystemCommon(
	uchar status, uchar data1, uchar data2, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		// unsupported
	}
}


void 
BSoftSynth::SystemRealTime(uchar status, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		// unsupported
	}
}


void 
BSoftSynth::TempoChange(int32 beatsPerMinute, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);
		// unsupported
	}
}


void 
BSoftSynth::AllNotesOff(bool justChannel, uint32 time)
{
	if (InitCheck()) {
		snooze_until(MAKE_BIGTIME(time), B_SYSTEM_TIMEBASE);

		// from BMidi::AllNotesOff
		for (uchar channel = 1; channel <= 16; ++channel) {
			fluid_synth_cc(fSynth, channel - 1, B_ALL_NOTES_OFF, 0);
	
			if (!justChannel) {
				for (uchar note = 0; note <= 0x7F; ++note) {
					fluid_synth_noteoff(fSynth, channel - 1, note);
				}
			}
		}
	}
}


void 
BSoftSynth::_Init()
{
	status_t err;
	fInitCheck = false;
	
	_Done();

	fSettings = new_fluid_settings();
	fluid_settings_setnum(fSettings, (char*)"synth.sample-rate", fSampleRate);
	fluid_settings_setint(fSettings, (char*)"synth.polyphony", fMaxVoices);

	fSynth = new_fluid_synth(fSettings);
	if (!fSynth)
		return;
	
	err = fluid_synth_sfload(fSynth, fInstrumentsFile, 1); 
	if (err < B_OK) {
		fprintf(stderr, "error in fluid_synth_sfload\n");
		return;
	}

	SetReverb(fReverbMode);

	media_raw_audio_format format = media_raw_audio_format::wildcard;
	format.channel_count = 2;
	format.frame_rate = fSampleRate;
	format.format = media_raw_audio_format::B_AUDIO_FLOAT;

	fSoundPlayer = new BSoundPlayer(&format, "Soft Synth", &PlayBuffer, NULL, this);
	err = fSoundPlayer->InitCheck();
	if (err != B_OK) {
		fprintf(stderr, "error in BSoundPlayer\n");
		return;
	}

	fSoundPlayer->SetHasData(true);
	fSoundPlayer->Start();

	fInitCheck = true;
}


void 
BSoftSynth::_Done()
{
	if (fSoundPlayer) {
		fSoundPlayer->SetHasData(false);
		fSoundPlayer->Stop();
		delete fSoundPlayer;
		fSoundPlayer = NULL;
	}
	if (fSynth) {
		delete_fluid_synth(fSynth);
		fSynth = NULL;
	}
	if (fSettings) {
		delete_fluid_settings(fSettings);
		fSettings = NULL;
	}
}


void
BSoftSynth::PlayBuffer(void* cookie, void* data, size_t size,
		const media_raw_audio_format& format)
{
	BSoftSynth* synth = (BSoftSynth*)cookie;

	if (synth->fMonitorSize == 0) {
		synth->fMonitor = (float*)new void*[size];
		synth->fMonitorSize = size;
		synth->fMonitorChans = format.channel_count;
	}

	// we use float samples
	if (synth->fSynth) {
		fluid_synth_write_float(
			synth->fSynth, size / sizeof(float) / format.channel_count,
			data, 0, format.channel_count,
			data, 1, format.channel_count);

		memcpy(synth->fMonitor, data, size);
	}
}