예제 #1
0
파일: test-onset.c 프로젝트: famulus/aubio
int main (int argc, char **argv)
{
  uint_t err = 0;
  if (argc < 2) {
    err = 2;
    PRINT_ERR("not enough arguments\n");
    PRINT_MSG("read a wave file as a mono vector\n");
    PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
    return err;
  }
  uint_t samplerate = 0;
  uint_t win_s = 1024; // window size
  uint_t hop_size = win_s / 4;
  uint_t n_frames = 0, read = 0;
  if ( argc == 3 ) samplerate = atoi(argv[2]);
  if ( argc == 4 ) hop_size = atoi(argv[3]);

  char_t *source_path = argv[1];
  aubio_source_t * source = new_aubio_source(source_path, samplerate, hop_size);
  if (!source) { err = 1; goto beach; }

  if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(source);

  // create some vectors
  fvec_t * in = new_fvec (hop_size); // input audio buffer
  fvec_t * out = new_fvec (2); // output position

  // create onset object
  aubio_onset_t * o = new_aubio_onset("default", win_s, hop_size, samplerate);

  do {
    // put some fresh data in input vector
    aubio_source_do(source, in, &read);
    // execute onset
    aubio_onset_do(o,in,out);
    // do something with the onsets
    if (out->data[0] != 0) {
      PRINT_MSG("onset at %.3fms, %.3fs, frame %d\n",
          aubio_onset_get_last_ms(o), aubio_onset_get_last_s(o),
          aubio_onset_get_last(o));
    }
    n_frames += read;
  } while ( read == hop_size );

  PRINT_MSG("read %.2fs, %d frames at %dHz (%d blocks) from %s\n",
      n_frames * 1. / samplerate,
      n_frames, samplerate,
      n_frames / hop_size, source_path);

  // clean up memory
  del_aubio_onset(o);
  del_fvec(in);
  del_fvec(out);
beach:
  aubio_cleanup();

  return err;
}
예제 #2
0
파일: notes.c 프로젝트: anthonylauzon/aubio
void del_aubio_notes (aubio_notes_t *o) {
  if (o->note_buffer) del_fvec(o->note_buffer);
  if (o->note_buffer2) del_fvec(o->note_buffer2);
  if (o->pitch_output) del_fvec(o->pitch_output);
  if (o->pitch) del_aubio_pitch(o->pitch);
  if (o->onset_output) del_fvec(o->onset_output);
  if (o->onset) del_aubio_onset(o->onset);
  AUBIO_FREE(o);
}
예제 #3
0
int main(int argc, char **argv) {
  frames_delay = 3;
  examples_common_init(argc,argv);

  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, samplerate);
  if (threshold != 0.) aubio_onset_set_threshold (o, threshold);
  onset = new_fvec (1);

  examples_common_process(aubio_process,process_print);

  del_aubio_onset (o);
  del_fvec (onset);

  examples_common_del();
  debug("End of program.\n");
  fflush(stderr);
  return 0;
}
예제 #4
0
int main(){
        /* allocate some memory */
        uint_t win_s      = 1024;                       /* window size */
        fvec_t * in       = new_fvec (win_s/4); /* input buffer */
        fvec_t * out      = new_fvec (2);     /* input buffer */
        aubio_onset_t * onset  = new_aubio_onset("complex", win_s, win_s/4, 44100.);
        uint_t i = 0;

        while (i < 10) {
          aubio_onset_do (onset,in,out);
          i++;
        };

        del_aubio_onset(onset);
        del_fvec(in);
        del_fvec(out);
        aubio_cleanup();

        return 0;
}
예제 #5
0
//Creates a list of times which the aubio onset detector thinks are note onset times for the audio Denemo->si->recording
//Result is placed in Denemo->si->note_onsets
void
generate_note_onsets (void)
{
    DenemoRecording *audio = Denemo.project->movement->recording;
    gint channels = audio->channels;

    smpl_t threshold = 0.3;
    smpl_t silence = -90.;
    uint_t buffer_size = 1024;
    uint_t overlap_size = 512;

    uint_t samplerate = 44100;

    aubio_onset_t *o = new_aubio_onset("default",
                                       buffer_size, overlap_size, samplerate);
    fvec_t *ibuf = new_fvec (overlap_size);
    fvec_t *onset = new_fvec (2);

    unsigned int pos = 0;         /*frames%dspblocksize */
    unsigned int i;               /*channels */
    unsigned int j;               /*frames */

    busy_cursor (Denemo.notebook);
    gtk_window_set_modal (progressbar (_("Analysing Audio"), NULL), TRUE);

    rewind_audio ();
    if (audio->notes)
    {
        g_list_free_full (audio->notes, g_free);
        audio->notes = NULL;
    }
    for (j = 0; j < (unsigned) audio->nframes; j++)
    {
        sf_read_float (audio->sndfile, ibuf->data + pos, 2);   //g_debug("\t%f", ibuf->data[0][pos]);
        if (pos == overlap_size - 1)
        {
            /* block loop */
            gtk_main_iteration_do (FALSE);
            aubio_onset_do (o, ibuf, onset);
            while (gtk_events_pending ())
                gtk_main_iteration ();
            if(onset->data[0] != 0) {
                DenemoRecordedNote *note = g_malloc0(sizeof(DenemoRecordedNote));
                note->timing = aubio_onset_get_last(o);/* aubio_onset_get_delay_s(o) for seconds */
                audio->notes = g_list_append (audio->notes, note);
            }
            pos = -1;             /* so it will be zero next j loop */
        }                       /* end of if pos==overlap_size-1 */
        pos++;
    }

    del_aubio_onset (o);
    del_fvec (ibuf);
    del_fvec (onset);
    aubio_cleanup ();











    progressbar_stop ();
    normal_cursor (Denemo.notebook);
}
예제 #6
0
void Note2midi::run(LV2_Handle instance, uint32_t SampleCount)
{
    Note2midi *plugin = (Note2midi *) instance;

    unsigned int new_onset_method = (unsigned int)(*plugin->_onset_method);
    unsigned int new_pitch_method = (unsigned int)(*plugin->_pitch_method);
    char_t* on_meth;
    char_t* pi_meth;

    silence_threshold = *(plugin->_silence_threshold);

    aubio_onset_set_threshold(plugin->o, *plugin->_onset_threshold);
    aubio_pitch_set_tolerance(plugin->pitch, *plugin->_pitch_method);

    if(0 <= new_onset_method && 16 >= new_onset_method &&
        new_onset_method != plugin->current_onset_method){ 
        
        del_aubio_onset(plugin->o);

        switch(new_onset_method){
            case ONSET_METHOD_ENERGY:
            on_meth = "energy";
            break;
            case ONSET_METHOD_SPECDIFF:
            on_meth = "specdiff";
            break;
            case ONSET_METHOD_HFC:
            on_meth = "hfc";
            break;
            case ONSET_METHOD_COMPLEXDOMAIN:
            on_meth = "complexdomain";
            break;
            case ONSET_METHOD_COMPLEX:
            on_meth = "complex";
            break;
            case ONSET_METHOD_PHASE:
            on_meth = "phase";
            break;
            case ONSET_METHOD_MKL:
            on_meth = "mkl";
            break;
            case ONSET_METHOD_KL:
            on_meth = "kl";
            break;
            case ONSET_METHOD_SPECFLUX:
            on_meth = "specflux";
            break;
            case ONSET_METHOD_CENTROID:
            on_meth = "centroid";
            break;
            case ONSET_METHOD_SPREAD:
            on_meth = "spread";
            break;
            case ONSET_METHOD_SKEWNESS:
            on_meth = "skewness";
            break;
            case ONSET_METHOD_KURTOSIS:
            on_meth = "kurtosis";
            break;
            case ONSET_METHOD_SLOPE:
            on_meth = "slope";
            break;
            case ONSET_METHOD_DECREASE:
            on_meth = "decrease";
            break;
            case ONSET_METHOD_ROLLOFF:
            on_meth = "rolloff";
            break;
            default:
            on_meth = "default";
            break;
        }


        plugin->o = new_aubio_onset (on_meth, PARAM_BUFFER_SIZE, PARAM_HOP_SIZE_ONSET, plugin->samplerate);
        
        plugin->current_onset_method = new_onset_method;
    }

    if(0 <= new_pitch_method && 6 >= new_pitch_method &&
        new_pitch_method != plugin->current_pitch_method){
        del_aubio_pitch(plugin->pitch);

        switch(new_pitch_method){
            case PITCH_METHOD_MCOMB:
            pi_meth = "mcomb";
            break;
            case PITCH_METHOD_YINFFT:
            pi_meth = "yinfft";
            break;
            case PITCH_METHOD_YIN:
            pi_meth = "yin";
            break;
            case PITCH_METHOD_SCHMITT:
            pi_meth = "schmitt";
            break;
            case PITCH_METHOD_FCOMB:
            pi_meth = "fcomb";
            break;
            case PITCH_METHOD_SPECACF:
            pi_meth = "specacf";
            break;
            default:
            pi_meth = "default";
            break;
        }


        plugin->pitch = new_aubio_pitch (pi_meth, PARAM_BUFFER_SIZE * PARAM_PITCH_BUFF_TIMES, PARAM_HOP_SIZE_PITCH, plugin->samplerate);
     
        // aubio_pitch_set_unit (plugin->pitch, plugin->pitch_unit);

        plugin->current_pitch_method = new_pitch_method;
    }

    out_capacity = plugin->out->atom.size;

    plugin->out->atom.type = plugin->atom_sequence;
    lv2_atom_sequence_clear(plugin->out);

    plugin->ibuf->data = (smpl_t *) plugin->in;

    counter++;

    if(counter++ >= PARAM_BUFFER_SIZE)
        counter = 0;

    plugin->process_block();
}