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);
}
}
}
