Implemented the softsynth support classes and a skeleton for

the synth itself.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@7565 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/kits/midi/Jamfile

@@ -11,6 +11,7 @@ SharedLibrary midi :
 	MidiSynthFile.cpp
 	MidiText.cpp
 	Samples.cpp
+	SoftSynth.cpp
 	Synth.cpp
 ;
 

src/kits/midi/MidiSynth.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2002-2004 Matthijs Hollemans
+ * Copyright (c) 2003 Jerome Leveque
  *
  * Permission is hereby granted, free of charge, to any person obtaining a 
  * copy of this software and associated documentation files (the "Software"), 
@@ -22,137 +23,144 @@
 
 #include "debug.h"
 #include "MidiSynth.h"
+#include "SoftSynth.h"
+
+using namespace BPrivate;
 
 //------------------------------------------------------------------------------
 
 BMidiSynth::BMidiSynth()
 {
-	/* not complete yet */
-
 	if (be_synth == NULL)
 	{
 		new BSynth();
 	}
+
+	be_synth->clientCount++;
+
+	inputEnabled = false;
+	transpose = 0;
+	creationTime = system_time();
 }
 
 //------------------------------------------------------------------------------
 
 BMidiSynth::~BMidiSynth()
 {
-	UNIMPLEMENTED
+	be_synth->clientCount--;
 }
 
 //------------------------------------------------------------------------------
 
 status_t BMidiSynth::EnableInput(bool enable, bool loadInstruments)
 {
-	UNIMPLEMENTED
+	status_t err = B_OK;
-	return B_ERROR;
+	inputEnabled = enable;
+	
+	if (loadInstruments)
+	{
+		err = be_synth->synth->LoadAllInstruments();
+	}
+
+	return err;
 }
 
 //------------------------------------------------------------------------------
 
 bool BMidiSynth::IsInputEnabled(void) const
 {
-	UNIMPLEMENTED
+	return inputEnabled;
-	return false;
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::SetVolume(double volume)
 {
-	UNIMPLEMENTED
+	be_synth->synth->SetVolume(volume);
 }
 
 //------------------------------------------------------------------------------
 
 double BMidiSynth::Volume(void) const
 {
-	UNIMPLEMENTED
+	return be_synth->synth->Volume();
-	return 0;
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::SetTransposition(int16 offset)
 {
-	UNIMPLEMENTED
+	transpose = offset;
 }
 
 //------------------------------------------------------------------------------
 
 int16 BMidiSynth::Transposition(void) const
 {
-	UNIMPLEMENTED
+	return transpose;
-	return 0;
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::MuteChannel(int16 channel, bool do_mute)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] MuteChannel is broken; don't use it\n");
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::GetMuteMap(char* pChannels) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] GetMuteMap is broken; don't use it\n");
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::SoloChannel(int16 channel, bool do_solo)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] SoloChannel is broken; don't use it\n");
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::GetSoloMap(char* pChannels) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] GetSoloMap is broken; don't use it\n");
 }
 
 //------------------------------------------------------------------------------
 
 status_t BMidiSynth::LoadInstrument(int16 instrument)
 {
-	UNIMPLEMENTED
+	return be_synth->synth->LoadInstrument(instrument);
-	return B_ERROR;
 }
 
 //------------------------------------------------------------------------------
 
 status_t BMidiSynth::UnloadInstrument(int16 instrument)
 {
-	UNIMPLEMENTED
+	return be_synth->synth->UnloadInstrument(instrument);
-	return B_ERROR;
 }
 
 //------------------------------------------------------------------------------
 
 status_t BMidiSynth::RemapInstrument(int16 from, int16 to)
 {
-	UNIMPLEMENTED
+	return be_synth->synth->RemapInstrument(from, to);
-	return B_ERROR;
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::FlushInstrumentCache(bool startStopCache)
 {
-	UNIMPLEMENTED
+	be_synth->synth->FlushInstrumentCache(startStopCache);
 }
 
 //------------------------------------------------------------------------------
 
 uint32 BMidiSynth::Tick(void) const
 {
-	UNIMPLEMENTED
+	return (uint32) (system_time() - creationTime);
-	return 0;
 }
 
 //------------------------------------------------------------------------------
@@ -160,7 +168,10 @@ uint32 BMidiSynth::Tick(void) const
 void BMidiSynth::NoteOff(
 	uchar channel, uchar note, uchar velocity, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->NoteOff(channel, note + transpose, velocity, time);
+	}
 }
 
 //------------------------------------------------------------------------------
@@ -168,7 +179,10 @@ void BMidiSynth::NoteOff(
 void BMidiSynth::NoteOn(
 	uchar channel, uchar note, uchar velocity, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->NoteOn(channel, note + transpose, velocity, time);
+	}
 }
 
 //------------------------------------------------------------------------------
@@ -176,7 +190,11 @@ void BMidiSynth::NoteOn(
 void BMidiSynth::KeyPressure(
 	uchar channel, uchar note, uchar pressure, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->KeyPressure(
+			channel, note + transpose, pressure, time);
+	}
 }
 
 //------------------------------------------------------------------------------
@@ -184,7 +202,11 @@ void BMidiSynth::KeyPressure(
 void BMidiSynth::ControlChange(
 	uchar channel, uchar controlNumber, uchar controlValue, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->ControlChange(
+			channel, controlNumber, controlValue, time);
+	}
 }
 
 //------------------------------------------------------------------------------
@@ -192,28 +214,40 @@ void BMidiSynth::ControlChange(
 void BMidiSynth::ProgramChange(
 	uchar channel, uchar programNumber, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->ProgramChange(channel, programNumber, time);
+	}
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::ChannelPressure(uchar channel, uchar pressure, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->ChannelPressure(channel, pressure, time);
+	}
 }
 
 //------------------------------------------------------------------------------
 
 void BMidiSynth::PitchBend(uchar channel, uchar lsb, uchar msb, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->PitchBend(channel, lsb, msb, time);
+	}
 }
 
 //------------------------------------------------------------------------------
 
-void BMidiSynth::AllNotesOff(bool controlOnly, uint32 time)
+void BMidiSynth::AllNotesOff(bool justChannel, uint32 time)
 {
-	UNIMPLEMENTED
+	if (inputEnabled)
+	{
+		be_synth->synth->AllNotesOff(justChannel, time);
+	}
 }
 
 //------------------------------------------------------------------------------
@@ -227,7 +261,7 @@ void BMidiSynth::_ReservedMidiSynth4() { }
 
 void BMidiSynth::Run()
 {
-	UNIMPLEMENTED
+	// do nothing
 }
 
 //------------------------------------------------------------------------------

src/kits/midi/Samples.cpp

@@ -28,8 +28,6 @@
 
 BSamples::BSamples()
 {
-	/* not complete yet */
-
 	if (be_synth == NULL)
 	{
 		new BSynth();
@@ -40,7 +38,7 @@ BSamples::BSamples()
 
 BSamples::~BSamples()
 {
-	UNIMPLEMENTED
+	// do nothing
 }
 
 //------------------------------------------------------------------------------
@@ -51,14 +49,14 @@ void BSamples::Start(
 	double sampleVolume, double stereoPosition, int32 hook_arg, 
 	sample_loop_hook pLoopContinueProc, sample_exit_hook pDoneProc)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 bool BSamples::IsPaused(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 	return false;
 }
 
@@ -66,28 +64,28 @@ bool BSamples::IsPaused(void) const
 
 void BSamples::Pause(void)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 void BSamples::Resume(void)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 void BSamples::Stop(void)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 bool BSamples::IsPlaying(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 	return false;
 }
 
@@ -95,14 +93,14 @@ bool BSamples::IsPlaying(void) const
 
 void BSamples::SetVolume(double newVolume)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 double BSamples::Volume(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 	return 0;
 }
 
@@ -110,14 +108,14 @@ double BSamples::Volume(void) const
 
 void BSamples::SetSamplingRate(double newRate)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 double BSamples::SamplingRate(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 	return 0;
 }
 
@@ -125,14 +123,14 @@ double BSamples::SamplingRate(void) const
 
 void BSamples::SetPlacement(double stereoPosition)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 double BSamples::Placement(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 	return 0;
 }
 
@@ -140,7 +138,7 @@ double BSamples::Placement(void) const
 
 void BSamples::EnableReverb(bool useReverb)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] BSamples is not supported\n");
 }
 
 //------------------------------------------------------------------------------

src/kits/midi/SoftSynth.cpp

@@ -0,0 +1,389 @@
+/* 
+ * Copyright (c) 2004 Matthijs Hollemans
+ * Copyright (c) 2003 Jerome Leveque
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in 
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <FindDirectory.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "debug.h"
+#include "SoftSynth.h"
+
+using namespace BPrivate;
+
+//------------------------------------------------------------------------------
+
+BSoftSynth::BSoftSynth()
+{
+	instrumentsFile = NULL;
+	SetDefaultInstrumentsFile();
+
+	sampleRate = 22050;
+	interpMode = B_LINEAR_INTERPOLATION;
+	maxVoices = 28;
+	limiterThreshold = 7;
+	reverbEnabled = true;
+	reverbMode = B_REVERB_BALLROOM;
+	volumeScale = 1.0;
+}
+
+//------------------------------------------------------------------------------
+
+BSoftSynth::~BSoftSynth()
+{
+	Unload();
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::Unload(void)
+{
+	/* TODO: purge samples from memory */
+	
+	free(instrumentsFile);
+	instrumentsFile = NULL;
+}
+
+//------------------------------------------------------------------------------
+
+bool BSoftSynth::IsLoaded(void) const
+{
+	return instrumentsFile != NULL;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::SetDefaultInstrumentsFile()
+{
+	char buf[B_PATH_NAME_LENGTH + 1];
+
+	if (B_OK == find_directory(
+			B_SYNTH_DIRECTORY, NULL, false, buf, B_PATH_NAME_LENGTH))
+	{
+		strcat(buf, B_BIG_SYNTH_FILE);
+		return SetInstrumentsFile(buf);
+	}
+	
+	return B_ERROR;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::SetInstrumentsFile(const char* path)
+{
+	if (path == NULL)
+	{
+		return B_BAD_VALUE;
+	}
+	
+	if (IsLoaded())
+	{
+		Unload();
+	}
+	
+	instrumentsFile = strdup(path);
+	return B_OK;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::LoadAllInstruments()
+{
+	/* TODO: Should load all of the instruments from the sample bank. */
+
+	UNIMPLEMENTED
+	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 (volume >= 0.0)
+	{
+		volumeScale = volume;
+	}
+}
+
+//------------------------------------------------------------------------------
+
+double BSoftSynth::Volume(void) const
+{
+	return volumeScale;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::SetSamplingRate(int32 rate)
+{
+	// TODO: According to the BeBook, we should round rate to the nearest
+	// acceptable value. However, this function may change depending on the 
+	// softsynth back-end we'll use.
+
+	if (rate == 11025 || rate == 22050 || rate == 44100)
+	{
+		sampleRate = rate;
+		return B_OK;
+	}
+	
+	return B_BAD_VALUE;
+}
+
+//------------------------------------------------------------------------------
+
+int32 BSoftSynth::SamplingRate() const
+{
+	return sampleRate;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::SetInterpolation(interpolation_mode mode)
+{
+	// TODO: this function could change depending on the synth back-end.
+	
+	interpMode = mode;
+	return B_OK;
+}
+
+//------------------------------------------------------------------------------
+
+interpolation_mode BSoftSynth::Interpolation() const
+{
+	return interpMode;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::EnableReverb(bool enabled)
+{
+	reverbEnabled = enabled;
+	return B_OK;
+}
+
+//------------------------------------------------------------------------------
+
+bool BSoftSynth::IsReverbEnabled() const
+{
+	return reverbEnabled;
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::SetReverb(reverb_mode mode)
+{
+	// TODO: this function could change depending on the synth back-end.
+
+	reverbMode = mode;
+}
+
+//------------------------------------------------------------------------------
+
+reverb_mode BSoftSynth::Reverb() const
+{
+	return reverbMode;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::SetMaxVoices(int32 max)
+{
+	// TODO: this function could change depending on the synth back-end.
+
+	if (max > 0 && max <= 32)
+	{
+		maxVoices = max;
+		return B_OK;
+	}
+	
+	return B_BAD_VALUE;
+}
+
+//------------------------------------------------------------------------------
+
+int16 BSoftSynth::MaxVoices(void) const
+{
+	return maxVoices;
+}
+
+//------------------------------------------------------------------------------
+
+status_t BSoftSynth::SetLimiterThreshold(int32 threshold)
+{
+	// TODO: this function could change depending on the synth back-end.
+
+	if (threshold > 0 && threshold <= 32)
+	{
+		limiterThreshold = threshold;
+		return B_OK;
+	}
+	
+	return B_BAD_VALUE;
+}
+
+//------------------------------------------------------------------------------
+
+int16 BSoftSynth::LimiterThreshold(void) const
+{
+	return limiterThreshold;
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::Pause(void)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::Resume(void)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::NoteOff(
+	uchar channel, uchar note, uchar velocity, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::NoteOn(
+	uchar channel, uchar note, uchar velocity, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::KeyPressure(
+	uchar channel, uchar note, uchar pressure, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::ControlChange(
+	uchar channel, uchar controlNumber, uchar controlValue, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::ProgramChange(
+	uchar channel, uchar programNumber, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::ChannelPressure(
+	uchar channel, uchar pressure, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::PitchBend(
+	uchar channel, uchar lsb, uchar msb, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::SystemExclusive(void* data, size_t length, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::SystemCommon(
+	uchar status, uchar data1, uchar data2, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::SystemRealTime(uchar status, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::TempoChange(int32 beatsPerMinute, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------
+
+void BSoftSynth::AllNotesOff(bool justChannel, uint32 time)
+{
+	UNIMPLEMENTED
+}
+
+//------------------------------------------------------------------------------

src/kits/midi/SoftSynth.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2004 Matthijs Hollemans
+ * Copyright (c) 2003 Jerome Leveque
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in 
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _SOFT_SYNTH_H
+#define _SOFT_SYNTH_H
+
+#include <Midi.h>
+#include <Synth.h>
+
+namespace BPrivate {
+
+class BSoftSynth
+{
+public:
+
+	void Unload(void);
+	bool IsLoaded(void) const;
+
+	status_t SetDefaultInstrumentsFile();
+	status_t SetInstrumentsFile(const char* path);
+
+	status_t LoadAllInstruments();
+	status_t LoadInstrument(int16 instrument);
+	status_t UnloadInstrument(int16 instrument);
+	status_t RemapInstrument(int16 from, int16 to);
+	void FlushInstrumentCache(bool startStopCache);
+
+	void SetVolume(double volume);
+	double Volume(void) const;
+
+	status_t SetSamplingRate(int32 rate);
+	int32 SamplingRate() const;
+
+	status_t SetInterpolation(interpolation_mode mode);
+	interpolation_mode Interpolation() const;
+
+	status_t EnableReverb(bool enabled);
+	bool IsReverbEnabled() const;
+	void SetReverb(reverb_mode mode);
+	reverb_mode Reverb() const;
+
+	status_t SetMaxVoices(int32 max);
+	int16 MaxVoices(void) const;
+
+	status_t SetLimiterThreshold(int32 threshold);
+	int16 LimiterThreshold(void) const;
+
+	void Pause(void);
+	void Resume(void);
+
+	void NoteOff(uchar, uchar, uchar, uint32);
+	void NoteOn(uchar, uchar, uchar, uint32);
+	void KeyPressure(uchar, uchar, uchar, uint32);
+	void ControlChange(uchar, uchar, uchar, uint32);
+	void ProgramChange(uchar, uchar, uint32);
+ 	void ChannelPressure(uchar, uchar, uint32);
+	void PitchBend(uchar, uchar, uchar, uint32);
+	void SystemExclusive(void*, size_t, uint32);
+	void SystemCommon(uchar, uchar, uchar, uint32);
+	void SystemRealTime(uchar, uint32);
+	void TempoChange(int32, uint32);
+	void AllNotesOff(bool, uint32);
+
+private:
+
+	friend class BSynth;
+	friend class BMidiSynth;
+
+	BSoftSynth();
+	~BSoftSynth();
+
+	char* instrumentsFile;
+	int32 sampleRate;
+	interpolation_mode interpMode;
+	int16 maxVoices;
+	int16 limiterThreshold;
+	reverb_mode reverbMode;
+	bool reverbEnabled;
+	double volumeScale;
+};
+
+} // namespace BPrivate
+
+#endif // _SYNTH_CONSUMER_H

src/kits/midi/Synth.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2002-2004 Matthijs Hollemans
+ * Copyright (c) 2003 Jerome Leveque
  *
  * Permission is hereby granted, free of charge, to any person obtaining a 
  * copy of this software and associated documentation files (the "Software"), 
@@ -22,35 +23,32 @@
 
 #include "debug.h"
 #include "Synth.h"
+#include "SoftSynth.h"
 
 BSynth* be_synth = NULL;
 
+using namespace BPrivate;
+
 //------------------------------------------------------------------------------
 
 BSynth::BSynth()
 {
-	/* not complete yet */
+	Init();
-
-	delete be_synth;
-	be_synth = this;
 }
 
 //------------------------------------------------------------------------------
 
-BSynth::BSynth(synth_mode synth)
+BSynth::BSynth(synth_mode mode)
 {
-	/* not complete yet */
+	Init();
-
+	synthMode = mode;
-	delete be_synth;
-	be_synth = this;
 }
 
 //------------------------------------------------------------------------------
 
 BSynth::~BSynth()
 {
-	/* not complete yet */
+	delete synth;
-	
 	be_synth = NULL;
 }
 
@@ -58,102 +56,107 @@ BSynth::~BSynth()
 
 status_t BSynth::LoadSynthData(entry_ref* instrumentsFile)
 {
-	UNIMPLEMENTED
+	if (instrumentsFile == NULL)
-	return B_ERROR;
+	{
+		return B_BAD_VALUE;
+	}
+	
+	return synth->SetInstrumentsFile(instrumentsFile->name);
 }
 
 //------------------------------------------------------------------------------
 
-status_t BSynth::LoadSynthData(synth_mode synth)
+status_t BSynth::LoadSynthData(synth_mode mode)
 {
-	UNIMPLEMENTED
+	// Our softsynth doesn't support multiple modes like Be's synth did.
-	return B_ERROR;
+	// Therefore, if you use this function, the synth will revert to its
+	// default instruments bank. However, we do keep track of the current
+	// synth_mode here, in order not to confuse old applications.
+
+	synthMode = mode;
+	if (synthMode == B_SAMPLES_ONLY)
+	{
+		fprintf(stderr, "[midi] LoadSynthData: BSamples is not supported\n");
+	}
+
+	return synth->SetDefaultInstrumentsFile();
 }
 
 //------------------------------------------------------------------------------
 
 synth_mode BSynth::SynthMode(void)
 {
-	UNIMPLEMENTED
+	return synthMode;
-	return B_NO_SYNTH;
 }
 
 //------------------------------------------------------------------------------
 
 void BSynth::Unload(void)
 {
-	UNIMPLEMENTED
+	synth->Unload();
 }
 
 //------------------------------------------------------------------------------
 
 bool BSynth::IsLoaded(void) const
 {
-	UNIMPLEMENTED
+	return synth->IsLoaded();
-	return false;
 }
 
 //------------------------------------------------------------------------------
 
 status_t BSynth::SetSamplingRate(int32 sample_rate)
 {
-	UNIMPLEMENTED
+	return synth->SetSamplingRate(sample_rate);
-	return B_ERROR;
 }
 
 //------------------------------------------------------------------------------
 
 int32 BSynth::SamplingRate() const
 {
-	UNIMPLEMENTED
+	return synth->SamplingRate();
-	return 0;
 }
 
 //------------------------------------------------------------------------------
 
 status_t BSynth::SetInterpolation(interpolation_mode interp_mode)
 {
-	UNIMPLEMENTED
+	return synth->SetInterpolation(interp_mode);
-	return B_ERROR;
 }
 
 //------------------------------------------------------------------------------
 
 interpolation_mode BSynth::Interpolation() const
 {
-	UNIMPLEMENTED
+	return synth->Interpolation();
-	return B_DROP_SAMPLE;
 }
 
 //------------------------------------------------------------------------------
 
 void BSynth::SetReverb(reverb_mode rev_mode)
 {
-	UNIMPLEMENTED
+	synth->SetReverb(rev_mode);
 }
 
 //------------------------------------------------------------------------------
 
 reverb_mode BSynth::Reverb() const
 {
-	UNIMPLEMENTED
+	return synth->Reverb();
-	return B_REVERB_NONE;
 }
 
 //------------------------------------------------------------------------------
 
 status_t BSynth::EnableReverb(bool reverb_enabled)
 {
-	UNIMPLEMENTED
+	return synth->EnableReverb(reverb_enabled);
-	return B_ERROR;
 }
 
 //------------------------------------------------------------------------------
 
 bool BSynth::IsReverbEnabled() const
 {
-	UNIMPLEMENTED
+	return synth->IsReverbEnabled();
-	return false;
 }
 
 //------------------------------------------------------------------------------
@@ -161,23 +164,27 @@ bool BSynth::IsReverbEnabled() const
 status_t BSynth::SetVoiceLimits(
 	int16 maxSynthVoices, int16 maxSampleVoices, int16 limiterThreshhold)
 {
-	UNIMPLEMENTED
+	status_t err = B_OK;
-	return B_ERROR;
+	err = synth->SetMaxVoices(maxSynthVoices);
+	if (err == B_OK)
+	{
+		err = synth->SetLimiterThreshold(limiterThreshhold);
+	}
+	return err;
 }
 
 //------------------------------------------------------------------------------
 
 int16 BSynth::MaxSynthVoices(void) const
 {
-	UNIMPLEMENTED
+	return synth->MaxVoices();
-	return 0;
 }
 
 //------------------------------------------------------------------------------
 
 int16 BSynth::MaxSampleVoices(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] MaxSampleVoices: BSamples not supported\n");
 	return 0;
 }
 
@@ -185,37 +192,35 @@ int16 BSynth::MaxSampleVoices(void) const
 
 int16 BSynth::LimiterThreshhold(void) const
 {
-	UNIMPLEMENTED
+	return synth->LimiterThreshold();
-	return 0;
 }
 
 //------------------------------------------------------------------------------
 
 void BSynth::SetSynthVolume(double theVolume)
 {
-	UNIMPLEMENTED
+	synth->SetVolume(theVolume);
 }
 
 //------------------------------------------------------------------------------
 
 double BSynth::SynthVolume(void) const
 {
-	UNIMPLEMENTED
+	return synth->Volume();
-	return 0;
 }
 
 //------------------------------------------------------------------------------
 
 void BSynth::SetSampleVolume(double theVolume)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] SetSampleVolume: BSamples not supported\n");
 }
 
 //------------------------------------------------------------------------------
 
 double BSynth::SampleVolume(void) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] SampleVolume: BSamples not supported\n");
 	return 0;
 }
 
@@ -224,7 +229,7 @@ double BSynth::SampleVolume(void) const
 status_t BSynth::GetAudio(
 	int16* pLeft, int16* pRight, int32 max_samples) const
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] GetAudio is not supported\n");
 	return B_ERROR;
 }
 
@@ -232,29 +237,39 @@ status_t BSynth::GetAudio(
 
 void BSynth::Pause(void)
 {
-	UNIMPLEMENTED
+	synth->Pause();
 }
 
 //------------------------------------------------------------------------------
 
 void BSynth::Resume(void)
 {
-	UNIMPLEMENTED
+	synth->Resume();
 }
 
 //------------------------------------------------------------------------------
 
 void BSynth::SetControllerHook(int16 controller, synth_controller_hook cback)
 {
-	UNIMPLEMENTED
+	fprintf(stderr, "[midi] SetControllerHook is not supported\n");
+}
+
+//------------------------------------------------------------------------------
+
+void BSynth::Init()
+{
+	delete be_synth;
+	be_synth = this;
+	synthMode = B_NO_SYNTH;
+	clientCount = 0;
+	synth = new BSoftSynth();
 }
 
 //------------------------------------------------------------------------------
 
 int32 BSynth::CountClients(void) const
 {
-	UNIMPLEMENTED
+	return clientCount;
-	return 0;
 }
 
 //------------------------------------------------------------------------------