ArrayInfo(int id, af::dim4 size, af::dim4 offset, af::dim4 stride, af_dtype af_type): devId(id), type(af_type), dim_size(size), dim_offsets(offset), dim_strides(stride) { af_init(); }
static int recreate_audio_filters(struct MPContext *mpctx) { assert(mpctx->d_audio); struct af_stream *afs = mpctx->d_audio->afilter; struct MPOpts *opts = mpctx->opts; struct mp_audio in_format; mp_audio_buffer_get_format(mpctx->d_audio->decode_buffer, &in_format); int new_srate = in_format.rate; if (!af_control_any_rev(afs, AF_CONTROL_SET_PLAYBACK_SPEED, &opts->playback_speed)) { new_srate = in_format.rate * opts->playback_speed; if (new_srate != afs->output.rate) opts->playback_speed = new_srate / (double)in_format.rate; } afs->input.rate = new_srate; if (af_init(afs) < 0) { MP_ERR(mpctx, "Couldn't find matching filter/ao format!\n"); return -1; } mixer_reinit_audio(mpctx->mixer, mpctx->ao, afs); return 0; }
void mixer_setbalance(mixer_t *mixer, float val) { float level[AF_NCH]; int i; af_control_ext_t arg_ext = { .arg = level }; af_instance_t* af_pan_balance; if(!mixer->afilter) return; if (af_control_any_rev(mixer->afilter, AF_CONTROL_PAN_BALANCE | AF_CONTROL_SET, &val)) return; if (!(af_pan_balance = af_add(mixer->afilter, "pan"))) { mp_msg(MSGT_GLOBAL, MSGL_ERR, MSGTR_NoBalance); return; } af_init(mixer->afilter); /* make all other channels pass thru since by default pan blocks all */ memset(level, 0, sizeof(level)); for (i = 2; i < AF_NCH; i++) { arg_ext.ch = i; level[i] = 1.f; af_pan_balance->control(af_pan_balance, AF_CONTROL_PAN_LEVEL | AF_CONTROL_SET, &arg_ext); level[i] = 0.f; } af_pan_balance->control(af_pan_balance, AF_CONTROL_PAN_BALANCE | AF_CONTROL_SET, &val); }
/* Init audio filters */ int init_audio_filters(sh_audio_t *sh_audio, int in_samplerate, int in_channels, int in_format, int *out_samplerate, int *out_channels, int *out_format, int out_minsize, int out_maxsize){ af_stream_t* afs=sh_audio->afilter; if(!afs){ afs = malloc(sizeof(af_stream_t)); memset(afs,0,sizeof(af_stream_t)); } // input format: same as codec's output format: afs->input.rate = in_samplerate; afs->input.nch = in_channels; afs->input.format = in_format; af_fix_parameters(&(afs->input)); // output format: same as ao driver's input format (if missing, fallback to input) afs->output.rate = *out_samplerate; afs->output.nch = *out_channels; afs->output.format = *out_format; af_fix_parameters(&(afs->output)); // filter config: memcpy(&afs->cfg,&af_cfg,sizeof(af_cfg_t)); mp_msg(MSGT_DECAUDIO, MSGL_V, MSGTR_BuildingAudioFilterChain, afs->input.rate,afs->input.nch,af_fmt2str_short(afs->input.format), afs->output.rate,afs->output.nch,af_fmt2str_short(afs->output.format)); // let's autoprobe it! if(0 != af_init(afs)){ sh_audio->afilter=NULL; free(afs); return 0; // failed :( } *out_samplerate=afs->output.rate; *out_channels=afs->output.nch; *out_format=afs->output.format; if (out_maxsize || out_minsize) { // allocate the a_out_* buffers: if(out_maxsize<out_minsize) out_maxsize=out_minsize; if(out_maxsize<8192) out_maxsize=MAX_OUTBURST; // not sure this is ok sh_audio->a_out_buffer_size=out_maxsize; if (sh_audio->a_out_buffer != sh_audio->a_buffer) free(sh_audio->a_out_buffer); sh_audio->a_out_buffer=memalign(16,sh_audio->a_out_buffer_size); memset(sh_audio->a_out_buffer,0,sh_audio->a_out_buffer_size); sh_audio->a_out_buffer_len=0; } // ok! sh_audio->afilter=(void*)afs; return 1; }
int reinit_audio_filters(struct MPContext *mpctx) { struct sh_audio *sh_audio = mpctx->sh_audio; if (!sh_audio) return -2; af_uninit(mpctx->sh_audio->afilter); if (af_init(mpctx->sh_audio->afilter) < 0) return -1; if (recreate_audio_filters(mpctx) < 0) return -1; return 0; }
int reinit_audio_filters(struct MPContext *mpctx) { struct dec_audio *d_audio = mpctx->d_audio; if (!d_audio) return 0; af_uninit(mpctx->d_audio->afilter); if (af_init(mpctx->d_audio->afilter) < 0) return -1; if (recreate_audio_filters(mpctx) < 0) return -1; return 1; }
int init_audio_filters(sh_audio_t *sh_audio, int in_samplerate, int *out_samplerate, int *out_channels, int *out_format) { af_stream_t *afs = sh_audio->afilter; if (!afs) { afs = malloc(sizeof(af_stream_t)); memset(afs, 0, sizeof(af_stream_t)); } // input format: same as codec's output format: afs->input.rate = in_samplerate; afs->input.nch = sh_audio->channels; afs->input.format = sh_audio->sample_format; af_fix_parameters(&(afs->input)); // output format: same as ao driver's input format (if missing, fallback to input) afs->output.rate = *out_samplerate; afs->output.nch = *out_channels; afs->output.format = *out_format; af_fix_parameters(&(afs->output)); // filter config: memcpy(&afs->cfg, &af_cfg, sizeof(af_cfg_t)); mp_msg(MSGT_DECAUDIO, MSGL_V, "Building audio filter chain for %dHz/%dch/%s -> %dHz/%dch/%s...\n", afs->input.rate, afs->input.nch, af_fmt2str_short(afs->input.format), afs->output.rate, afs->output.nch, af_fmt2str_short(afs->output.format)); // let's autoprobe it! if (0 != af_init(afs)) { sh_audio->afilter = NULL; free(afs); return 0; // failed :( } *out_samplerate = afs->output.rate; *out_channels = afs->output.nch; *out_format = afs->output.format; // Do not reset a_out_buffer_len. This may cause some // glitches/slow adaption of changes but it is better than // losing audio even for minor adjustments and avoids sync issues. // ok! sh_audio->afilter = (void *) afs; return 1; }
void freakz_init() { drvr_init(); mmem_init(); ctimer_init(); mac_init(); nwk_init(); aps_init(); af_init(); zdo_init(); buf_init(); slow_clock_init(); #if (TEST_SIM == 1) test_app_init(); #endif }
int init_audio_filters(sh_audio_t *sh_audio, int in_samplerate, int *out_samplerate, int *out_channels, int *out_format) { af_stream_t *afs = sh_audio->afilter; if (!afs) { afs = malloc(sizeof(af_stream_t)); memset(afs, 0, sizeof(af_stream_t)); } // input format: same as codec's output format: afs->input.rate = in_samplerate; afs->input.nch = sh_audio->channels; afs->input.format = sh_audio->sample_format; af_fix_parameters(&(afs->input)); // output format: same as ao driver's input format (if missing, fallback to input) afs->output.rate = *out_samplerate; afs->output.nch = *out_channels; afs->output.format = *out_format; af_fix_parameters(&(afs->output)); // filter config: memcpy(&afs->cfg, &af_cfg, sizeof(af_cfg_t)); mp_msg(MSGT_DECAUDIO, MSGL_V, MSGTR_BuildingAudioFilterChain, afs->input.rate, afs->input.nch, af_fmt2str_short(afs->input.format), afs->output.rate, afs->output.nch, af_fmt2str_short(afs->output.format)); // let's autoprobe it! if (0 != af_init(afs)) { sh_audio->afilter = NULL; free(afs); return 0; // failed :( } *out_samplerate = afs->output.rate; *out_channels = afs->output.nch; *out_format = afs->output.format; sh_audio->a_out_buffer_len = 0; // ok! sh_audio->afilter = (void *) afs; return 1; }
int init_audio_filters(sh_audio_t *sh_audio, int in_samplerate, int *out_samplerate, int *out_channels, int *out_format) { af_stream_t *afs = sh_audio->afilter; if (!afs) { afs = calloc(1, sizeof(struct af_stream)); afs->opts = sh_audio->opts; } // input format: same as codec's output format: afs->input.rate = in_samplerate; afs->input.nch = sh_audio->channels; afs->input.format = sh_audio->sample_format; af_fix_parameters(&(afs->input)); // output format: same as ao driver's input format (if missing, fallback to input) afs->output.rate = *out_samplerate; afs->output.nch = *out_channels; afs->output.format = *out_format; af_fix_parameters(&(afs->output)); // filter config: memcpy(&afs->cfg, &af_cfg, sizeof(af_cfg_t)); mp_tmsg(MSGT_DECAUDIO, MSGL_V, "Building audio filter chain for %dHz/%dch/%s -> %dHz/%dch/%s...\n", afs->input.rate, afs->input.nch, af_fmt2str_short(afs->input.format), afs->output.rate, afs->output.nch, af_fmt2str_short(afs->output.format)); // let's autoprobe it! if (0 != af_init(afs)) { sh_audio->afilter = NULL; free(afs); return 0; // failed :( } *out_samplerate = afs->output.rate; *out_channels = afs->output.nch; *out_format = afs->output.format; // ok! sh_audio->afilter = (void *) afs; return 1; }
int audio_init_filters(struct dec_audio *d_audio, int in_samplerate, int *out_samplerate, struct mp_chmap *out_channels, int *out_format) { if (!d_audio->afilter) d_audio->afilter = af_new(d_audio->global); struct af_stream *afs = d_audio->afilter; // input format: same as codec's output format: mp_audio_buffer_get_format(d_audio->decode_buffer, &afs->input); // Sample rate can be different when adjusting playback speed afs->input.rate = in_samplerate; // output format: same as ao driver's input format (if missing, fallback to input) afs->output.rate = *out_samplerate; mp_audio_set_channels(&afs->output, out_channels); mp_audio_set_format(&afs->output, *out_format); afs->metadata = d_audio->metadata; afs->replaygain_data = d_audio->replaygain_data; char *s_from = mp_audio_config_to_str(&afs->input); char *s_to = mp_audio_config_to_str(&afs->output); MP_VERBOSE(d_audio, "Building audio filter chain for %s -> %s...\n", s_from, s_to); talloc_free(s_from); talloc_free(s_to); // let's autoprobe it! if (af_init(afs) != 0) { af_destroy(afs); d_audio->afilter = NULL; return 0; // failed :( } *out_samplerate = afs->output.rate; *out_channels = afs->output.channels; *out_format = afs->output.format; return 1; }
int init_audio_filters(sh_audio_t *sh_audio, int in_samplerate, int *out_samplerate, struct mp_chmap *out_channels, int *out_format) { if (!sh_audio->afilter) sh_audio->afilter = af_new(sh_audio->opts); struct af_stream *afs = sh_audio->afilter; // input format: same as codec's output format: afs->input.rate = in_samplerate; mp_audio_set_channels(&afs->input, &sh_audio->channels); mp_audio_set_format(&afs->input, sh_audio->sample_format); // output format: same as ao driver's input format (if missing, fallback to input) afs->output.rate = *out_samplerate; mp_audio_set_channels(&afs->output, out_channels); mp_audio_set_format(&afs->output, *out_format); char *s_from = mp_audio_config_to_str(&afs->input); char *s_to = mp_audio_config_to_str(&afs->output); mp_tmsg(MSGT_DECAUDIO, MSGL_V, "Building audio filter chain for %s -> %s...\n", s_from, s_to); talloc_free(s_from); talloc_free(s_to); // let's autoprobe it! if (af_init(afs) != 0) { af_destroy(afs); sh_audio->afilter = NULL; return 0; // failed :( } *out_samplerate = afs->output.rate; *out_channels = afs->output.channels; *out_format = afs->output.format; return 1; }
/** * Module thread, should not return. */ static void AutotuneTask(void *parameters) { enum AUTOTUNE_STATE state = AT_INIT; uint32_t last_update_time = PIOS_Thread_Systime(); float X[AF_NUMX] = {0}; float P[AF_NUMP] = {0}; float noise[3] = {0}; af_init(X,P); uint32_t last_time = 0.0f; const uint32_t YIELD_MS = 2; GyrosConnectCallback(at_new_gyro_data); while(1) { PIOS_WDG_UpdateFlag(PIOS_WDG_AUTOTUNE); uint32_t diff_time; const uint32_t PREPARE_TIME = 2000; const uint32_t MEASURE_TIME = 60000; static uint32_t update_counter = 0; bool doing_ident = false; bool can_sleep = true; FlightStatusData flightStatus; FlightStatusGet(&flightStatus); // Only allow this module to run when autotuning if (flightStatus.FlightMode != FLIGHTSTATUS_FLIGHTMODE_AUTOTUNE) { state = AT_INIT; PIOS_Thread_Sleep(50); continue; } switch(state) { case AT_INIT: last_update_time = PIOS_Thread_Systime(); // Only start when armed and flying if (flightStatus.Armed == FLIGHTSTATUS_ARMED_ARMED) { af_init(X,P); UpdateSystemIdent(X, NULL, 0.0f, 0, 0); state = AT_START; } break; case AT_START: diff_time = PIOS_Thread_Systime() - last_update_time; // Spend the first block of time in normal rate mode to get airborne if (diff_time > PREPARE_TIME) { last_time = PIOS_DELAY_GetRaw(); /* Drain the queue of all current data */ while (circ_queue_read_pos(at_queue)) { circ_queue_read_completed(at_queue); } /* And reset the point spill counter */ update_counter = 0; at_points_spilled = 0; state = AT_RUN; last_update_time = PIOS_Thread_Systime(); } break; case AT_RUN: diff_time = PIOS_Thread_Systime() - last_update_time; doing_ident = true; can_sleep = false; for (int i=0; i<MAX_PTS_PER_CYCLE; i++) { struct at_queued_data *pt; /* Grab an autotune point */ pt = circ_queue_read_pos(at_queue); if (!pt) { /* We've drained the buffer * fully. Yay! */ can_sleep = true; break; } /* calculate time between successive * points */ float dT_s = PIOS_DELAY_DiffuS2(last_time, pt->raw_time) * 1.0e-6f; /* This is for the first point, but * also if we have extended drops */ if (dT_s > 0.010f) { dT_s = 0.010f; } last_time = pt->raw_time; af_predict(X, P, pt->u, pt->y, dT_s); // Update uavo every 256 cycles to avoid // telemetry spam if (!((update_counter++) & 0xff)) { UpdateSystemIdent(X, noise, dT_s, update_counter, at_points_spilled); } for (uint32_t i = 0; i < 3; i++) { const float NOISE_ALPHA = 0.9997f; // 10 second time constant at 300 Hz noise[i] = NOISE_ALPHA * noise[i] + (1-NOISE_ALPHA) * (pt->y[i] - X[i]) * (pt->y[i] - X[i]); } /* Free the buffer containing an AT point */ circ_queue_read_completed(at_queue); } if (diff_time > MEASURE_TIME) { // Move on to next state state = AT_FINISHED; last_update_time = PIOS_Thread_Systime(); } break; case AT_FINISHED: // Wait until disarmed and landed before saving the settings UpdateSystemIdent(X, noise, 0, update_counter, at_points_spilled); state = AT_WAITING; // Fall through case AT_WAITING: // TODO do this unconditionally on disarm, // no matter what mode we're in. if (flightStatus.Armed == FLIGHTSTATUS_ARMED_DISARMED) { // Save the settings locally. UAVObjSave(SystemIdentHandle(), 0); state = AT_INIT; } break; default: // Set an alarm or some shit like that break; } // Update based on manual controls UpdateStabilizationDesired(doing_ident); if (can_sleep) { PIOS_Thread_Sleep(YIELD_MS); } } }