examples/utils.c

   1 /*
   2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
   3
   4   This file is part of aubio.
   5
   6   aubio is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   aubio is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with aubio.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21 /**
  22
  23   This file includes some tools common to all examples. Code specific to the
  24   algorithm performed by each program should go in the source file of that
  25   program instead.
  26
  27 */
  28
  29 #include "utils.h"
  30 #ifdef HAVE_JACK
  31 #include "jackio.h"
  32 #endif /* HAVE_JACK */
  33
  34 int verbose = 0;
  35 int usejack = 0;
  36 // input / output
  37 char_t *sink_uri = NULL;
  38 char_t *source_uri = NULL;
  39 // general stuff
  40 uint_t samplerate = 0;
  41 uint_t buffer_size = 512;
  42 uint_t hop_size = 256;
  43 // onset stuff
  44 char_t * onset_method = "default";
  45 smpl_t onset_threshold = 0.0; // will be set if != 0.
  46 smpl_t onset_minioi = 0.0; // will be set if != 0.
  47 // pitch stuff
  48 char_t * pitch_unit = "default";
  49 char_t * pitch_method = "default";
  50 smpl_t pitch_tolerance = 0.0; // will be set if != 0.
  51 // time stuff
  52 uint_t time_format = 0; // for "seconds", 1 for "ms", 2 for "samples"
  53 // tempo stuff
  54 char_t * tempo_method = "default";
  55 // more general stuff
  56 smpl_t silence_threshold = -90.;
  57 uint_t mix_input = 0;
  58
  59 uint_t force_overwrite = 0;
  60
  61 //
  62 // internal memory stuff
  63 aubio_source_t *this_source = NULL;
  64 aubio_sink_t *this_sink = NULL;
  65 fvec_t *ibuf;
  66 fvec_t *obuf;
  67
  68 smpl_t miditap_note = 69.;
  69 smpl_t miditap_velo = 65.;
  70
  71 /* settings */
  72 int blocks = 0;
  73
  74 extern void usage (FILE * stream, int exit_code);
  75 extern int parse_args (int argc, char **argv);
  76
  77 #if HAVE_JACK
  78 #define MAX_MIDI_EVENTS 128
  79 #define MAX_MIDI_EVENT_SIZE 3
  80 aubio_jack_t *jack_setup;
  81 jack_midi_event_t ev;
  82 jack_midi_data_t midi_data[MAX_MIDI_EVENTS * MAX_MIDI_EVENT_SIZE];
  83 size_t midi_event_count = 0;
  84 #endif /* HAVE_JACK */
  85
  86 void examples_common_init (int argc, char **argv);
  87 void examples_common_del (void);
  88 void examples_common_process (aubio_process_func_t process_func,
  89     aubio_print_func_t print);
  90
  91 void examples_common_init (int argc, char **argv)
  92 {
  93
  94   /* parse command line arguments */
  95   parse_args (argc, argv);
  96
  97   if (!usejack) {
  98     debug ("Opening files ...\n");
  99     this_source = new_aubio_source ((char_t*)source_uri, samplerate, hop_size);
 100     if (this_source == NULL) {
 101       errmsg ("Error: could not open input file %s\n", source_uri);
 102       exit (1);
 103     }
 104     if (samplerate == 0) {
 105       samplerate = aubio_source_get_samplerate(this_source);
 106     }
 107     if (sink_uri != NULL) {
 108       uint_t sink_exists = (access(sink_uri, F_OK) == 0 );
 109       if (!force_overwrite && sink_exists) {
 110         errmsg ("Error: output file %s already exists, use -f to overwrite.\n",
 111             sink_uri);
 112         exit (1);
 113       }
 114       this_sink = new_aubio_sink ((char_t*)sink_uri, samplerate);
 115       if (this_sink == NULL) {
 116         errmsg ("Error: could not create output file %s\n", sink_uri);
 117         exit (1);
 118       }
 119     }
 120 #ifdef HAVE_JACK
 121   } else {
 122     debug ("Jack init ...\n");
 123     jack_setup = new_aubio_jack (hop_size, 1, 1, 0, 1);
 124     samplerate = aubio_jack_get_samplerate (jack_setup);
 125     source_uri = "jack";
 126 #endif /* HAVE_JACK */
 127   }
 128   ibuf = new_fvec (hop_size);
 129   obuf = new_fvec (hop_size);
 130
 131 }
 132
 133 void examples_common_del (void)
 134 {
 135   del_fvec (ibuf);
 136   del_fvec (obuf);
 137   aubio_cleanup ();
 138   fflush(stderr);
 139   fflush(stdout);
 140 }
 141
 142 void examples_common_process (aubio_process_func_t process_func,
 143     aubio_print_func_t print)
 144 {
 145
 146   uint_t read = 0;
 147   if (usejack) {
 148
 149 #ifdef HAVE_JACK
 150     ev.size = MAX_MIDI_EVENT_SIZE;
 151     ev.time = 0; // send it now
 152     debug ("Jack activation ...\n");
 153     aubio_jack_activate (jack_setup, process_func);
 154     debug ("Processing (Ctrl+C to quit) ...\n");
 155     pause ();
 156     aubio_jack_close (jack_setup);
 157 #else /* HAVE_JACK */
 158     usage (stderr, 1);
 159     outmsg ("Compiled without jack output, exiting.\n");
 160 #endif /* HAVE_JACK */
 161
 162   } else {
 163
 164     uint_t total_read = 0;
 165     blocks = 0;
 166
 167     do {
 168       aubio_source_do (this_source, ibuf, &read);
 169       process_func (ibuf, obuf);
 170       // print to console if verbose or no output given
 171       if (verbose || sink_uri == NULL) {
 172         print();
 173       }
 174       if (this_sink) {
 175         aubio_sink_do (this_sink, obuf, hop_size);
 176       }
 177       blocks++;
 178       total_read += read;
 179     } while (read == hop_size);
 180
 181     verbmsg ("read %.2fs (%d samples in %d blocks of %d) from %s at %dHz\n",
 182         total_read * 1. / samplerate,
 183         total_read, blocks, hop_size, source_uri, samplerate);
 184
 185     del_aubio_source (this_source);
 186     del_aubio_sink   (this_sink);
 187
 188   }
 189 }
 190
 191 void
 192 send_noteon (smpl_t pitch, smpl_t velo)
 193 {
 194 #ifdef HAVE_JACK
 195   if (usejack) {
 196     ev.buffer = midi_data + midi_event_count++ * MAX_MIDI_EVENT_SIZE;
 197     if (midi_event_count >= MAX_MIDI_EVENTS) {
 198       midi_event_count = 0;
 199     }
 200     ev.buffer[2] = velo;
 201     ev.buffer[1] = pitch;
 202     if (velo == 0) {
 203       ev.buffer[0] = 0x80;      /* note off */
 204     } else {
 205       ev.buffer[0] = 0x90;      /* note on */
 206     }
 207     aubio_jack_midi_event_write (jack_setup, (jack_midi_event_t *) & ev);
 208   } else
 209 #endif
 210   if (velo == 0) {
 211     print_time (blocks * hop_size);
 212     outmsg ("\n");
 213   } else {
 214     outmsg ("%f\t", pitch);
 215     print_time (blocks * hop_size);
 216     outmsg ("\t");
 217   }
 218 }
 219
 220 void print_time (uint_t time_in_samples) {
 221   /* output times in selected format */
 222   if (time_format == 2) {
 223     outmsg ("%d", time_in_samples);
 224   } else if (time_format == 1) {
 225     outmsg ("%f", 1000. * time_in_samples / (float) samplerate);
 226   } else {
 227     outmsg ("%f", time_in_samples / (float) samplerate);
 228   }
 229 }