int main (void) { fprintf(stdout, "### testing normal logging\n"); AUBIO_ERR("testing normal AUBIO_LOG_ERR\n"); AUBIO_WRN("testing normal AUBIO_LOG_WRN\n"); AUBIO_MSG("testing normal AUBIO_LOG_MSG\n"); AUBIO_DBG("testing normal AUBIO_LOG_DBG\n"); fprintf(stdout, "### testing with one custom function\n"); aubio_log_set_function(logging, (void *)hdr); AUBIO_ERR("testing recustom AUBIO_LOG_ERR\n"); AUBIO_WRN("testing recustom AUBIO_LOG_WRN\n"); AUBIO_MSG("testing recustom AUBIO_LOG_MSG\n"); AUBIO_DBG("testing recustom AUBIO_LOG_DBG\n"); fprintf(stdout, "### testing resetted logging\n"); aubio_log_reset(); AUBIO_ERR("testing uncustom AUBIO_LOG_ERR\n"); AUBIO_WRN("testing uncustom AUBIO_LOG_WRN\n"); AUBIO_MSG("testing uncustom AUBIO_LOG_MSG\n"); AUBIO_DBG("testing uncustom AUBIO_LOG_DBG\n"); fprintf(stdout, "### testing per level customization\n"); aubio_log_set_level_function(AUBIO_LOG_ERR, logging, (void *)hdr2); aubio_log_set_level_function(AUBIO_LOG_WRN, logging, NULL); aubio_log_set_level_function(AUBIO_LOG_MSG, logging, (void *)hdr); AUBIO_ERR("testing custom AUBIO_LOG_ERR\n"); AUBIO_WRN("testing custom AUBIO_LOG_WRN with data=NULL\n"); AUBIO_MSG("testing custom AUBIO_LOG_MSG\n"); AUBIO_DBG("testing uncustomized AUBIO_LOG_DBG\n"); return 0; }
OSStatus audio_unit_set_audio_session_category(bool has_input, bool verbose) { //if we have input, set the session category accordingly OSStatus err = 0; UInt32 category; if (has_input) { category = kAudioSessionCategory_PlayAndRecord; if (verbose) AUBIO_MSG("audio_unit: setting category to PlayAndRecord\n"); } else { category = kAudioSessionCategory_MediaPlayback; if (verbose) AUBIO_MSG("audio_unit: setting category to MediaPlayback\n"); } err = AudioSessionSetProperty(kAudioSessionProperty_AudioCategory, sizeof(category), &category); if (err) { AUBIO_ERR("audio_unit: could not set audio category\n"); } // Audiob.us style UInt32 allowMixing = 1; AudioSessionSetProperty(kAudioSessionProperty_OverrideCategoryMixWithOthers, sizeof (allowMixing), &allowMixing); if (err) { AUBIO_ERR("audio_unit: could not set audio session to mix with others\n"); } return err; }
void fvec_print(const fvec_t *s) { uint_t j; for (j=0; j< s->length; j++) { AUBIO_MSG(AUBIO_SMPL_FMT " ", s->data[j]); } AUBIO_MSG("\n"); }
void lvec_print(lvec_t *s) { uint_t j; for (j=0; j< s->length; j++) { AUBIO_MSG(AUBIO_LSMP_FMT " ", s->data[j]); } AUBIO_MSG("\n"); }
void audio_unit_check_audio_route(aubio_audio_unit_t *o) { CFStringRef currentRoute; UInt32 val, thissize = sizeof(currentRoute); OSStatus err = AudioSessionGetProperty(kAudioSessionProperty_AudioRoute, &thissize, ¤tRoute); if (err) { AUBIO_ERR("audio_unit: could not get current route\n"); goto fail; } else { char *route = (char *)CFStringGetCStringPtr ( currentRoute, kCFStringEncodingUTF8); if (route == NULL) { int bufferSize = 25; route = calloc(bufferSize, sizeof(char)); CFStringGetCString ( currentRoute, route, bufferSize, kCFStringEncodingUTF8); } if (o->verbose) { AUBIO_MSG ("audio_unit: current route is %s\n", route); } //free(route); } if( currentRoute ) { if( CFStringCompare( currentRoute, CFSTR("Headset"), 0 ) == kCFCompareEqualTo ) { val = kAudioSessionOverrideAudioRoute_None; } else if( CFStringCompare( currentRoute, CFSTR("Receiver" ), 0 ) == kCFCompareEqualTo ) { val = kAudioSessionOverrideAudioRoute_Speaker; } else if( CFStringCompare( currentRoute, CFSTR("ReceiverAndMicrophone" ), 0 ) == kCFCompareEqualTo ) { val = kAudioSessionOverrideAudioRoute_Speaker; } else if( CFStringCompare( currentRoute, CFSTR("SpeakerAndMicrophone" ), 0 ) == kCFCompareEqualTo ) { val = kAudioSessionOverrideAudioRoute_Speaker; } else if( CFStringCompare( currentRoute, CFSTR("HeadphonesAndMicrophone" ), 0 ) == kCFCompareEqualTo ) { val = kAudioSessionOverrideAudioRoute_None; } else if( CFStringCompare( currentRoute, CFSTR("HeadsetInOut" ), 0 ) == kCFCompareEqualTo ) { val = kAudioSessionOverrideAudioRoute_None; } else { val = kAudioSessionOverrideAudioRoute_None; } o->input_enabled = true; if (val == kAudioSessionOverrideAudioRoute_Speaker) { if (o->prevent_feedback) { o->input_enabled = false; if (o->verbose) { AUBIO_MSG ("audio_unit: disabling input to avoid feedback\n"); } } else { AUBIO_WRN ("audio_unit: input not disabled as prevent_feedback set to 0, risking feedback\n"); } } err = AudioSessionSetProperty(kAudioSessionProperty_OverrideAudioRoute, sizeof(UInt32), &val); if (err) { AUBIO_ERR("audio_unit: could not set session OverrideAudioRoute to Speaker\n"); } } fail: if ( currentRoute ) free((void*)currentRoute); return; }
void fmat_print(fmat_t *s) { uint_t i,j; for (i=0; i< s->height; i++) { for (j=0; j< s->length; j++) { AUBIO_MSG(AUBIO_SMPL_FMT " ", s->data[i][j]); } AUBIO_MSG("\n"); } }
aubio_jack_t * new_aubio_jack(uint_t ichan, uint_t ochan, aubio_process_func_t callback) { aubio_jack_t * jack_setup = aubio_jack_alloc (ichan, ochan); uint_t i; char * client_name = "aubio"; char name[64]; /* initial jack client setup */ if ((jack_setup->client = jack_client_new (client_name)) == 0) { AUBIO_ERR ("jack server not running?\n"); AUBIO_QUIT(AUBIO_FAIL); } /* set callbacks */ jack_set_process_callback (jack_setup->client, aubio_jack_process, (void*) jack_setup); jack_on_shutdown (jack_setup->client, aubio_jack_shutdown, (void*) jack_setup); /* register jack output ports */ for (i = 0; i < ochan; i++) { AUBIO_SPRINTF(name, "out_%d", i+1); AUBIO_MSG("%s\n", name); if ((jack_setup->oports[i] = jack_port_register (jack_setup->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)) == 0) { AUBIO_ERR("failed registering output port \"%s\"!\n", name); jack_client_close (jack_setup->client); AUBIO_QUIT(AUBIO_FAIL); } } /* register jack input ports */ for (i = 0; i < ichan; i++) { AUBIO_SPRINTF(name, "in_%d", i+1); AUBIO_MSG("%s\n", name); if ((jack_setup->iports[i] = jack_port_register (jack_setup->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0)) == 0) { AUBIO_ERR("failed registering input port \"%s\"!\n", name); jack_client_close (jack_setup->client); AUBIO_QUIT(AUBIO_FAIL); } } /* set processing callback */ jack_setup->callback = callback; return jack_setup; }
aubio_source_t * new_aubio_source(char_t * uri, uint_t samplerate, uint_t hop_size) { aubio_source_t * s = AUBIO_NEW(aubio_source_t); AUBIO_MSG("new aubio source"); #if HAVE_LIBAV AUBIO_MSG("libav"); s->source = (void *)new_aubio_source_avcodec(uri, samplerate, hop_size); if (s->source) { s->s_do = (aubio_source_do_t)(aubio_source_avcodec_do); s->s_do_multi = (aubio_source_do_multi_t)(aubio_source_avcodec_do_multi); s->s_get_channels = (aubio_source_get_channels_t)(aubio_source_avcodec_get_channels); s->s_get_samplerate = (aubio_source_get_samplerate_t)(aubio_source_avcodec_get_samplerate); s->s_seek = (aubio_source_seek_t)(aubio_source_avcodec_seek); s->s_del = (del_aubio_source_t)(del_aubio_source_avcodec); return s; } #endif /* HAVE_LIBAV */ #ifdef __APPLE__ AUBIO_MSG("apple"); s->source = (void *)new_aubio_source_apple_audio(uri, samplerate, hop_size); if (s->source) { s->s_do = (aubio_source_do_t)(aubio_source_apple_audio_do); s->s_do_multi = (aubio_source_do_multi_t)(aubio_source_apple_audio_do_multi); s->s_get_channels = (aubio_source_get_channels_t)(aubio_source_apple_audio_get_channels); s->s_get_samplerate = (aubio_source_get_samplerate_t)(aubio_source_apple_audio_get_samplerate); s->s_seek = (aubio_source_seek_t)(aubio_source_apple_audio_seek); s->s_del = (del_aubio_source_t)(del_aubio_source_apple_audio); return s; } #endif /* __APPLE__ */ #if HAVE_SNDFILE AUBIO_MSG("sndfile"); s->source = (void *)new_aubio_source_sndfile(uri, samplerate, hop_size); if (s->source) { s->s_do = (aubio_source_do_t)(aubio_source_sndfile_do); s->s_do_multi = (aubio_source_do_multi_t)(aubio_source_sndfile_do_multi); s->s_get_channels = (aubio_source_get_channels_t)(aubio_source_sndfile_get_channels); s->s_get_samplerate = (aubio_source_get_samplerate_t)(aubio_source_sndfile_get_samplerate); s->s_seek = (aubio_source_seek_t)(aubio_source_sndfile_seek); s->s_del = (del_aubio_source_t)(del_aubio_source_sndfile); return s; } #endif /* HAVE_SNDFILE */ AUBIO_ERROR("failed creating aubio source with %s\n", uri); AUBIO_FREE(s); return NULL; }
SInt32 audio_unit_get_route_change_reason(CFDictionaryRef routeChangeDic) { CFNumberRef routeChangeReasonRef = (CFNumberRef)CFDictionaryGetValue(routeChangeDic, CFSTR(kAudioSession_AudioRouteChangeKey_Reason)); SInt32 change_reason_number; CFNumberGetValue ( routeChangeReasonRef, kCFNumberSInt32Type, &change_reason_number); switch (change_reason_number) { case kAudioSessionRouteChangeReason_NewDeviceAvailable: AUBIO_MSG("audio_unit: route changed to NewDeviceAvailable\n"); break; case kAudioSessionRouteChangeReason_OldDeviceUnavailable: AUBIO_MSG("audio_unit: route changed to OldDeviceUnavailable\n"); break; case kAudioSessionRouteChangeReason_CategoryChange: AUBIO_MSG("audio_unit: route changed to CategoryChange\n"); audio_unit_get_audio_session_category(); break; case kAudioSessionRouteChangeReason_Override: AUBIO_MSG("audio_unit: route changed to Override\n"); break; case kAudioSessionRouteChangeReason_WakeFromSleep: AUBIO_MSG("audio_unit: route changed to WakeFromSleep\n"); break; case kAudioSessionRouteChangeReason_NoSuitableRouteForCategory: AUBIO_MSG("audio_unit: route changed to NoSuitableRouteForCategory\n"); break; case kAudioSessionRouteChangeReason_Unknown: default: AUBIO_ERR("audio_unit: route changed for an unknown reason!?\n"); break; } return change_reason_number; }
void cvec_print(const cvec_t *s) { uint_t j; AUBIO_MSG("norm: "); for (j=0; j< s->length; j++) { AUBIO_MSG(AUBIO_SMPL_FMT " ", s->norm[j]); } AUBIO_MSG("\n"); AUBIO_MSG("phas: "); for (j=0; j< s->length; j++) { AUBIO_MSG(AUBIO_SMPL_FMT " ", s->phas[j]); } AUBIO_MSG("\n"); }
UInt32 audio_unit_get_audio_session_category () { UInt32 category, thissize; thissize = sizeof(category); OSStatus err = AudioSessionGetProperty(kAudioSessionProperty_AudioCategory, &thissize, &category); if (err) { AUBIO_ERR("audio_unit: could not get audio category (%d)\n", (int)err); return err; } if (category == kAudioSessionCategory_AmbientSound) { AUBIO_MSG("audio_unit: session category is AmbiantSound\n"); } else if (category == kAudioSessionCategory_SoloAmbientSound) { AUBIO_MSG("audio_unit: session category is SoloAmbiantSound\n"); } else if (category == kAudioSessionCategory_MediaPlayback) { AUBIO_MSG("audio_unit: session category is MediaPlayback\n"); } else if (category == kAudioSessionCategory_RecordAudio) { AUBIO_MSG("audio_unit: session category is RecordAudio\n"); } else if (category == kAudioSessionCategory_PlayAndRecord) { AUBIO_MSG("audio_unit: session category is PlayAndRecord\n"); } else if (category == kAudioSessionCategory_AudioProcessing) { AUBIO_MSG("audio_unit: session category is AudioProcessing\n"); } return category; }
sint_t aubio_audio_unit_get_info (aubio_audio_unit_t *o) { UInt32 thissize, input_hw_channels, output_hw_channels, max_fps; Float32 latency, input_latency, output_latency, input_hw_volume, output_hw_volume; Float64 samplerate; OSStatus err = 0; // Show some info about the opened unit /* get sampling rate */ thissize = sizeof(samplerate); err = AudioUnitGetProperty (o->audio_unit, kAudioUnitProperty_SampleRate, kAudioUnitScope_Output, 1, &samplerate, &thissize); if (err) { AUBIO_ERR("audio_unit: could not get audio unit sample rate (%d)\n", (int)err); goto fail; } /* get hardware input channels */ thissize = sizeof(input_hw_channels); err = AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareInputNumberChannels, &thissize, &input_hw_channels); if (err) { AUBIO_ERR("audio_unit: could not get hardware input channels (%d)\n", (int)err); goto fail; } /* get hardware output channels */ thissize = sizeof(output_hw_channels); err = AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareOutputNumberChannels, &thissize, &output_hw_channels); if (err) { AUBIO_ERR("audio_unit: could not get hardware output channels (%d)\n", (int)err); goto fail; } /* get hardware input volume */ thissize = sizeof(input_hw_volume); err = AudioSessionGetProperty(kAudioSessionProperty_InputGainScalar, &thissize, &input_hw_volume); if (err) { AUBIO_ERR("audio_unit: could not get hardware input volume (%d)\n", (int)err); goto fail; } /* get hardware output volume */ thissize = sizeof(output_hw_volume); err = AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareOutputVolume, &thissize, &output_hw_volume); if (err) { AUBIO_ERR("audio_unit: could not get hardware output volume (%d)\n", (int)err); goto fail; } AUBIO_MSG("audio_unit: opened at %.0fHz, sw channels %din/%dout, hw channels %din/%dout, hw vol %.2fin/%.2fout\n", samplerate, o->sw_input_channels, o->sw_output_channels, (unsigned int)input_hw_channels, (unsigned int)output_hw_channels, input_hw_volume, output_hw_volume); /* get max frames per slice */ thissize = sizeof(max_fps); err = AudioUnitGetProperty (o->audio_unit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, &max_fps, &thissize); if (err) { AUBIO_ERR("audio_unit: could not get maximum frames per slice property %d\n", (int)err); goto fail; } /* get hardware latency */ thissize = sizeof(latency); err = AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareIOBufferDuration, &thissize, &latency); if (err) { AUBIO_ERR("audio_unit: could not get hardware latency %d\n", (int)err); goto fail; } /* get input latency */ thissize = sizeof(input_latency); err = AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareInputLatency, &thissize, &input_latency); if (err) { AUBIO_ERR("audio_unit: could not get input latency %d\n", (int)err); goto fail; } /* get output harlatency */ thissize = sizeof(output_latency); err = AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareOutputLatency, &thissize, &output_latency); if (err) { AUBIO_ERR("audio_unit: could not get output latency %d\n", (int)err); goto fail; } AUBIO_MSG("audio_unit: I/O latency: %.2fms, %d frames, (%.2fms, %d frames in, %.2fms %d frames out)\n", latency*1000., (sint_t)round(latency*samplerate), input_latency*1000., (sint_t)ROUND(input_latency*samplerate), output_latency*1000., (sint_t)ROUND(output_latency*samplerate)); fail: return err; }
/** new_aubio_alsa_seq_driver */ aubio_midi_driver_t* new_aubio_alsa_seq_driver(//aubio_settings_t* settings, handle_midi_event_func_t handler, void* data) { int i, err; aubio_alsa_seq_driver_t* dev; /**< object to return */ pthread_attr_t attr; /**< sequencer thread */ int sched = SCHED_FIFO; /**< default scheduling policy */ struct sched_param priority; /**< scheduling priority settings */ int count; /**< number of MIDI file descriptors */ struct pollfd *pfd = NULL; /**< poll file descriptor array (copied in dev->pfd) */ char* device = NULL; /**< the device name */ char* id = NULL; char full_id[64]; char full_name[64]; /* not much use doing anything */ if (handler == NULL) { AUBIO_ERR( "Invalid argument"); return NULL; } /* allocate the device */ dev = AUBIO_NEW(aubio_alsa_seq_driver_t); if (dev == NULL) { AUBIO_ERR( "Out of memory"); return NULL; } AUBIO_MEMSET(dev, 0, sizeof(aubio_alsa_seq_driver_t)); dev->seq_port = -1; dev->driver.data = data; dev->driver.handler = handler; /* get the device name. if none is specified, use the default device. */ //aubio_settings_getstr(settings, "midi.alsa_seq.device", &device); if (device == NULL) { device = "default"; } /* open the sequencer INPUT only, non-blocking */ //if ((err = snd_seq_open(&dev->seq_handle, device, SND_SEQ_OPEN_INPUT, if ((err = snd_seq_open(&dev->seq_handle, device, SND_SEQ_OPEN_DUPLEX, SND_SEQ_NONBLOCK)) < 0) { AUBIO_ERR( "Error opening ALSA sequencer"); goto error_recovery; } /* get # of MIDI file descriptors */ count = snd_seq_poll_descriptors_count(dev->seq_handle, POLLIN); if (count > 0) { /* make sure there are some */ pfd = AUBIO_MALLOC(sizeof (struct pollfd) * count); dev->pfd = AUBIO_MALLOC(sizeof (struct pollfd) * count); /* grab file descriptor POLL info structures */ count = snd_seq_poll_descriptors(dev->seq_handle, pfd, count, POLLIN); } for (i = 0; i < count; i++) { /* loop over file descriptors */ /* copy the input FDs */ if (pfd[i].events & POLLIN) { /* use only the input FDs */ dev->pfd[dev->npfd].fd = pfd[i].fd; dev->pfd[dev->npfd].events = POLLIN; dev->pfd[dev->npfd].revents = 0; dev->npfd++; } } AUBIO_FREE(pfd); //aubio_settings_getstr(settings, "midi.alsa_seq.id", &id); if (id != NULL) { if (AUBIO_STRCMP(id, "pid") == 0) { snprintf(full_id, 64, "aubio (%d)", getpid()); snprintf(full_name, 64, "aubio_port (%d)", getpid()); } else { snprintf(full_id, 64, "aubio (%s)", id); snprintf(full_name, 64, "aubio_port (%s)", id); } } else { snprintf(full_id, 64, "aubio"); snprintf(full_name, 64, "aubio_port"); } /* set the client name */ snd_seq_set_client_name (dev->seq_handle, full_id); if ((dev->seq_port = snd_seq_create_simple_port (dev->seq_handle, full_name, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ | SND_SEQ_PORT_CAP_DUPLEX, SND_SEQ_PORT_TYPE_APPLICATION)) < 0) { AUBIO_ERR( "Error creating ALSA sequencer port"); goto error_recovery; } dev->status = AUBIO_MIDI_READY; /* create the midi thread */ if (pthread_attr_init(&attr)) { AUBIO_ERR( "Couldn't initialize midi thread attributes"); goto error_recovery; } /* use fifo scheduling. if it fails, use default scheduling. */ while (1) { err = pthread_attr_setschedpolicy(&attr, sched); if (err) { AUBIO_MSG( "Couldn't set high priority scheduling for the MIDI input"); if (sched == SCHED_FIFO) { sched = SCHED_OTHER; continue; } else { AUBIO_ERR( "Couldn't set scheduling policy."); goto error_recovery; } } /* SCHED_FIFO will not be active without setting the priority */ priority.sched_priority = (sched == SCHED_FIFO) ? ALSA_SEQ_SCHED_PRIORITY : 0; pthread_attr_setschedparam (&attr, &priority); err = pthread_create(&dev->thread, &attr, aubio_alsa_seq_run, (void*) dev); if (err) { AUBIO_ERR( "Couldn't set high priority scheduling for the MIDI input"); if (sched == SCHED_FIFO) { sched = SCHED_OTHER; continue; } else { //AUBIO_LOG(AUBIO_PANIC, "Couldn't create the midi thread."); AUBIO_ERR( "Couldn't create the midi thread."); goto error_recovery; } } break; } return (aubio_midi_driver_t*) dev; error_recovery: del_aubio_alsa_seq_driver((aubio_midi_driver_t*) dev); return NULL; }