size_t overlap_size;//window_size-R
size_t samples_gathered;
//message
+ float X;
float *H;//frequency response filter (magnitude based)
float *W;//windowing function (time domain)
float *work_buffer, **input, **overlap_accum;
fftwf_plan forward_plan, inverse_plan;
//size_t samplings;
+ float Xs[2];
float *Hs[2];//thread updatable copies
pa_aupdate *a_H;
pa_memchunk conv_buffer;
#define v_size 4
#define SINKLIST "equalized_sinklist"
#define EQDB "equalizer_db"
+#define FILTER_SIZE (u->fft_size / 2 + 1)
+#define PROFILE_SIZE (FILTER_SIZE + 1)
static void dbus_init(struct userdata *u);
static void dbus_done(struct userdata *u);
switch (code) {
case PA_SINK_MESSAGE_GET_LATENCY: {
- size_t fs=pa_frame_size(&u->sink->sample_spec);
+ //size_t fs=pa_frame_size(&u->sink->sample_spec);
/* The sink is _put() before the sink input is, so let's
* make sure we don't access it in that time. Also, the
pa_sink_get_latency_within_thread(u->sink_input->sink) +
/* Add the latency internal to our sink input on top */
- pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec) +
- pa_bytes_to_usec(u->samples_gathered * fs, &u->sink->sample_spec);
+ pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
+ // pa_bytes_to_usec(u->samples_gathered * fs, &u->sink->sample_spec);
//+ pa_bytes_to_usec(u->latency * fs, ss)
//+ pa_bytes_to_usec(pa_memblockq_get_length(u->input_q), ss);
return 0;
pa_sink_get_requested_latency_within_thread(s));
}
-typedef float v4sf __attribute__ ((__aligned__(v_size * sizeof(float))));
-typedef union float_vector {
- float f[v_size];
- v4sf v;
-#ifdef __SSE2__
- __m128 m;
-#endif
-} float_vector_t;
-
//reference implementation
static void dsp_logic(
float * restrict dst,//used as a temp array too, needs to be fft_length!
memset(dst + u->window_size, 0, (u->fft_size - u->window_size) * sizeof(float));
//window the data
for(size_t j = 0;j < u->window_size; ++j){
- dst[j] = W[j] * src[j];
+ dst[j] = u->X * W[j] * src[j];
}
//Processing is done here!
//do fft
fftwf_execute_dft_r2c(u->forward_plan, dst, output_window);
//perform filtering
- for(size_t j = 0; j < u->fft_size / 2 + 1; ++j){
+ for(size_t j = 0; j < FILTER_SIZE; ++j){
u->output_window[j][0] *= u->H[j];
u->output_window[j][1] *= u->H[j];
}
);
}
+typedef float v4sf __attribute__ ((__aligned__(v_size * sizeof(float))));
+typedef union float_vector {
+ float f[v_size];
+ v4sf v;
+#ifdef __SSE2__
+ __m128 m;
+#endif
+} float_vector_t;
+
////regardless of sse enabled, the loops in here assume
////16 byte aligned addresses and memory allocations divisible by v_size
//void dsp_logic(
// const float * restrict W,//The windowing function
// fftwf_complex * restrict output_window,//The transformed window'd src
// struct userdata *u){//Collection of constants
-//
+ //float_vector_t x = {u->X, u->X, u->X, u->X};
// const size_t window_size = PA_ROUND_UP(u->window_size,v_size);
-// const size_t fft_h = PA_ROUND_UP(u->fft_size / 2 + 1, v_size / 2);
+// const size_t fft_h = PA_ROUND_UP(FILTER_SIZE, v_size / 2);
// //const size_t R = PA_ROUND_UP(u->R, v_size);
// const size_t overlap_size = PA_ROUND_UP(u->overlap_size, v_size);
+// overlap_size = PA_ROUND_UP(u->overlap_size, v_size);
//
// //assert(u->samples_gathered >= u->R);
// //zero out the bit beyond the real overlap so we don't add garbage
// float_vector_t *w = (float_vector_t*) (W+j);
// float_vector_t *s = (float_vector_t*) (src+j);
//#if __SSE2__
-// d->m = _mm_mul_ps(w->m, s->m);
+// d->m = _mm_mul_ps(x->m, _mm_mul_ps(w->m, s->m));
//#else
-// d->v = w->v * s->v;
+// d->v = x->v * w->v * s->v;
//#endif
// }
// //Processing is done here!
struct userdata *u;
size_t fs;
struct timeval start, end;
+ unsigned a_i;
pa_memchunk tchunk;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
pa_assert(u->fft_size >= u->window_size);
pa_assert(u->R < u->window_size);
/* set the H filter */
- u->H = u->Hs[pa_aupdate_read_begin(u->a_H)];
+ a_i = pa_aupdate_read_begin(u->a_H);
+ u->X = u->Xs[a_i];
+ u->H = u->Hs[a_i];
pa_rtclock_get(&start);
/* process a block */
process_samples(u, chunk);
}
static void save_profile(struct userdata *u, char *name){
- float *H_n = pa_xmalloc((u->fft_size / 2 + 1) * sizeof(float));
- const float *H = u->Hs[pa_aupdate_read_begin(u->a_H)];
+ unsigned a_i;
+ const size_t profile_size = PROFILE_SIZE * sizeof(float);
+ float *H_n, *profile;
+ const float *H;
pa_datum key, data;
- for(size_t i = 0 ; i <= u->fft_size / 2 + 1; ++i){
+ profile = pa_xnew0(float, profile_size);
+ a_i = pa_aupdate_read_begin(u->a_H);
+ 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];
}
pa_aupdate_read_end(u->a_H);
key.data=name;
key.size = strlen(key.data);
- data.data = H_n;
- data.size = (u->fft_size / 2 + 1) * sizeof(float);
+ data.data = profile;
+ data.size = profile_size;
pa_database_set(u->database, &key, &data, TRUE);
pa_database_sync(u->database);
}
}
static const char* load_profile(struct userdata *u, char *name){
- pa_datum key,value;
+ unsigned a_i;
+ pa_datum key, value;
+ const size_t profile_size = PROFILE_SIZE * sizeof(float);
key.data = name;
key.size = strlen(key.data);
if(pa_database_get(u->database, &key, &value) != NULL){
- if(value.size == (u->fft_size / 2 + 1) * sizeof(float)){
- float *H=u->Hs[pa_aupdate_write_begin(u->a_H)];
- memcpy(H, value.data, value.size);
+ 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);
}else{
return "incompatible size";
pa_bool_t *use_default = NULL;
size_t fs;
float *H;
+ unsigned a_i;
pa_assert(m);
u->a_H = pa_aupdate_new();
u->latency = u->window_size - u->R;
for(size_t i = 0; i < 2; ++i){
- u->Hs[i] = alloc((u->fft_size / 2 + 1), sizeof(float));
+ u->Hs[i] = alloc((FILTER_SIZE), sizeof(float));
}
u->W = alloc(u->window_size, sizeof(float));
u->work_buffer = alloc(u->fft_size, sizeof(float));
u->overlap_accum[c] = alloc(u->overlap_size, sizeof(float));
memset(u->overlap_accum[c], 0, u->overlap_size*sizeof(float));
}
- u->output_window = alloc((u->fft_size / 2 + 1), sizeof(fftwf_complex));
+ u->output_window = alloc((FILTER_SIZE), sizeof(fftwf_complex));
u->forward_plan = fftwf_plan_dft_r2c_1d(u->fft_size, u->work_buffer, u->output_window, FFTW_ESTIMATE);
u->inverse_plan = fftwf_plan_dft_c2r_1d(u->fft_size, u->output_window, u->work_buffer, FFTW_ESTIMATE);
dbus_init(u);
//default filter to these
- H=u->Hs[pa_aupdate_write_begin(u->a_H)];
- for(size_t i = 0; i < u->fft_size / 2 + 1; ++i){
+ 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);
}
fix_filter(H, u->fft_size);
#define MANAGER_IFACE EXTNAME ".Manager"
#define EQUALIZER_IFACE EXTNAME ".Equalizer"
static void manager_get_revision(DBusConnection *conn, DBusMessage *msg, void *_u);
-static void get_sinks(pa_core *u, char ***names, unsigned *n_sinks);
static void manager_get_sinks(DBusConnection *conn, DBusMessage *msg, void *_u);
-static void get_profiles(pa_core *u, char ***names, unsigned *n_sinks);
static void manager_get_profiles(DBusConnection *conn, DBusMessage *msg, void *_u);
static void manager_get_all(DBusConnection *conn, DBusMessage *msg, void *_u);
static void manager_handle_remove_profile(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_get_all(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_set_filter(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_save_profile(DBusConnection *conn, DBusMessage *msg, void *_u);
static void equalizer_handle_load_profile(DBusConnection *conn, DBusMessage *msg, void *_u);
-static void get_filter(struct userdata *u, double **H_);
-static void set_filter(struct userdata *u, double **H_);
enum manager_method_index {
MANAGER_METHOD_REMOVE_PROFILE,
MANAGER_METHOD_MAX
EQUALIZER_HANDLER_FILTERSAMPLERATE,
EQUALIZER_HANDLER_N_COEFS,
EQUALIZER_HANDLER_FILTER,
+ EQUALIZER_HANDLER_PREAMP,
EQUALIZER_HANDLER_MAX
};
pa_dbus_arg_info filter_points_args[]={
{"xs", "au","in"},
{"ys", "ad","out"},
+ {"preamp", "d","out"},
};
pa_dbus_arg_info seed_filter_args[]={
{"xs", "au","in"},
{"ys", "ad","in"},
+ {"preamp", "d","in"},
};
pa_dbus_arg_info save_profile_args[]={
{"name", "s","in"},
[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_FILTER]{.property_name="Filter",.type="ad",.get_cb=equalizer_get_filter,.set_cb=equalizer_set_filter}
};
enum equalizer_signal_index{
.n_signals=EQUALIZER_SIGNAL_MAX
};
-static void dbus_init(struct userdata *u){
+void dbus_init(struct userdata *u){
uint32_t dummy;
DBusMessage *signal = NULL;
pa_idxset *sink_list = NULL;
dbus_message_unref(signal);
}
-static void dbus_done(struct userdata *u){
+void dbus_done(struct userdata *u){
pa_idxset *sink_list;
uint32_t dummy;
pa_dbus_protocol_unref(u->dbus_protocol);
}
-static void manager_handle_remove_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
+void manager_handle_remove_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
DBusError error;
pa_core *c = (pa_core *)_u;
DBusMessage *signal = NULL;
dbus_message_unref(signal);
}
-static void manager_get_revision(DBusConnection *conn, DBusMessage *msg, void *_u){
+void manager_get_revision(DBusConnection *conn, DBusMessage *msg, void *_u){
uint32_t rev=1;
pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_UINT32, &rev);
}
}
}
-static void manager_get_sinks(DBusConnection *conn, DBusMessage *msg, void *_u){
+void manager_get_sinks(DBusConnection *conn, DBusMessage *msg, void *_u){
unsigned n;
char **names = NULL;
pa_assert(conn);
pa_strlist_free(head);
}
-static void manager_get_profiles(DBusConnection *conn, DBusMessage *msg, void *_u){
+void manager_get_profiles(DBusConnection *conn, DBusMessage *msg, void *_u){
char **names;
unsigned n;
pa_assert(conn);
pa_xfree(names);
}
-static void manager_get_all(DBusConnection *conn, DBusMessage *msg, void *_u){
+void manager_get_all(DBusConnection *conn, DBusMessage *msg, void *_u){
pa_core *c;
char **names = NULL;
unsigned n;
dbus_message_unref(reply);
}
-static void equalizer_handle_seed_filter(DBusConnection *conn, DBusMessage *msg, void *_u) {
+void equalizer_handle_seed_filter(DBusConnection *conn, DBusMessage *msg, void *_u) {
struct userdata *u=(struct userdata *) _u;
DBusError error;
DBusMessage *signal = NULL;
float *ys;
uint32_t *xs;
- double *_ys;
- unsigned x_npoints, y_npoints;
+ double *_ys, preamp;
+ unsigned x_npoints, y_npoints, a_i;
float *H;
pa_bool_t points_good = TRUE;
pa_assert(conn);
if(!dbus_message_get_args(msg, &error,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &xs, &x_npoints,
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &_ys, &y_npoints,
+ 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;
}
for(size_t i = 0; i < x_npoints; ++i){
- if(xs[i] >= u->fft_size / 2 + 1){
+ if(xs[i] >= FILTER_SIZE){
points_good = FALSE;
break;
}
dbus_error_free(&error);
return;
- }else if(x_npoints != y_npoints || x_npoints < 2 || x_npoints > u->fft_size / 2 +1 ){
- pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "xs and ys must be the same length and 2<=l<=%ld!", u->fft_size / 2 + 1);
+ }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);
return;
}else if(xs[0] != 0 || xs[x_npoints - 1] != u->fft_size / 2){
for(uint32_t i = 0; i < x_npoints; ++i){
ys[i] = (float) _ys[i];
}
-
- H = u->Hs[pa_aupdate_write_begin(u->a_H)];
- interpolate(H, u->fft_size / 2 + 1, xs, ys, x_npoints);
+ a_i = pa_aupdate_write_begin(u->a_H);
+ H = u->Hs[a_i];
+ u->Xs[a_i] = preamp;
+ interpolate(H, FILTER_SIZE, xs, ys, x_npoints);
fix_filter(H, u->fft_size);
pa_aupdate_write_end(u->a_H);
pa_xfree(ys);
dbus_message_unref(signal);
}
-static void equalizer_handle_get_filter_points(DBusConnection *conn, DBusMessage *msg, void *_u) {
+void equalizer_handle_get_filter_points(DBusConnection *conn, DBusMessage *msg, void *_u) {
struct userdata *u = (struct userdata *) _u;
DBusError error;
uint32_t *xs;
- double *ys;
- unsigned x_npoints;
+ double *ys, preamp;
+ unsigned x_npoints, a_i;
float *H;
pa_bool_t points_good=TRUE;
+ DBusMessage *reply = NULL;
+ DBusMessageIter msg_iter;
pa_assert(conn);
pa_assert(msg);
return;
}
for(size_t i = 0; i < x_npoints; ++i){
- if(xs[i] >= u->fft_size / 2 + 1){
+ if(xs[i] >= FILTER_SIZE){
points_good=FALSE;
break;
}
}
- if(x_npoints > u->fft_size / 2 +1 || !points_good){
- pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "xs indices/length must be <= %ld!", u->fft_size / 2 + 1);
+ if(x_npoints > FILTER_SIZE || !points_good){
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "xs indices/length must be <= %ld!", FILTER_SIZE);
dbus_error_free(&error);
return;
}
ys = pa_xmalloc(x_npoints * sizeof(double));
- H = u->Hs[pa_aupdate_read_begin(u->a_H)];
+ a_i = pa_aupdate_read_begin(u->a_H);
+ H = u->Hs[a_i];
+ preamp = u->Xs[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_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_DOUBLE, ys, x_npoints);
+ 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, ys, x_npoints);
+ 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(ys);
}
-static void equalizer_handle_save_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
+void equalizer_handle_save_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
struct userdata *u = (struct userdata *) _u;
char *name;
DBusMessage *signal = NULL;
dbus_message_unref(signal);
}
-static void equalizer_handle_load_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
+void equalizer_handle_load_profile(DBusConnection *conn, DBusMessage *msg, void *_u) {
struct userdata *u=(struct userdata *) _u;
char *name;
DBusError error;
dbus_error_free(&error);
return;
}
- err_msg = load_profile(u,name);
+ err_msg = load_profile(u, 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);
dbus_message_unref(signal);
}
-static void equalizer_get_revision(DBusConnection *conn, DBusMessage *msg, void *_u){
+void equalizer_get_revision(DBusConnection *conn, DBusMessage *msg, void *_u){
uint32_t rev=1;
pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_UINT32, &rev);
}
-static void equalizer_get_n_coefs(DBusConnection *conn, DBusMessage *msg, void *_u){
+void equalizer_get_n_coefs(DBusConnection *conn, DBusMessage *msg, void *_u){
struct userdata *u;
uint32_t n_coefs;
pa_assert_se(u = (struct userdata *) _u);
pa_assert(conn);
pa_assert(msg);
- n_coefs = (uint32_t) (u->fft_size / 2 + 1);
+ n_coefs = (uint32_t) PROFILE_SIZE;
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &n_coefs);
}
-static void equalizer_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *_u){
+void equalizer_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *_u){
struct userdata *u;
uint32_t rate;
pa_assert_se(u = (struct userdata *) _u);
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &rate);
}
-static void equalizer_get_filter_rate(DBusConnection *conn, DBusMessage *msg, void *_u){
+void equalizer_get_filter_rate(DBusConnection *conn, DBusMessage *msg, void *_u){
struct userdata *u;
uint32_t fft_size;
pa_assert_se(u = (struct userdata *) _u);
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &fft_size);
}
-static void get_filter(struct userdata *u, double **H_){
+static double * get_filter(struct userdata *u){
float *H;
- *H_ = pa_xnew0(double, u->fft_size / 2 + 1);
- H = u->Hs[pa_aupdate_read_begin(u->a_H)];
- for(size_t i = 0;i < u->fft_size / 2 + 1; ++i){
- (*H_)[i] = H[i] * u->fft_size;
+ 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_;
}
-static 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;
- pa_assert_se(u = (struct userdata *) _u);
- pa_assert(msg);
-
- rev = 1;
- n_coefs = (uint32_t) (u->fft_size / 2 + 1);
- rate = (uint32_t) u->sink->sample_spec.rate;
- fft_size = (uint32_t) u->fft_size;
-
- pa_assert_se((reply = dbus_message_new_method_return(msg)));
- dbus_message_iter_init_append(reply, &msg_iter);
- pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
-
- pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_REVISION].property_name, DBUS_TYPE_UINT32, &rev);
- 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);
- get_filter(u, &H);
- pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_FILTER].property_name, DBUS_TYPE_UINT32, &H);
- pa_xfree(H);
-
- pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
- pa_assert_se(dbus_connection_send(conn, reply, NULL));
- dbus_message_unref(reply);
-}
-
-static void equalizer_get_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
+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 = u->fft_size / 2 + 1;
+ n_coefs = PROFILE_SIZE;
pa_assert(conn);
pa_assert(msg);
- get_filter(u, &H_);
+ 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_){
- float *H = u->Hs[pa_aupdate_write_begin(u->a_H)];
- for(size_t i = 0; i < u->fft_size / 2 + 1; ++i){
- H[i] = (float) (*H_)[i];
+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, u->fft_size);
+ fix_filter(H + 1, u->fft_size);
pa_aupdate_write_end(u->a_H);
}
-static void equalizer_set_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
+void equalizer_set_filter(DBusConnection *conn, DBusMessage *msg, void *_u){
struct userdata *u;
double *H;
unsigned _n_coefs;
if(pa_dbus_get_fixed_array_set_property_arg(conn, msg, DBUS_TYPE_DOUBLE, &H, &_n_coefs)){
return;
}
- if(_n_coefs!=u->fft_size / 2 + 1){
- pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "This filter takes exactly %ld coefficients, you gave %d", u->fft_size / 2 + 1, _n_coefs);
+ 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);
- //Stupid for IO reasons? Add a save signal to dbus instead
- //save_state(u);
+ set_filter(u, H);
pa_dbus_send_empty_reply(conn, msg);
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;
+ pa_assert_se(u = (struct userdata *) _u);
+ pa_assert(msg);
+
+ rev = 1;
+ n_coefs = (uint32_t) PROFILE_SIZE;
+ rate = (uint32_t) u->sink->sample_spec.rate;
+ fft_size = (uint32_t) u->fft_size;
+
+ pa_assert_se((reply = dbus_message_new_method_return(msg)));
+ dbus_message_iter_init_append(reply, &msg_iter);
+ pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
+
+ pa_dbus_append_basic_variant_dict_entry(&dict_iter, equalizer_handlers[EQUALIZER_HANDLER_REVISION].property_name, DBUS_TYPE_UINT32, &rev);
+ 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_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
+ pa_assert_se(dbus_connection_send(conn, reply, NULL));
+ dbus_message_unref(reply);
+}