fftwf_plan forward_plan, inverse_plan;
//size_t samplings;
- float Xs[2];
- float *Hs[2];//thread updatable copies of the freq response filters (magintude based)
- pa_aupdate *a_H;
+ float **Xs;
+ float ***Hs;//thread updatable copies of the freq response filters (magintude based)
+ pa_aupdate **a_H;
pa_memchunk conv_buffer;
pa_memblockq *input_q;
pa_bool_t first_iteration;
pa_dbus_protocol *dbus_protocol;
char *dbus_path;
+ pa_bool_t set_default;
pa_database *database;
};
"master",
"format",
"rate",
+ "set_default",
"channels",
"channel_map",
NULL
#define v_size 4
#define SINKLIST "equalized_sinklist"
#define EQDB "equalizer_db"
+#define EQ_STATE_DB "equalizer-state"
#define FILTER_SIZE (u->fft_size / 2 + 1)
-#define PROFILE_SIZE (FILTER_SIZE + 1)
+#define CHANNEL_PROFILE_SIZE (FILTER_SIZE + 1)
+#define STATE_SIZE (CHANNEL_PROFILE_SIZE * u->channels)
static void dbus_init(struct userdata *u);
static void dbus_done(struct userdata *u);
tchunk->length = u->R * fs;
tchunk->memblock = pa_memblock_new(u->sink->core->mempool, tchunk->length);
dst = ((float*)pa_memblock_acquire(tchunk->memblock));
- /* set the H filter */
- a_i = pa_aupdate_read_begin(u->a_H);
- X = u->Xs[a_i];
- H = u->Hs[a_i];
for(size_t c=0;c < u->channels; c++) {
+ a_i = pa_aupdate_read_begin(u->a_H[c]);
+ X = u->Xs[c][a_i];
+ H = u->Hs[c][a_i];
dsp_logic(
u->work_buffer,
u->input[c],
u->output_window,
u
);
+ pa_aupdate_read_end(u->a_H[c]);
if(u->first_iteration){
/* The windowing function will make the audio ramped in, as a cheap fix we can
* undo the windowing (for non-zero window values)
}
pa_memblock_release(tchunk->memblock);
u->samples_gathered -= u->R;
-
- pa_aupdate_read_end(u->a_H);
}
static void initialize_buffer(struct userdata *u, pa_memchunk *in){
//pa_sink_render_into(u->sink, buffer);
while(pa_memblockq_peek(u->input_q, &tchunk) < 0){
pa_sink_render(u->sink, input_remaining*fs, &tchunk);
+ //pa_sink_render_full(u->sink, input_remaining*fs, &tchunk);
pa_assert(tchunk.memblock);
pa_memblockq_push(u->input_q, &tchunk);
pa_memblock_unref(tchunk.memblock);
//TODO: this guy causes dropouts constantly+rewinds, it's unusable
//pa_sink_set_latency_range_within_thread(u->sink, u->master->thread_info.min_latency, u->master->thread_info.max_latency);
pa_sink_attach_within_thread(u->sink);
+ if(u->set_default){
+ pa_namereg_set_default_sink(u->module->core, u->sink);
+ }
}
/* Called from main context */
}
}
-static void save_profile(struct userdata *u, char *name){
+static void save_profile(struct userdata *u, size_t channel, char *name){
unsigned a_i;
- const size_t profile_size = PROFILE_SIZE * sizeof(float);
+ const size_t profile_size = CHANNEL_PROFILE_SIZE * sizeof(float);
float *H_n, *profile;
const float *H;
pa_datum key, data;
profile = pa_xnew0(float, profile_size);
- a_i = pa_aupdate_read_begin(u->a_H);
+ a_i = pa_aupdate_read_begin(u->a_H[channel]);
+ profile[0] = u->Xs[a_i][channel];
+ H = u->Hs[channel][a_i];
H_n = profile + 1;
- H = u->Hs[a_i];
- profile[0] = u->Xs[a_i];
for(size_t i = 0 ; i <= FILTER_SIZE; ++i){
- //H_n[i] = H[i] * u->fft_size;
- H_n[i] = H[i];
+ H_n[i] = H[i] * u->fft_size;
+ //H_n[i] = H[i];
}
- pa_aupdate_read_end(u->a_H);
+ pa_aupdate_read_end(u->a_H[channel]);
key.data=name;
key.size = strlen(key.data);
data.data = profile;
}
static void save_state(struct userdata *u){
- char *state_name = pa_sprintf_malloc("%s-previous-state", u->name);
- save_profile(u, state_name);
- pa_xfree(state_name);
+ unsigned a_i;
+ const size_t state_size = STATE_SIZE * sizeof(float);
+ float *H_n, *state;
+ float *H;
+ pa_datum key, data;
+ pa_database *database;
+ char *dbname;
+ char *state_name = u->name;
+ state = pa_xnew0(float, STATE_SIZE);
+
+ for(size_t c = 0; c < u->channels; ++c){
+ a_i = pa_aupdate_read_begin(u->a_H[c]);
+ state[c * CHANNEL_PROFILE_SIZE] = u->Xs[a_i][c];
+ H = u->Hs[c][a_i];
+ H_n = state + c * CHANNEL_PROFILE_SIZE + 1;
+ memcpy(H_n, H, FILTER_SIZE * sizeof(float));
+ pa_aupdate_read_end(u->a_H[c]);
+ }
+
+ key.data = state_name;
+ key.size = strlen(key.data);
+ data.data = state;
+ data.size = state_size;
+ //thread safety for 0.9.17?
+ pa_assert_se(dbname = pa_state_path(EQ_STATE_DB, TRUE));
+ pa_assert_se(database = pa_database_open(dbname, TRUE));
+ pa_xfree(dbname);
+
+ pa_database_set(database, &key, &data, TRUE);
+ pa_database_sync(database);
+ pa_database_close(database);
+ pa_xfree(state);
}
static void remove_profile(pa_core *c, char *name){
pa_database_sync(database);
}
-static const char* load_profile(struct userdata *u, char *name){
+static const char* load_profile(struct userdata *u, size_t channel, char *name){
unsigned a_i;
pa_datum key, value;
- const size_t profile_size = PROFILE_SIZE * sizeof(float);
+ const size_t profile_size = CHANNEL_PROFILE_SIZE * sizeof(float);
key.data = name;
key.size = strlen(key.data);
if(pa_database_get(u->database, &key, &value) != NULL){
if(value.size == profile_size){
- float *H = (float *) value.data;
- a_i = pa_aupdate_write_begin(u->a_H);
- u->Xs[a_i] = H[0];
- memcpy(u->Hs[a_i], H + 1, (FILTER_SIZE) * sizeof(float));
- pa_aupdate_write_end(u->a_H);
+ float *profile = (float *) value.data;
+ a_i = pa_aupdate_write_begin(u->a_H[channel]);
+ u->Xs[channel][a_i] = profile[0];
+ memcpy(u->Hs[channel][a_i], profile + 1, CHANNEL_PROFILE_SIZE * sizeof(float));
+ fix_filter(u->Hs[channel][a_i], u->fft_size);
+ pa_aupdate_write_end(u->a_H[channel]);
}else{
return "incompatible size";
}
return "profile doesn't exist";
}
return NULL;
- //fix_filter(u->H, u->fft_size);
}
static void load_state(struct userdata *u){
- char *state_name=pa_sprintf_malloc("%s-previous-state", u->name);
- load_profile(u,state_name);
- pa_xfree(state_name);
+ unsigned a_i;
+ float *H;
+ pa_datum key, value;
+ pa_database *database;
+ char *dbname;
+ char *state_name = u->name;
+
+ pa_assert_se(dbname = pa_state_path(EQ_STATE_DB, FALSE));
+ database = pa_database_open(dbname, FALSE);
+ pa_xfree(dbname);
+ if(!database){
+ return;
+ }
+
+ key.data = state_name;
+ key.size = strlen(key.data);
+
+ if(pa_database_get(database, &key, &value) != NULL){
+ size_t states = PA_MIN(value.size / (CHANNEL_PROFILE_SIZE * sizeof(float)), u->channels);
+ float *state = (float *) value.data;
+ for(size_t c = 0; c < states; ++c){
+ a_i = pa_aupdate_write_begin(u->a_H[c]);
+ H = state + c * CHANNEL_PROFILE_SIZE + 1;
+ u->Xs[c][a_i] = state[c * CHANNEL_PROFILE_SIZE];
+ memcpy(u->Hs[c][a_i], H, FILTER_SIZE * sizeof(float));
+ pa_aupdate_write_end(u->a_H[c]);
+ }
+ pa_datum_free(&value);
+ }
+ pa_database_close(database);
}
/* Called from main context */
}
if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) {
- pa_log("Master sink not found");
- goto fail;
+ pa_log("Master sink not found, trying default");
+ master = pa_namereg_get_default_sink(m->core);
+ if(!master){
+ pa_log("no default sink found!");
+ goto fail;
+ }
}
ss = master->sample_spec;
u->module = m;
m->userdata = u;
+ u->set_default = TRUE;
+ u->set_default = pa_modargs_get_value_boolean(ma, "set_default", &u->set_default);
+
u->channels = ss.channels;
u->fft_size = pow(2, ceil(log(ss.rate)/log(2)));
pa_log_debug("fft size: %ld", u->fft_size);
u->R = (u->window_size + 1) / 2;
u->overlap_size = u->window_size - u->R;
u->samples_gathered = 0;
- u->a_H = pa_aupdate_new();
+ u->a_H = pa_xnew0(pa_aupdate *, u->channels);
u->latency = u->window_size - u->R;
- for(size_t i = 0; i < 2; ++i){
- u->Hs[i] = alloc((FILTER_SIZE), sizeof(float));
+ u->Xs = pa_xnew0(float *, u->channels);
+ u->Hs = pa_xnew0(float **, u->channels);
+ for(size_t c = 0; c < u->channels; ++c){
+ u->Xs[c] = pa_xnew0(float, 2);
+ u->Hs[c] = pa_xnew0(float *, 2);
+ for(size_t i = 0; i < 2; ++i){
+ u->Hs[c][i] = alloc((FILTER_SIZE), sizeof(float));
+ }
}
u->W = alloc(u->window_size, sizeof(float));
u->work_buffer = alloc(u->fft_size, sizeof(float));
u->input = pa_xnew0(float *, u->channels);
u->overlap_accum = pa_xnew0(float *, u->channels);
for(size_t c = 0; c < u->channels; ++c){
+ u->a_H[c] = pa_aupdate_new();
u->input[c] = alloc(u->window_size, sizeof(float));
memset(u->input[c], 0, (u->window_size)*sizeof(float));
u->overlap_accum[c] = alloc(u->overlap_size, sizeof(float));
dbus_init(u);
//default filter to these
- a_i = pa_aupdate_write_begin(u->a_H);
- H = u->Hs[a_i];
- u->Xs[a_i] = 1.0f;
- for(size_t i = 0; i < FILTER_SIZE; ++i){
- H[i] = 1.0 / sqrtf(2.0f);
+ for(size_t c = 0; c< u->channels; ++c){
+ a_i = pa_aupdate_write_begin(u->a_H[c]);
+ H = u->Hs[c][a_i];
+ u->Xs[c][a_i] = 1.0f;
+ for(size_t i = 0; i < FILTER_SIZE; ++i){
+ H[i] = 1.0 / sqrtf(2.0f);
+ }
+ fix_filter(H, u->fft_size);
+ pa_aupdate_write_end(u->a_H[c]);
}
- fix_filter(H, u->fft_size);
- pa_aupdate_write_end(u->a_H);
//load old parameters
load_state(u);
if (u->sink)
pa_sink_unref(u->sink);
- pa_aupdate_free(u->a_H);
pa_memblockq_free(u->input_q);
fftwf_destroy_plan(u->inverse_plan);
fftwf_destroy_plan(u->forward_plan);
pa_xfree(u->output_window);
for(size_t c=0; c < u->channels; ++c){
+ pa_aupdate_free(u->a_H[c]);
pa_xfree(u->overlap_accum[c]);
pa_xfree(u->input[c]);
}
+ pa_xfree(u->a_H);
pa_xfree(u->overlap_accum);
pa_xfree(u->input);
pa_xfree(u->work_buffer);
pa_xfree(u->W);
- for(size_t i = 0; i < 2; ++i){
- pa_xfree(u->Hs[i]);
+ for(size_t c = 0; c < u->channels; ++c){
+ pa_xfree(u->Xs[c]);
+ for(size_t i = 0; i < 2; ++i){
+ pa_xfree(u->Hs[c][i]);
+ }
+ pa_xfree(u->Hs[c]);
}
+ pa_xfree(u->Xs);
+ pa_xfree(u->Hs);
pa_xfree(u->name);
static void equalizer_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_get_filter_rate(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_get_n_coefs(DBusConnection *conn, DBusMessage *msg, void *_u);
-static void equalizer_get_filter(DBusConnection *conn, DBusMessage *msg, void *_u);
-static void equalizer_set_filter(DBusConnection *conn, DBusMessage *msg, void *_u);
+static void equalizer_get_n_channels(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_get_all(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_handle_seed_filter(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_handle_get_filter_points(DBusConnection *conn, DBusMessage *msg, void *_u);
+static void equalizer_handle_get_filter(DBusConnection *conn, DBusMessage *msg, void *_u);
+static void equalizer_handle_set_filter(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_handle_save_profile(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_handle_load_profile(DBusConnection *conn, DBusMessage *msg, void *_u);
enum manager_method_index {
EQUALIZER_METHOD_SEED_FILTER,
EQUALIZER_METHOD_SAVE_PROFILE,
EQUALIZER_METHOD_LOAD_PROFILE,
+ EQUALIZER_METHOD_SET_FILTER,
+ EQUALIZER_METHOD_GET_FILTER,
EQUALIZER_METHOD_MAX
};
EQUALIZER_HANDLER_SAMPLERATE,
EQUALIZER_HANDLER_FILTERSAMPLERATE,
EQUALIZER_HANDLER_N_COEFS,
- EQUALIZER_HANDLER_FILTER,
+ EQUALIZER_HANDLER_N_CHANNELS,
EQUALIZER_HANDLER_MAX
};
pa_dbus_arg_info filter_points_args[]={
+ {"channel", "u","in"},
{"xs", "au","in"},
{"ys", "ad","out"},
- {"preamp", "d","out"},
+ {"preamp", "d","out"}
};
pa_dbus_arg_info seed_filter_args[]={
+ {"channel", "u","in"},
{"xs", "au","in"},
{"ys", "ad","in"},
- {"preamp", "d","in"},
+ {"preamp", "d","in"}
+};
+
+pa_dbus_arg_info set_filter_args[]={
+ {"channel", "u","in"},
+ {"ys", "ad","in"},
+ {"preamp", "d","in"}
+};
+pa_dbus_arg_info get_filter_args[]={
+ {"channel", "u","in"},
+ {"ys", "ad","out"},
+ {"preamp", "d","out"}
};
+
pa_dbus_arg_info save_profile_args[]={
- {"name", "s","in"},
+ {"channel", "u","in"},
+ {"name", "s","in"}
};
pa_dbus_arg_info load_profile_args[]={
- {"name", "s","in"},
+ {"channel", "u","in"},
+ {"name", "s","in"}
};
static pa_dbus_method_handler equalizer_methods[EQUALIZER_METHOD_MAX]={
.arguments=filter_points_args,
.n_arguments=sizeof(filter_points_args)/sizeof(pa_dbus_arg_info),
.receive_cb=equalizer_handle_get_filter_points},
+ [EQUALIZER_METHOD_SET_FILTER]{
+ .method_name="SetFilter",
+ .arguments=set_filter_args,
+ .n_arguments=sizeof(set_filter_args)/sizeof(pa_dbus_arg_info),
+ .receive_cb=equalizer_handle_set_filter},
+ [EQUALIZER_METHOD_GET_FILTER]{
+ .method_name="GetFilter",
+ .arguments=get_filter_args,
+ .n_arguments=sizeof(get_filter_args)/sizeof(pa_dbus_arg_info),
+ .receive_cb=equalizer_handle_get_filter},
[EQUALIZER_METHOD_SAVE_PROFILE]{
.method_name="SaveProfile",
.arguments=save_profile_args,
.method_name="LoadProfile",
.arguments=load_profile_args,
.n_arguments=sizeof(load_profile_args)/sizeof(pa_dbus_arg_info),
- .receive_cb=equalizer_handle_load_profile},
+ .receive_cb=equalizer_handle_load_profile}
};
static pa_dbus_property_handler equalizer_handlers[EQUALIZER_HANDLER_MAX]={
[EQUALIZER_HANDLER_SAMPLERATE]{.property_name="SampleRate",.type="u",.get_cb=equalizer_get_sample_rate,.set_cb=NULL},
[EQUALIZER_HANDLER_FILTERSAMPLERATE]{.property_name="FilterSampleRate",.type="u",.get_cb=equalizer_get_filter_rate,.set_cb=NULL},
[EQUALIZER_HANDLER_N_COEFS]{.property_name="NFilterCoefficients",.type="u",.get_cb=equalizer_get_n_coefs,.set_cb=NULL},
- [EQUALIZER_HANDLER_FILTER]{.property_name="Filter",.type="ad",.get_cb=equalizer_get_filter,.set_cb=equalizer_set_filter}
+ [EQUALIZER_HANDLER_N_CHANNELS]{.property_name="NChannels",.type="u",.get_cb=equalizer_get_n_channels,.set_cb=NULL},
};
enum equalizer_signal_index{
pa_dbus_protocol_add_interface(u->dbus_protocol, u->dbus_path, &equalizer_info, u);
sink_list = pa_shared_get(u->sink->core, SINKLIST);
- u->database=pa_shared_get(u->sink->core, EQDB);
- if(sink_list==NULL){
+ u->database = pa_shared_get(u->sink->core, EQDB);
+ if(sink_list == NULL){
char *dbname;
sink_list=pa_idxset_new(&pa_idxset_trivial_hash_func, &pa_idxset_trivial_compare_func);
pa_shared_set(u->sink->core, SINKLIST, sink_list);
- pa_assert_se(dbname = pa_state_path("equalizers", TRUE));
+ pa_assert_se(dbname = pa_state_path("equalizer-presets", FALSE));
pa_assert_se(u->database = pa_database_open(dbname, TRUE));
pa_xfree(dbname);
- pa_shared_set(u->sink->core,EQDB,u->database);
+ pa_shared_set(u->sink->core, EQDB, u->database);
pa_dbus_protocol_add_interface(u->dbus_protocol, MANAGER_PATH, &manager_info, u->sink->core);
pa_dbus_protocol_register_extension(u->dbus_protocol, EXTNAME);
}
DBusError error;
DBusMessage *signal = NULL;
float *ys;
- uint32_t *xs;
+ uint32_t *xs, channel, r_channel;
double *_ys, preamp;
unsigned x_npoints, y_npoints, a_i;
float *H;
dbus_error_init(&error);
if(!dbus_message_get_args(msg, &error,
+ DBUS_TYPE_UINT32, &channel,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &xs, &x_npoints,
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &_ys, &y_npoints,
DBUS_TYPE_DOUBLE, &preamp,
dbus_error_free(&error);
return;
}
+ if(channel > u->channels){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "invalid channel: %d", channel);
+ dbus_error_free(&error);
+ return;
+ }
for(size_t i = 0; i < x_npoints; ++i){
if(xs[i] >= FILTER_SIZE){
points_good = FALSE;
pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "xs must be monotonic and 0<=x<=%ld", u->fft_size / 2);
dbus_error_free(&error);
return;
-
}else if(x_npoints != y_npoints || x_npoints < 2 || x_npoints > FILTER_SIZE ){
pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "xs and ys must be the same length and 2<=l<=%ld!", FILTER_SIZE);
dbus_error_free(&error);
for(uint32_t i = 0; i < x_npoints; ++i){
ys[i] = (float) _ys[i];
}
- a_i = pa_aupdate_write_begin(u->a_H);
- H = u->Hs[a_i];
- u->Xs[a_i] = preamp;
+ r_channel = channel == u->channels ? 0 : channel;
+ a_i = pa_aupdate_write_begin(u->a_H[r_channel]);
+ H = u->Hs[r_channel][a_i];
+ u->Xs[r_channel][a_i] = preamp;
interpolate(H, FILTER_SIZE, xs, ys, x_npoints);
fix_filter(H, u->fft_size);
- pa_aupdate_write_end(u->a_H);
+ if(channel == u->channels){
+ for(size_t c = 1; c < u->channels; ++c){
+ unsigned b_i = pa_aupdate_write_begin(u->a_H[c]);
+ float *H_p = u->Hs[c][b_i];
+ u->Xs[c][b_i] = preamp;
+ memcpy(H_p, H, FILTER_SIZE * sizeof(float));
+ pa_aupdate_write_end(u->a_H[c]);
+ }
+ }
+ pa_aupdate_write_end(u->a_H[r_channel]);
pa_xfree(ys);
+
//Stupid for IO reasons? Add a save signal to dbus instead
//save_state(u);
void equalizer_handle_get_filter_points(DBusConnection *conn, DBusMessage *msg, void *_u) {
struct userdata *u = (struct userdata *) _u;
- DBusError error;
- uint32_t *xs;
+ uint32_t *xs, channel, r_channel;
double *ys, preamp;
unsigned x_npoints, a_i;
float *H;
pa_bool_t points_good=TRUE;
DBusMessage *reply = NULL;
DBusMessageIter msg_iter;
+ DBusError error;
pa_assert(conn);
pa_assert(msg);
pa_assert(u);
dbus_error_init(&error);
-
if(!dbus_message_get_args(msg, &error,
+ DBUS_TYPE_UINT32, &channel,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &xs, &x_npoints,
DBUS_TYPE_INVALID)){
pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
dbus_error_free(&error);
return;
}
+ if(channel > u->channels){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "invalid channel: %d", channel);
+ dbus_error_free(&error);
+ return;
+ }
+
for(size_t i = 0; i < x_npoints; ++i){
if(xs[i] >= FILTER_SIZE){
points_good=FALSE;
return;
}
+ r_channel = channel == u->channels ? 0 : channel;
ys = pa_xmalloc(x_npoints * sizeof(double));
- a_i = pa_aupdate_read_begin(u->a_H);
- H = u->Hs[a_i];
- preamp = u->Xs[a_i];
+ a_i = pa_aupdate_read_begin(u->a_H[r_channel]);
+ H = u->Hs[r_channel][a_i];
+ preamp = u->Xs[r_channel][a_i];
for(uint32_t i = 0; i < x_npoints; ++i){
ys[i] = H[xs[i]] * u->fft_size;
}
- pa_aupdate_read_end(u->a_H);
+ pa_aupdate_read_end(u->a_H[r_channel]);
pa_assert_se((reply = dbus_message_new_method_return(msg)));
dbus_message_iter_init_append(reply, &msg_iter);
pa_xfree(ys);
}
+static void get_filter(struct userdata *u, size_t channel, double **H_, double *preamp){
+ float *H;
+ unsigned a_i;
+ size_t r_channel = channel == u->channels ? 0 : channel;
+ *H_ = pa_xnew0(double, FILTER_SIZE);
+ a_i = pa_aupdate_read_begin(u->a_H[r_channel]);
+ H = u->Hs[r_channel][a_i];
+ for(size_t i = 0;i < FILTER_SIZE; ++i){
+ (*H_)[i] = H[i] * u->fft_size;
+ }
+ *preamp = u->Xs[r_channel][a_i];
+
+ pa_aupdate_read_end(u->a_H[r_channel]);
+}
+
+void equalizer_handle_get_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
+ struct userdata *u;
+ unsigned n_coefs;
+ uint32_t channel;
+ double *H_, preamp;
+ DBusMessage *reply = NULL;
+ DBusMessageIter msg_iter;
+ DBusError error;
+ pa_assert_se(u = (struct userdata *) _u);
+ pa_assert(conn);
+ pa_assert(msg);
+
+ dbus_error_init(&error);
+ if(!dbus_message_get_args(msg, &error,
+ DBUS_TYPE_UINT32, &channel,
+ DBUS_TYPE_INVALID)){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
+ dbus_error_free(&error);
+ return;
+ }
+ if(channel > u->channels){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "invalid channel: %d", channel);
+ dbus_error_free(&error);
+ return;
+ }
+
+ n_coefs = CHANNEL_PROFILE_SIZE;
+ pa_assert(conn);
+ pa_assert(msg);
+ get_filter(u, channel, &H_, &preamp);
+ pa_assert_se((reply = dbus_message_new_method_return(msg)));
+ dbus_message_iter_init_append(reply, &msg_iter);
+
+ pa_dbus_append_basic_array(&msg_iter, DBUS_TYPE_DOUBLE, H_, n_coefs);
+ pa_dbus_append_basic_variant(&msg_iter, DBUS_TYPE_DOUBLE, &preamp);
+
+ pa_assert_se(dbus_connection_send(conn, reply, NULL));
+ dbus_message_unref(reply);
+ pa_xfree(H_);
+}
+
+static void set_filter(struct userdata *u, size_t channel, double *H_, double preamp){
+ unsigned a_i;
+ size_t r_channel = channel == u->channels ? 0 : channel;
+ float *H;
+ //all channels
+ a_i = pa_aupdate_write_begin(u->a_H[r_channel]);
+ u->Xs[r_channel][a_i] = (float) preamp;
+ H = u->Hs[r_channel][a_i];
+ for(size_t i = 0; i < FILTER_SIZE; ++i){
+ H[i] = (float) H_[i];
+ }
+ fix_filter(H, u->fft_size);
+ if(channel == u->channels){
+ for(size_t c = 1; c < u->channels; ++c){
+ unsigned b_i = pa_aupdate_write_begin(u->a_H[c]);
+ u->Xs[c][b_i] = u->Xs[r_channel][a_i];
+ memcpy(u->Hs[c][b_i], u->Hs[r_channel][a_i], FILTER_SIZE * sizeof(float));
+ pa_aupdate_write_end(u->a_H[c]);
+ }
+ }
+ pa_aupdate_write_end(u->a_H[r_channel]);
+}
+
+void equalizer_handle_set_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
+ struct userdata *u;
+ double *H, preamp;
+ uint32_t channel;
+ unsigned _n_coefs;
+ DBusMessage *signal = NULL;
+ DBusError error;
+ pa_assert_se(u = (struct userdata *) _u);
+ pa_assert(conn);
+ pa_assert(msg);
+
+ dbus_error_init(&error);
+ if(!dbus_message_get_args(msg, &error,
+ DBUS_TYPE_UINT32, &channel,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &H, &_n_coefs,
+ DBUS_TYPE_DOUBLE, &preamp,
+ DBUS_TYPE_INVALID)){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
+ dbus_error_free(&error);
+ return;
+ }
+ if(channel > u->channels){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "invalid channel: %d", channel);
+ dbus_error_free(&error);
+ return;
+ }
+ if(_n_coefs != FILTER_SIZE){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "This filter takes exactly %ld coefficients, you gave %d", FILTER_SIZE, _n_coefs);
+ return;
+ }
+ set_filter(u, channel, H, preamp);
+
+ pa_dbus_send_empty_reply(conn, msg);
+
+ pa_assert_se((signal = dbus_message_new_signal(u->dbus_path, EQUALIZER_IFACE, equalizer_signals[EQUALIZER_SIGNAL_FILTER_CHANGED].name)));
+ pa_dbus_protocol_send_signal(u->dbus_protocol, signal);
+ dbus_message_unref(signal);
+}
+
void equalizer_handle_save_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
struct userdata *u = (struct userdata *) _u;
char *name;
+ uint32_t channel, r_channel;
DBusMessage *signal = NULL;
DBusError error;
pa_assert(conn);
dbus_error_init(&error);
if(!dbus_message_get_args(msg, &error,
- DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &channel,
+ DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID)){
pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
dbus_error_free(&error);
return;
}
- save_profile(u,name);
+ if(channel > u->channels){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "invalid channel: %d", channel);
+ dbus_error_free(&error);
+ return;
+ }
+ r_channel = channel == u->channels ? 0 : channel;
+ save_profile(u, r_channel, name);
pa_dbus_send_empty_reply(conn, msg);
pa_assert_se((signal = dbus_message_new_signal(MANAGER_PATH, MANAGER_IFACE, manager_signals[MANAGER_SIGNAL_PROFILES_CHANGED].name)));
}
void equalizer_handle_load_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
- struct userdata *u=(struct userdata *) _u;
+ struct userdata *u = (struct userdata *) _u;
char *name;
DBusError error;
+ uint32_t channel, r_channel;
const char *err_msg = NULL;
DBusMessage *signal = NULL;
dbus_error_init(&error);
if(!dbus_message_get_args(msg, &error,
- DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &channel,
+ DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID)){
pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
dbus_error_free(&error);
return;
}
- err_msg = load_profile(u, name);
+ if(channel > u->channels){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "invalid channel: %d", channel);
+ dbus_error_free(&error);
+ return;
+ }
+ r_channel = channel == u->channels ? 0 : channel;
+
+ err_msg = load_profile(u, r_channel, name);
if(err_msg != NULL){
pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "error loading profile %s: %s", name, err_msg);
dbus_error_free(&error);
return;
}
+ if(channel == u->channels){
+ for(uint32_t c = 1; c < u->channels; ++c){
+ load_profile(u, c, name);
+ }
+ }
pa_dbus_send_empty_reply(conn, msg);
pa_assert_se((signal = dbus_message_new_signal(u->dbus_path, EQUALIZER_IFACE, equalizer_signals[EQUALIZER_SIGNAL_FILTER_CHANGED].name)));
pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_UINT32, &rev);
}
+void equalizer_get_n_channels(DBusConnection *conn, DBusMessage *msg, void *_u){
+ struct userdata *u;
+ uint32_t channels;
+ pa_assert_se(u = (struct userdata *) _u);
+ pa_assert(conn);
+ pa_assert(msg);
+
+ channels = (uint32_t) u->channels;
+ pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &channels);
+}
+
void equalizer_get_n_coefs(DBusConnection *conn, DBusMessage *msg, void *_u){
struct userdata *u;
uint32_t n_coefs;
pa_assert(conn);
pa_assert(msg);
- n_coefs = (uint32_t) PROFILE_SIZE;
+ n_coefs = (uint32_t) CHANNEL_PROFILE_SIZE;
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &n_coefs);
}
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &fft_size);
}
-static double * get_filter(struct userdata *u){
- float *H;
- double *H_;
- unsigned a_i;
- H_ = pa_xnew0(double, PROFILE_SIZE);
- a_i = pa_aupdate_read_begin(u->a_H);
- H = u->Hs[a_i];
- H_[0] = u->Xs[a_i];
- for(size_t i = 0;i < FILTER_SIZE; ++i){
- H_[i + 1] = H[i] * u->fft_size;
- }
- pa_aupdate_read_end(u->a_H);
- return H_;
-}
-
-void equalizer_get_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
- struct userdata *u;
- unsigned n_coefs;
- double *H_;
- pa_assert_se(u = (struct userdata *) _u);
-
- n_coefs = PROFILE_SIZE;
- pa_assert(conn);
- pa_assert(msg);
- H_ = get_filter(u);
- pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_DOUBLE, H_, n_coefs);
- pa_xfree(H_);
-}
-
-static void set_filter(struct userdata *u, double *H_){
- unsigned a_i= pa_aupdate_write_begin(u->a_H);
- float *H = u->Hs[a_i];
- u->Xs[a_i] = H_[0];
- for(size_t i = 0; i < FILTER_SIZE; ++i){
- H[i] = (float) H_[i + 1];
- }
- fix_filter(H + 1, u->fft_size);
- pa_aupdate_write_end(u->a_H);
-}
-
-void equalizer_set_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
- struct userdata *u;
- double *H;
- unsigned _n_coefs;
- DBusMessage *signal = NULL;
- pa_assert_se(u = (struct userdata *) _u);
- pa_assert(conn);
- pa_assert(msg);
-
- if(pa_dbus_get_fixed_array_set_property_arg(conn, msg, DBUS_TYPE_DOUBLE, &H, &_n_coefs)){
- return;
- }
- if(_n_coefs != PROFILE_SIZE){
- pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "This filter takes exactly %ld coefficients, you gave %d", PROFILE_SIZE, _n_coefs);
- return;
- }
- set_filter(u, H);
-
- pa_dbus_send_empty_reply(conn, msg);
-
- pa_assert_se((signal = dbus_message_new_signal(u->dbus_path, EQUALIZER_IFACE, equalizer_signals[EQUALIZER_SIGNAL_FILTER_CHANGED].name)));
- pa_dbus_protocol_send_signal(u->dbus_protocol, signal);
- dbus_message_unref(signal);
-}
-
void equalizer_get_all(DBusConnection *conn, DBusMessage *msg, void *_u){
struct userdata *u;
DBusMessage *reply = NULL;
DBusMessageIter msg_iter, dict_iter;
- uint32_t rev, n_coefs, rate, fft_size;
- double *H;
+ uint32_t rev, n_coefs, rate, fft_size, channels;
pa_assert_se(u = (struct userdata *) _u);
pa_assert(msg);
rev = 1;
- n_coefs = (uint32_t) PROFILE_SIZE;
+ n_coefs = (uint32_t) CHANNEL_PROFILE_SIZE;
rate = (uint32_t) u->sink->sample_spec.rate;
fft_size = (uint32_t) u->fft_size;
+ channels = (uint32_t) u->channels;
pa_assert_se((reply = dbus_message_new_method_return(msg)));
dbus_message_iter_init_append(reply, &msg_iter);
pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_SAMPLERATE].property_name, DBUS_TYPE_UINT32, &rate);
pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_FILTERSAMPLERATE].property_name, DBUS_TYPE_UINT32, &fft_size);
pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_N_COEFS].property_name, DBUS_TYPE_UINT32, &n_coefs);
- H = get_filter(u);
- pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_FILTER].property_name, DBUS_TYPE_UINT32, &H);
- pa_xfree(H);
+ pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_N_CHANNELS].property_name, DBUS_TYPE_UINT32, &channels);
pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
pa_assert_se(dbus_connection_send(conn, reply, NULL));
projects / platform / upstream / pulseaudio.git / commitdiff