Merged stereo support, mostly coded by tczy <tczy@wre.ath.cx>.
[jacksampler.git] / src / jacksampler.cc
1 /* JackSampler - JACK based sampler
2  * Copyright (C) 2009-2010 Stefan Westerfeld
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General
15  * Public License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19 #include <sfi/sfistore.h>
20 #include <bse/bsemain.h>
21 #include <bse/bseloader.h>
22 #include <bse/gslfft.h>
23 #include <bse/bsemathsignal.h>
24 #include <bse/bseblockutils.hh>
25 #include <list>
26 #include <unistd.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <bse/gsldatautils.h>
30
31 #include <stdio.h>
32 #include <math.h>
33 #include <unistd.h>
34 #include <string.h>
35 #include <string>
36 #include <vector>
37
38 #include <jack/jack.h>
39 #include <jack/midiport.h>
40
41 #include "main.hh"
42 #include "jacksampler.hh"
43 #include "microconf.hh"
44
45 using std::string;
46 using std::vector;
47
48 static float
49 freqFromNote (float note)
50 {
51   return 440 * exp (log (2) * (note - 69) / 12.0);
52 }
53
54 static bool
55 isNoteOn (const jack_midi_event_t& event)
56 {
57   if ((event.buffer[0] & 0xf0) == 0x90)
58     {
59       if (event.buffer[2] != 0) /* note on with velocity 0 => note off */
60         return true;
61     }
62   return false;
63 }
64
65 static bool
66 isNoteOff (const jack_midi_event_t& event)
67 {
68   if ((event.buffer[0] & 0xf0) == 0x90)
69     {
70       if (event.buffer[2] == 0) /* note on with velocity 0 => note off */
71         return true;
72     }
73   else if ((event.buffer[0] & 0xf0) == 0x80)
74     {
75       return true;
76     }
77   return false;
78 }
79
80 JackSampler::JackSampler() :
81   n_output_ports (1),
82   voices (256),
83   instrument (1),
84   pedal_down (false),
85   release_delay_ms (0),
86   release_ms (50),
87   mout (0),
88   instrument_count (0)
89 {
90 }
91
92 void
93 JackSampler::init (const Options& options, jack_client_t *client, int argc, char **argv)
94 {
95   for (int i = 1; i < argc; i++)
96     parse_config (options, i, argv[i]);
97   instrument_count = argc - 1;
98
99   jack_set_process_callback (client, jack_process, this);
100
101   jack_mix_freq = jack_get_sample_rate (client);
102
103   input_port = jack_port_register (client, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
104   output_port_1 = jack_port_register (client, "audio_out_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
105   if (n_output_ports == 2)
106     output_port_2 = jack_port_register (client, "audio_out_2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
107
108   if (jack_activate (client))
109     {
110       fprintf (stderr, "cannot activate client");
111       exit (1);
112     }
113 }
114
115 int
116 JackSampler::process (jack_nframes_t nframes)
117 {
118   jack_default_audio_sample_t *out_1;
119   jack_default_audio_sample_t *out_2;
120   out_1 = (jack_default_audio_sample_t *) jack_port_get_buffer (output_port_1, nframes);
121   if (n_output_ports == 2)
122      out_2 = (jack_default_audio_sample_t *) jack_port_get_buffer (output_port_2, nframes);
123   void* port_buf = jack_port_get_buffer (input_port, nframes);
124
125   jack_nframes_t event_count = jack_midi_get_event_count (port_buf);
126   jack_midi_event_t in_event;
127   jack_nframes_t event_index = 0;
128
129   jack_midi_event_get (&in_event, port_buf, 0);
130   for (int i = 0; i < nframes; i++)
131     {
132       while ((in_event.time == i) && (event_index < event_count))
133         {
134           // process event
135           if (isNoteOn (in_event))
136             {
137               /* note on */
138               //printf ("note on %d mout = %f\n", in_event.buffer[1], mout);
139               /* find unused voice */
140               int v = 0;
141               while ((v < voices.size()) && (voices[v].state != Voice::UNUSED))
142                 v++;
143               if (v != voices.size())
144                 {
145                   //printf ("voice = %d\n", v);
146                   voices[v].note  = in_event.buffer[1];
147                   voices[v].env   = 1.0;
148                   voices[v].pos   = 0.0;
149                   voices[v].frequency = freqFromNote (in_event.buffer[1]);
150                   voices[v].velocity = in_event.buffer[2] / 127.0;
151                   voices[v].sample = NULL;
152                   float best_delta = 1e20;
153                   for (size_t s = 0; s < samples.size(); s++)
154                     {
155                       // find nearest sample with a logarithmic distance measure: delta of 220 and 440 == delta of 440 and 880 == 2
156                       float delta = std::max (voices[v].frequency / samples[s].osc_freq, samples[s].osc_freq / voices[v].frequency);
157                       if (samples[s].instrument == instrument && delta < best_delta)
158                         {
159                           voices[v].sample = &samples[s];
160                           best_delta = delta;
161                         }
162                     }
163                   if (voices[v].sample) /* only switch to on if a sample was found */
164                     {
165                       voices[v].state = Voice::ON;
166                       //printf ("sample=%s\n", voices[v].sample->file_name.c_str());
167                       //printf ("stepping=%f\n", voices[v].frequency / voices[v].sample->osc_freq * voices[v].sample->mix_freq / jack_mix_freq);
168                     }
169                 }
170               else
171                 {
172                   printf ("NO MORE VOICES\n");
173                 }
174             }
175           else if (isNoteOff (in_event))
176             {
177               /* note off */
178               //printf ("note off %d\n", in_event.buffer[1]);
179
180               for (int v = 0; v < voices.size(); v++)
181                 {
182                   if (voices[v].state == Voice::ON && voices[v].note == in_event.buffer[1])
183                     {
184                       if (pedal_down)
185                         voices[v].pedal = true;
186                       else
187                         {
188                           //printf ("off voice %d\n", v);
189                           voices[v].state = Voice::RELEASE_DELAY;
190                           voices[v].rd_pos = 0;
191                         }
192                     }
193                 }
194             }
195           else if ((in_event.buffer[0] & 0xf0) == 0xb0)
196             {
197               //printf ("got midi controller event status=%x controller=%x value=%x\n",
198               //        in_event.buffer[0], in_event.buffer[1], in_event.buffer[2]);
199               if (in_event.buffer[1] == 0x40)
200                 {
201                   pedal_down = in_event.buffer[2] > 0x40;
202                   if (!pedal_down)
203                     {
204                       /* release voices which are sustained due to the pedal */
205                       for (int v = 0; v < voices.size(); v++)
206                         {
207                           if (voices[v].pedal)
208                             {
209                               voices[v].state = Voice::RELEASE_DELAY;
210                               voices[v].rd_pos = 0;
211                               voices[v].pedal = false;
212                             }
213                         }
214                     }
215                 }
216             }
217
218           // get next event
219           event_index++;
220           if (event_index < event_count)
221             jack_midi_event_get (&in_event, port_buf, event_index);
222         }
223
224       // generate one sample
225       out_1[i] = 0.0;
226       if (n_output_ports == 2)
227         out_2[i] = 0.0;
228       for (int v = 0; v < voices.size(); v++)
229         {
230           if (voices[v].state != Voice::UNUSED)
231             {
232               int ipos = voices[v].pos;
233               double dpos = voices[v].pos - ipos;
234
235               switch (voices[v].sample->channels)
236                 {
237                 case 1:
238                   if (ipos < (voices[v].sample->pcm_data.size() - 1))
239                     {
240                       double left = voices[v].sample->pcm_data[ipos];
241                       double right = voices[v].sample->pcm_data[ipos + 1];
242                       double out = (left * (1.0 - dpos) + right * dpos) * voices[v].env * voices[v].velocity;
243                       out_1[i] += out;
244                       if (n_output_ports == 2)
245                         out_2[i] += out;
246                     }
247                   break;
248                 case 2:  // assert (n_output_ports == 2);
249                   if (ipos * 2 < (voices[v].sample->pcm_data.size() - 3))
250                     {
251                       double left = voices[v].sample->pcm_data[ipos * 2];
252                       double right = voices[v].sample->pcm_data[ipos * 2 + 2];
253                       out_1[i] += (left * (1.0 - dpos) + right * dpos) * voices[v].env * voices[v].velocity;
254
255                       left = voices[v].sample->pcm_data[ipos * 2 + 1];
256                       right = voices[v].sample->pcm_data[ipos * 2 + 3];
257                       out_2[i] += (left * (1.0 - dpos) + right * dpos) * voices[v].env * voices[v].velocity;
258                     }
259                   break;
260                 }
261
262               voices[v].pos += voices[v].frequency / voices[v].sample->osc_freq *
263                                voices[v].sample->mix_freq / jack_mix_freq;
264             }
265           if (voices[v].state == Voice::RELEASE_DELAY)
266             {
267               voices[v].rd_pos += 1000.0 / jack_mix_freq;
268               if (voices[v].rd_pos > release_delay_ms)
269                 voices[v].state = Voice::FADE_OUT;
270             }
271           if (voices[v].state == Voice::FADE_OUT)
272             {
273               voices[v].env -= (1000.0 / jack_mix_freq) / release_ms;
274               if (voices[v].env <= 0)
275                 {
276                   voices[v].state = Voice::UNUSED;
277                   voices[v].pedal = false;
278                 }
279             }
280         }
281       out_1[i] *= 0.333;    /* empiric */
282       mout = std::max (fabs (out_1[i]), mout);
283       if (n_output_ports == 2)
284         {
285           out_2[i] *= 0.333;
286           mout = std::max (fabs (out_2[i]), mout);
287         }
288     }
289   return 0;
290 }
291
292 int
293 JackSampler::jack_process (jack_nframes_t nframes, void *arg)
294 {
295   JackSampler *instance = reinterpret_cast<JackSampler *> (arg);
296   return instance->process (nframes);
297 }
298
299 int
300 JackSampler::load_note (const Options& options, int note, const char *file_name, int instrument)
301 {
302   /* open input */
303   BseErrorType error;
304
305   BseWaveFileInfo *wave_file_info = bse_wave_file_info_load (file_name, &error);
306   if (!wave_file_info)
307     {
308       fprintf (stderr, "%s: can't open the input file %s: %s\n", options.program_name.c_str(), file_name, bse_error_blurb (error));
309       exit (1);
310     }
311
312   BseWaveDsc *waveDsc = bse_wave_dsc_load (wave_file_info, 0, FALSE, &error);
313   if (!waveDsc)
314     {
315       fprintf (stderr, "%s: can't open the input file %s: %s\n", options.program_name.c_str(), file_name, bse_error_blurb (error));
316       exit (1);
317     }
318
319   GslDataHandle *dhandle = bse_wave_handle_create (waveDsc, 0, &error);
320   if (!dhandle)
321     {
322       fprintf (stderr, "%s: can't open the input file %s: %s\n", options.program_name.c_str(), file_name, bse_error_blurb (error));
323       exit (1);
324     }
325
326   error = gsl_data_handle_open (dhandle);
327   if (error)
328     {
329       fprintf (stderr, "%s: can't open the input file %s: %s\n", options.program_name.c_str(), file_name, bse_error_blurb (error));
330       exit (1);
331     }
332
333   Sample s;
334   s.channels = waveDsc->n_channels;
335
336   vector<float> block (1024);
337   uint64 pos = 0;
338   uint64 len = gsl_data_handle_length (dhandle);
339   while (pos < len)
340     {
341       uint64 r = gsl_data_handle_read (dhandle, pos, block.size(), &block[0]);
342
343       for (int i = 0; i < r; i++)
344         s.pcm_data.push_back (block[i]);
345       pos += r;
346     }
347   printf ("loaded sample, length = %ld, channels = %d\n", s.pcm_data.size(), s.channels);
348   s.mix_freq = gsl_data_handle_mix_freq (dhandle);
349   s.osc_freq = freqFromNote (note);
350   s.instrument = instrument;
351   s.file_name = file_name;
352   samples.push_back (s);
353
354   return s.channels;
355 }
356
357 void
358 JackSampler::parse_config (const Options& options, int instrument, const char *name)
359 {
360   MicroConf cfg (name);
361
362   while (cfg.next())
363     {
364       int    note = 0;
365       double d = 0;
366       string file;
367
368       if (cfg.command ("sample", note, file))
369         {
370           if (load_note (options, note, file.c_str(), instrument) == 2)
371             n_output_ports = 2;
372           printf ("NOTE %d FILE %s\n", note, file.c_str());
373         }
374       else if (cfg.command ("release_delay", d))
375         {
376           release_delay_ms = d;
377           printf ("RELEASE_DELAY %f ms\n", release_delay_ms);
378         }
379       else if (cfg.command ("release", d))
380         {
381           release_ms = d;
382           printf ("RELEASE %f ms\n", release_ms);
383         }
384       else
385         {
386           cfg.die_if_unknown();
387         }
388     }
389 }
390
391 void
392 JackSampler::change_instrument (int new_instrument)
393 {
394   instrument = new_instrument;
395   printf ("JackSampler: changed instrument to %d\n", instrument);
396 }
397
398 void
399 JackSampler::status()
400 {
401   int unused = 0;
402   int on = 0;
403   int release_delay = 0;
404   int fade_out = 0;
405
406   for (size_t i = 0; i < voices.size(); i++)
407     {
408       if (voices[i].state == Voice::UNUSED)
409         unused++;
410       else if (voices[i].state == Voice::ON)
411         on++;
412       else if (voices[i].state == Voice::RELEASE_DELAY)
413         release_delay++;
414       else if (voices[i].state == Voice::FADE_OUT)
415         fade_out++;
416       else
417         g_assert_not_reached();
418     }
419   printf ("sampling rate:   %.2f\n", jack_mix_freq);
420   printf ("output ports:    %d\n", n_output_ports);
421   printf ("instruments:     %d\n", instrument_count);
422   printf ("active instr.:   %d\n", instrument);
423   printf ("total voices:    %d\n", voices.size());
424   printf ("\n");
425   printf (" * unused        %d\n", unused);
426   printf (" * on            %d\n", on);
427   printf (" * release delay %d\n", release_delay);
428   printf (" * fade out      %d\n", fade_out);
429 }
430
431 void
432 JackSampler::reset()
433 {
434   // reset all voices the hard way (might click)
435   for (size_t v = 0; v < voices.size(); v++)
436     voices[v].state = Voice::UNUSED;
437 }