2 This file is part of PulseAudio.
4 This module is based off Lennart Poettering's LADSPA sink and swaps out
5 LADSPA functionality for a dbus-aware STFT OLA based digital equalizer.
6 All new work is published under Pulseaudio's original license.
7 Copyright 2009 Jason Newton <nevion@gmail.com>
10 Copyright 2004-2008 Lennart Poettering
12 PulseAudio is free software; you can redistribute it and/or modify
13 it under the terms of the GNU Lesser General Public License as published
14 by the Free Software Foundation; either version 2.1 of the License,
15 or (at your option) any later version.
17 PulseAudio is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU Lesser General Public License
23 along with PulseAudio; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
39 #include <pulse/xmalloc.h>
40 #include <pulse/i18n.h>
41 #include <pulse/timeval.h>
43 #include <pulsecore/core-rtclock.h>
44 #include <pulsecore/aupdate.h>
45 #include <pulsecore/core-error.h>
46 #include <pulsecore/namereg.h>
47 #include <pulsecore/sink.h>
48 #include <pulsecore/module.h>
49 #include <pulsecore/core-util.h>
50 #include <pulsecore/modargs.h>
51 #include <pulsecore/log.h>
52 #include <pulsecore/thread.h>
53 #include <pulsecore/thread-mq.h>
54 #include <pulsecore/rtpoll.h>
55 #include <pulsecore/sample-util.h>
56 #include <pulsecore/shared.h>
57 #include <pulsecore/idxset.h>
58 #include <pulsecore/strlist.h>
59 #include <pulsecore/database.h>
60 #include <pulsecore/protocol-dbus.h>
61 #include <pulsecore/dbus-util.h>
69 #include <xmmintrin.h>
70 #include <emmintrin.h>
75 #include "module-equalizer-sink-symdef.h"
77 PA_MODULE_AUTHOR("Jason Newton");
78 PA_MODULE_DESCRIPTION(_("General Purpose Equalizer"));
79 PA_MODULE_VERSION(PACKAGE_VERSION
);
80 PA_MODULE_LOAD_ONCE(FALSE
);
81 PA_MODULE_USAGE(_("sink=<sink to connect to> "));
83 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
89 pa_sink_input
*sink_input
;
93 size_t fft_size
;//length (res) of fft
96 *effectively chooses R
98 size_t R
;/* the hop size between overlapping windows
99 * the latency of the filter, calculated from window_size
100 * based on constraints of COLA and window function
102 //for twiddling with pulseaudio
103 size_t overlap_size
;//window_size-R
104 size_t samples_gathered
;
105 size_t input_buffer_max
;
107 float *W
;//windowing function (time domain)
108 float *work_buffer
, **input
, **overlap_accum
;
109 fftwf_complex
*output_window
;
110 fftwf_plan forward_plan
, inverse_plan
;
114 float ***Hs
;//thread updatable copies of the freq response filters (magintude based)
116 pa_memchunk conv_buffer
;
117 pa_memblockq
*input_q
;
118 pa_bool_t first_iteration
;
120 pa_dbus_protocol
*dbus_protocol
;
122 pa_bool_t set_default
;
124 pa_database
*database
;
125 char **base_profiles
;
128 static const char* const valid_modargs
[] = {
142 #define SINKLIST "equalized_sinklist"
143 #define EQDB "equalizer_db"
144 #define EQ_STATE_DB "equalizer-state"
145 #define FILTER_SIZE (u->fft_size / 2 + 1)
146 #define CHANNEL_PROFILE_SIZE (FILTER_SIZE + 1)
147 #define FILTER_STATE_SIZE (CHANNEL_PROFILE_SIZE * u->channels)
148 static void dbus_init(struct userdata
*u
);
149 static void dbus_done(struct userdata
*u
);
151 static void hanning_window(float *W
, size_t window_size
){
152 //h=.5*(1-cos(2*pi*j/(window_size+1)), COLA for R=(M+1)/2
153 for(size_t i
=0; i
< window_size
;++i
){
154 W
[i
] = (float).5*(1-cos(2*M_PI
*i
/(window_size
+1)));
158 static void fix_filter(float *H
, size_t fft_size
){
159 //divide out the fft gain
160 for(size_t i
= 0; i
< fft_size
/ 2 + 1; ++i
){
165 static void interpolate(float *signal
, size_t length
, uint32_t *xs
, float *ys
, size_t n_points
){
166 //Note that xs must be monotonically increasing!
167 float x_range_lower
, x_range_upper
, c0
;
168 pa_assert_se(n_points
>=2);
169 pa_assert_se(xs
[0] == 0);
170 pa_assert_se(xs
[n_points
- 1] == length
- 1);
171 for(size_t x
= 0, x_range_lower_i
= 0; x
< length
-1; ++x
){
172 pa_assert(x_range_lower_i
< n_points
-1);
173 x_range_lower
= (float) (xs
[x_range_lower_i
]);
174 x_range_upper
= (float) (xs
[x_range_lower_i
+1]);
175 pa_assert_se(x_range_lower
< x_range_upper
);
176 pa_assert_se(x
>= x_range_lower
);
177 pa_assert_se(x
<= x_range_upper
);
178 //bilinear-interpolation of coefficients specified
179 c0
= (x
-x_range_lower
)/(x_range_upper
-x_range_lower
);
180 pa_assert_se(c0
>= 0&&c0
<= 1.0);
181 signal
[x
] = ((1.0f
- c0
) * ys
[x_range_lower_i
] + c0
* ys
[x_range_lower_i
+ 1]);
182 while(x
>= xs
[x_range_lower_i
+ 1]){
186 signal
[length
-1]=ys
[n_points
-1];
189 static int is_monotonic(const uint32_t *xs
,size_t length
){
193 for(size_t i
= 1; i
< length
; ++i
){
201 //ensure's memory allocated is a multiple of v_size
203 static void * alloc(size_t x
,size_t s
){
204 size_t f
= PA_ROUND_UP(x
*s
, sizeof(float)*v_size
);
212 static void alloc_input_buffers(struct userdata
*u
, size_t min_buffer_length
){
213 if(min_buffer_length
<= u
->input_buffer_max
){
216 pa_assert(min_buffer_length
>= u
->window_size
);
217 for(size_t c
= 0; c
< u
->channels
; ++c
){
218 float *tmp
= alloc(min_buffer_length
, sizeof(float));
220 if(!u
->first_iteration
){
221 memcpy(tmp
, u
->input
[c
], u
->overlap_size
* sizeof(float));
227 u
->input_buffer_max
= min_buffer_length
;
230 /* Called from I/O thread context */
231 static int sink_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
232 struct userdata
*u
= PA_SINK(o
)->userdata
;
236 case PA_SINK_MESSAGE_GET_LATENCY
: {
237 //size_t fs=pa_frame_size(&u->sink->sample_spec);
239 /* The sink is _put() before the sink input is, so let's
240 * make sure we don't access it in that time. Also, the
241 * sink input is first shut down, the sink second. */
242 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
243 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
)) {
244 *((pa_usec_t
*) data
) = 0;
248 *((pa_usec_t
*) data
) =
249 /* Get the latency of the master sink */
250 pa_sink_get_latency_within_thread(u
->sink_input
->sink
) +
252 /* Add the latency internal to our sink input on top */
253 pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->sink_input
->sink
->sample_spec
);
254 // pa_bytes_to_usec(u->samples_gathered * fs, &u->sink->sample_spec);
255 //+ pa_bytes_to_usec(u->latency * fs, ss)
256 //+ pa_bytes_to_usec(pa_memblockq_get_length(u->input_q), ss);
261 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
265 /* Called from main context */
266 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t state
) {
269 pa_sink_assert_ref(s
);
270 pa_assert_se(u
= s
->userdata
);
272 if (!PA_SINK_IS_LINKED(state
) ||
273 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
276 pa_sink_input_cork(u
->sink_input
, state
== PA_SINK_SUSPENDED
);
280 /* Called from I/O thread context */
281 static void sink_request_rewind_cb(pa_sink
*s
) {
284 pa_sink_assert_ref(s
);
285 pa_assert_se(u
= s
->userdata
);
287 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
288 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
291 /* Just hand this one over to the master sink */
292 pa_sink_input_request_rewind(u
->sink_input
, s
->thread_info
.rewind_nbytes
+pa_memblockq_get_length(u
->input_q
), TRUE
, FALSE
, FALSE
);
295 /* Called from I/O thread context */
296 static void sink_update_requested_latency_cb(pa_sink
*s
) {
299 pa_sink_assert_ref(s
);
300 pa_assert_se(u
= s
->userdata
);
302 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
303 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
306 /* Just hand this one over to the master sink */
307 pa_sink_input_set_requested_latency_within_thread(
309 pa_sink_get_requested_latency_within_thread(s
));
312 /* Called from main context */
313 static void sink_set_volume_cb(pa_sink
*s
) {
316 pa_sink_assert_ref(s
);
317 pa_assert_se(u
= s
->userdata
);
319 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
320 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
323 pa_sink_input_set_volume(u
->sink_input
, &s
->real_volume
, s
->save_volume
, TRUE
);
326 /* Called from main context */
327 static void sink_set_mute_cb(pa_sink
*s
) {
330 pa_sink_assert_ref(s
);
331 pa_assert_se(u
= s
->userdata
);
333 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
334 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
337 pa_sink_input_set_mute(u
->sink_input
, s
->muted
, s
->save_muted
);
341 //reference implementation
342 static void dsp_logic(
343 float * restrict dst
,//used as a temp array too, needs to be fft_length!
344 float * restrict src
,/*input data w/ overlap at start,
345 *automatically cycled in routine
347 float * restrict overlap
,
348 const float X
,//multipliar
349 const float * restrict H
,//The freq. magnitude scalers filter
350 const float * restrict W
,//The windowing function
351 fftwf_complex
* restrict output_window
,//The transformed window'd src
353 //use a linear-phase sliding STFT and overlap-add method (for each channel)
355 for(size_t j
= 0; j
< u
->window_size
; ++j
){
356 dst
[j
] = X
* W
[j
] * src
[j
];
358 //zero padd the the remaining fft window
359 memset(dst
+ u
->window_size
, 0, (u
->fft_size
- u
->window_size
) * sizeof(float));
360 //Processing is done here!
362 fftwf_execute_dft_r2c(u
->forward_plan
, dst
, output_window
);
364 for(size_t j
= 0; j
< FILTER_SIZE
; ++j
){
365 u
->output_window
[j
][0] *= H
[j
];
366 u
->output_window
[j
][1] *= H
[j
];
369 fftwf_execute_dft_c2r(u
->inverse_plan
, output_window
, dst
);
370 ////debug: tests overlaping add
371 ////and negates ALL PREVIOUS processing
372 ////yields a perfect reconstruction if COLA is held
373 //for(size_t j = 0; j < u->window_size; ++j){
374 // u->work_buffer[j] = u->W[j] * u->input[c][j];
377 //overlap add and preserve overlap component from this window (linear phase)
378 for(size_t j
= 0; j
< u
->overlap_size
; ++j
){
379 u
->work_buffer
[j
] += overlap
[j
];
380 overlap
[j
] = dst
[u
->R
+ j
];
382 ////debug: tests if basic buffering works
383 ////shouldn't modify the signal AT ALL (beyond roundoff)
384 //for(size_t j = 0; j < u->window_size;++j){
385 // u->work_buffer[j] = u->input[c][j];
388 //preseve the needed input for the next window's overlap
389 memmove(src
, src
+ u
->R
,
390 (u
->samples_gathered
- u
->R
) * sizeof(float)
394 typedef float v4sf
__attribute__ ((__aligned__(v_size
* sizeof(float))));
395 typedef union float_vector
{
401 //regardless of sse enabled, the loops in here assume
402 //16 byte aligned addresses and memory allocations divisible by v_size
403 static void dsp_logic(
404 float * restrict dst
,//used as a temp array too, needs to be fft_length!
405 float * restrict src
,/*input data w/ overlap at start,
406 *automatically cycled in routine
408 float * restrict overlap
,//The size of the overlap
409 const float X
,//multipliar
410 const float * restrict H
,//The freq. magnitude scalers filter
411 const float * restrict W
,//The windowing function
412 fftwf_complex
* restrict output_window
,//The transformed window'd src
413 struct userdata
*u
){//Collection of constants
414 const size_t overlap_size
= PA_ROUND_UP(u
->overlap_size
, v_size
);
417 //assert(u->samples_gathered >= u->R);
418 //use a linear-phase sliding STFT and overlap-add method
419 for(size_t j
= 0; j
< u
->window_size
; j
+= v_size
){
420 //dst[j] = W[j] * src[j];
421 float_vector_t
*d
= (float_vector_t
*) (dst
+ j
);
422 float_vector_t
*w
= (float_vector_t
*) (W
+ j
);
423 float_vector_t
*s
= (float_vector_t
*) (src
+ j
);
425 d
->m
= _mm_mul_ps(w
->m
, s
->m
);
427 // d->v = w->v * s->v;
430 //zero padd the the remaining fft window
431 memset(dst
+ u
->window_size
, 0, (u
->fft_size
- u
->window_size
) * sizeof(float));
433 //Processing is done here!
435 fftwf_execute_dft_r2c(u
->forward_plan
, dst
, output_window
);
436 //perform filtering - purely magnitude based
437 for(size_t j
= 0; j
< FILTER_SIZE
; j
+= v_size
/ 2){
438 //output_window[j][0]*=H[j];
439 //output_window[j][1]*=H[j];
440 float_vector_t
*d
= (float_vector_t
*)( ((float *) output_window
) + 2 * j
);
442 h
.f
[0] = h
.f
[1] = H
[j
];
443 h
.f
[2] = h
.f
[3] = H
[j
+ 1];
445 d
->m
= _mm_mul_ps(d
->m
, h
.m
);
447 // d->v = d->v * h.v;
452 fftwf_execute_dft_c2r(u
->inverse_plan
, output_window
, dst
);
454 ////debug: tests overlaping add
455 ////and negates ALL PREVIOUS processing
456 ////yields a perfect reconstruction if COLA is held
457 //for(size_t j = 0; j < u->window_size; ++j){
458 // dst[j] = W[j] * src[j];
461 //overlap add and preserve overlap component from this window (linear phase)
462 for(size_t j
= 0; j
< overlap_size
; j
+= v_size
){
463 //dst[j]+=overlap[j];
464 //overlap[j]+=dst[j+R];
465 float_vector_t
*d
= (float_vector_t
*)(dst
+ j
);
466 float_vector_t
*o
= (float_vector_t
*)(overlap
+ j
);
468 d
->m
= _mm_add_ps(d
->m
, o
->m
);
469 o
->m
= ((float_vector_t
*)(dst
+ u
->R
+ j
))->m
;
471 // d->v = d->v + o->v;
472 // o->v = ((float_vector_t*)(dst + u->R + j))->v;
475 //memcpy(overlap, dst+u->R, u->overlap_size * sizeof(float)); //overlap preserve (debug)
476 //zero out the bit beyond the real overlap so we don't add garbage next iteration
477 memset(overlap
+ u
->overlap_size
, 0, overlap_size
- u
->overlap_size
);
479 ////debug: tests if basic buffering works
480 ////shouldn't modify the signal AT ALL (beyond roundoff)
481 //for(size_t j = 0; j < u->window_size; ++j){
485 //preseve the needed input for the next window's overlap
486 memmove(src
, src
+ u
->R
,
487 (u
->samples_gathered
- u
->R
) * sizeof(float)
492 static void process_samples(struct userdata
*u
, pa_memchunk
*tchunk
){
493 size_t fs
= pa_frame_size(&(u
->sink
->sample_spec
));
497 size_t iterations
, offset
;
498 pa_assert(u
->samples_gathered
>= u
->window_size
);
499 iterations
= (u
->samples_gathered
- u
->overlap_size
) / u
->R
;
501 tchunk
->length
= iterations
* u
->R
* fs
;
502 tchunk
->memblock
= pa_memblock_new(u
->sink
->core
->mempool
, tchunk
->length
);
503 dst
= ((float*) pa_memblock_acquire(tchunk
->memblock
));
504 for(size_t iter
= 0; iter
< iterations
; ++iter
){
505 offset
= iter
* u
->R
* fs
;
506 for(size_t c
= 0;c
< u
->channels
; c
++) {
507 a_i
= pa_aupdate_read_begin(u
->a_H
[c
]);
520 pa_aupdate_read_end(u
->a_H
[c
]);
521 if(u
->first_iteration
){
522 /* The windowing function will make the audio ramped in, as a cheap fix we can
523 * undo the windowing (for non-zero window values)
525 for(size_t i
= 0; i
< u
->overlap_size
; ++i
){
526 u
->work_buffer
[i
] = u
->W
[i
] <= FLT_EPSILON
? u
->work_buffer
[i
] : u
->work_buffer
[i
] / u
->W
[i
];
529 pa_sample_clamp(PA_SAMPLE_FLOAT32NE
, (uint8_t *) (dst
+ c
) + offset
, fs
, u
->work_buffer
, sizeof(float), u
->R
);
531 if(u
->first_iteration
){
532 u
->first_iteration
= FALSE
;
534 u
->samples_gathered
-= u
->R
;
536 pa_memblock_release(tchunk
->memblock
);
539 static void input_buffer(struct userdata
*u
, pa_memchunk
*in
){
540 size_t fs
= pa_frame_size(&(u
->sink
->sample_spec
));
541 size_t samples
= in
->length
/fs
;
542 float *src
= (float*) ((uint8_t*) pa_memblock_acquire(in
->memblock
) + in
->index
);
543 pa_assert(u
->samples_gathered
+ samples
<= u
->input_buffer_max
);
544 for(size_t c
= 0; c
< u
->channels
; c
++) {
545 //buffer with an offset after the overlap from previous
548 u
->input
[c
] + u
->samples_gathered
+ samples
<= u
->input
[c
] + u
->input_buffer_max
550 pa_sample_clamp(PA_SAMPLE_FLOAT32NE
, u
->input
[c
] + u
->samples_gathered
, sizeof(float), src
+ c
, fs
, samples
);
552 u
->samples_gathered
+= samples
;
553 pa_memblock_release(in
->memblock
);
556 /* Called from I/O thread context */
557 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
559 size_t fs
, target_samples
;
560 struct timeval start
, end
;
562 pa_sink_input_assert_ref(i
);
563 pa_assert_se(u
= i
->userdata
);
566 fs
= pa_frame_size(&(u
->sink
->sample_spec
));
567 target_samples
= PA_ROUND_UP(nbytes
/ fs
, u
->R
);
568 if(u
->first_iteration
){
569 //allocate request_size
570 target_samples
= PA_MAX(target_samples
, u
->window_size
);
572 //allocate request_size + overlap
573 target_samples
+= u
->overlap_size
;
575 alloc_input_buffers(u
, target_samples
);
576 chunk
->memblock
= NULL
;
578 /* Hmm, process any rewind request that might be queued up */
579 pa_sink_process_rewind(u
->sink
, 0);
581 //pa_log_debug("start output-buffered %ld, input-buffered %ld, requested %ld",buffered_samples,u->samples_gathered,samples_requested);
582 pa_rtclock_get(&start
);
584 size_t input_remaining
= target_samples
- u
->samples_gathered
;
585 pa_assert(input_remaining
> 0);
586 while(pa_memblockq_peek(u
->input_q
, &tchunk
) < 0){
587 //pa_sink_render(u->sink, input_remaining * fs, &tchunk);
588 pa_sink_render_full(u
->sink
, input_remaining
* fs
, &tchunk
);
589 pa_assert(tchunk
.memblock
);
590 pa_memblockq_push(u
->input_q
, &tchunk
);
591 pa_memblock_unref(tchunk
.memblock
);
593 pa_assert(tchunk
.memblock
);
594 tchunk
.length
= PA_MIN(input_remaining
* fs
, tchunk
.length
);
595 pa_memblockq_drop(u
->input_q
, tchunk
.length
);
596 //pa_log_debug("asked for %ld input samples, got %ld samples",input_remaining,buffer->length/fs);
598 //pa_rtclock_get(start);
599 input_buffer(u
, &tchunk
);
600 //pa_rtclock_get(&end);
601 //pa_log_debug("Took %0.5f seconds to setup", pa_timeval_diff(end, start) / (double) PA_USEC_PER_SEC);
602 pa_memblock_unref(tchunk
.memblock
);
603 }while(u
->samples_gathered
< target_samples
);
605 pa_rtclock_get(&end
);
606 pa_log_debug("Took %0.6f seconds to get data", (double) pa_timeval_diff(&end
, &start
) / PA_USEC_PER_SEC
);
608 pa_assert(u
->fft_size
>= u
->window_size
);
609 pa_assert(u
->R
< u
->window_size
);
610 /* set the H filter */
611 pa_rtclock_get(&start
);
612 /* process a block */
613 process_samples(u
, chunk
);
614 pa_rtclock_get(&end
);
615 pa_log_debug("Took %0.6f seconds to process", (double) pa_timeval_diff(&end
, &start
) / PA_USEC_PER_SEC
);
617 pa_assert(chunk
->memblock
);
618 //pa_log_debug("gave %ld", chunk->length/fs);
619 //pa_log_debug("end pop");
623 /* Called from main context */
624 static void sink_input_volume_changed_cb(pa_sink_input
*i
) {
627 pa_sink_input_assert_ref(i
);
628 pa_assert_se(u
= i
->userdata
);
630 pa_sink_volume_changed(u
->sink
, &i
->volume
);
633 /* Called from main context */
634 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
637 pa_sink_input_assert_ref(i
);
638 pa_assert_se(u
= i
->userdata
);
640 pa_sink_mute_changed(u
->sink
, i
->muted
);
643 static void reset_filter(struct userdata
*u
){
644 size_t fs
= pa_frame_size(&u
->sink
->sample_spec
);
646 u
->samples_gathered
= 0;
647 for(size_t i
= 0; i
< u
->channels
; ++i
){
648 memset(u
->overlap_accum
[i
], 0, u
->overlap_size
* sizeof(float));
650 u
->first_iteration
= TRUE
;
651 //set buffer size to max request, no overlap copy
652 max_request
= PA_ROUND_UP(pa_sink_input_get_max_request(u
->sink_input
) / fs
, u
->R
);
653 max_request
= PA_MAX(max_request
, u
->window_size
);
654 pa_sink_set_max_request_within_thread(u
->sink
, max_request
* fs
);
657 /* Called from I/O thread context */
658 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
662 pa_log_debug("Rewind callback!");
663 pa_sink_input_assert_ref(i
);
664 pa_assert_se(u
= i
->userdata
);
666 if (u
->sink
->thread_info
.rewind_nbytes
> 0) {
669 //max_rewrite = nbytes;
670 max_rewrite
= nbytes
+ pa_memblockq_get_length(u
->input_q
);
671 //PA_MIN(pa_memblockq_get_length(u->input_q), nbytes);
672 amount
= PA_MIN(u
->sink
->thread_info
.rewind_nbytes
, max_rewrite
);
673 u
->sink
->thread_info
.rewind_nbytes
= 0;
676 //invalidate the output q
677 pa_memblockq_seek(u
->input_q
, - (int64_t) amount
, PA_SEEK_RELATIVE
, TRUE
);
678 pa_log("Resetting filter");
679 //reset_filter(u); //this is the "proper" thing to do...
683 pa_sink_process_rewind(u
->sink
, amount
);
684 pa_memblockq_rewind(u
->input_q
, nbytes
);
687 /* Called from I/O thread context */
688 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
691 pa_sink_input_assert_ref(i
);
692 pa_assert_se(u
= i
->userdata
);
694 pa_memblockq_set_maxrewind(u
->input_q
, nbytes
);
695 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
698 /* Called from I/O thread context */
699 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
702 pa_sink_input_assert_ref(i
);
703 pa_assert_se(u
= i
->userdata
);
704 //if(u->first_iteration){
707 fs
= pa_frame_size(&(u
->sink
->sample_spec
));
708 pa_sink_set_max_request_within_thread(u
->sink
, PA_ROUND_UP(nbytes
/ fs
, u
->R
) * fs
);
711 /* Called from I/O thread context */
712 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
715 pa_sink_input_assert_ref(i
);
716 pa_assert_se(u
= i
->userdata
);
718 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
721 /* Called from I/O thread context */
722 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
725 pa_sink_input_assert_ref(i
);
726 pa_assert_se(u
= i
->userdata
);
728 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
731 /* Called from I/O thread context */
732 static void sink_input_detach_cb(pa_sink_input
*i
) {
735 pa_sink_input_assert_ref(i
);
736 pa_assert_se(u
= i
->userdata
);
738 pa_sink_detach_within_thread(u
->sink
);
740 pa_sink_set_rtpoll(u
->sink
, NULL
);
743 /* Called from I/O thread context */
744 static void sink_input_attach_cb(pa_sink_input
*i
) {
746 size_t fs
, max_request
;
747 pa_sink_input_assert_ref(i
);
748 pa_assert_se(u
= i
->userdata
);
750 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
751 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
753 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
754 fs
= pa_frame_size(&u
->sink
->sample_spec
);
755 //set buffer size to max request, no overlap copy
756 max_request
= PA_ROUND_UP(pa_sink_input_get_max_request(u
->sink_input
) / fs
, u
->R
);
757 max_request
= PA_MAX(max_request
, u
->window_size
);
758 pa_sink_set_max_request_within_thread(u
->sink
, max_request
* fs
);
759 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
760 pa_sink_attach_within_thread(u
->sink
);
762 pa_log_debug("Setting default sink to %s", u
->sink
->name
);
763 pa_namereg_set_default_sink(u
->module
->core
, u
->sink
);
767 /* Called from main context */
768 static void sink_input_kill_cb(pa_sink_input
*i
) {
771 pa_sink_input_assert_ref(i
);
772 pa_assert_se(u
= i
->userdata
);
774 /* The order here matters! We first kill the sink input, followed
775 * by the sink. That means the sink callbacks must be protected
776 * against an unconnected sink input! */
777 pa_sink_input_unlink(u
->sink_input
);
778 pa_sink_unlink(u
->sink
);
780 pa_sink_input_unref(u
->sink_input
);
781 u
->sink_input
= NULL
;
783 pa_sink_unref(u
->sink
);
786 pa_module_unload_request(u
->module
, TRUE
);
789 /* Called from IO thread context */
790 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
793 pa_sink_input_assert_ref(i
);
794 pa_assert_se(u
= i
->userdata
);
796 /* If we are added for the first time, ask for a rewinding so that
797 * we are heard right-away. */
798 if (PA_SINK_INPUT_IS_LINKED(state
) &&
799 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
800 pa_log_debug("Requesting rewind due to state change.");
801 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
805 static void pack(char **strs
, size_t len
, char **packed
, size_t *length
){
807 size_t headers
= (1+len
) * sizeof(uint16_t);
809 for(size_t i
= 0; i
< len
; ++i
){
810 t_len
+= strlen(strs
[i
]);
812 *length
= headers
+ t_len
;
813 p
= *packed
= pa_xmalloc0(*length
);
814 *((uint16_t *) p
) = (uint16_t) len
;
815 p
+= sizeof(uint16_t);
816 for(size_t i
= 0; i
< len
; ++i
){
817 uint16_t l
= strlen(strs
[i
]);
818 *((uint16_t *) p
) = (uint16_t) l
;
819 p
+= sizeof(uint16_t);
820 memcpy(p
, strs
[i
], l
);
824 static void unpack(char *str
, size_t length
, char ***strs
, size_t *len
){
826 *len
= *((uint16_t *) p
);
827 p
+= sizeof(uint16_t);
828 *strs
= pa_xnew(char *, *len
);
830 for(size_t i
= 0; i
< *len
; ++i
){
831 size_t l
= *((uint16_t *) p
);
832 p
+= sizeof(uint16_t);
833 (*strs
)[i
] = pa_xnew(char, l
+ 1);
834 memcpy((*strs
)[i
], p
, l
);
835 (*strs
)[i
][l
] = '\0';
839 static void save_profile(struct userdata
*u
, size_t channel
, char *name
){
841 const size_t profile_size
= CHANNEL_PROFILE_SIZE
* sizeof(float);
842 float *H_n
, *profile
;
845 profile
= pa_xnew0(float, profile_size
);
846 a_i
= pa_aupdate_read_begin(u
->a_H
[channel
]);
847 profile
[0] = u
->Xs
[a_i
][channel
];
848 H
= u
->Hs
[channel
][a_i
];
850 for(size_t i
= 0 ; i
<= FILTER_SIZE
; ++i
){
851 H_n
[i
] = H
[i
] * u
->fft_size
;
854 pa_aupdate_read_end(u
->a_H
[channel
]);
856 key
.size
= strlen(key
.data
);
858 data
.size
= profile_size
;
859 pa_database_set(u
->database
, &key
, &data
, TRUE
);
860 pa_database_sync(u
->database
);
861 if(u
->base_profiles
[channel
]){
862 pa_xfree(u
->base_profiles
[channel
]);
864 u
->base_profiles
[channel
] = pa_xstrdup(name
);
867 static void save_state(struct userdata
*u
){
869 const size_t filter_state_size
= FILTER_STATE_SIZE
* sizeof(float);
873 pa_database
*database
;
875 char *state_name
= u
->name
;
877 size_t packed_length
;
879 pack(u
->base_profiles
, u
->channels
, &packed
, &packed_length
);
880 state
= (float *) pa_xmalloc0(filter_state_size
+ packed_length
);
881 memcpy(state
+ FILTER_STATE_SIZE
, packed
, packed_length
);
884 for(size_t c
= 0; c
< u
->channels
; ++c
){
885 a_i
= pa_aupdate_read_begin(u
->a_H
[c
]);
886 state
[c
* CHANNEL_PROFILE_SIZE
] = u
->Xs
[c
][a_i
];
888 H_n
= &state
[c
* CHANNEL_PROFILE_SIZE
+ 1];
889 memcpy(H_n
, H
, FILTER_SIZE
* sizeof(float));
890 pa_aupdate_read_end(u
->a_H
[c
]);
893 key
.data
= state_name
;
894 key
.size
= strlen(key
.data
);
896 data
.size
= filter_state_size
+ packed_length
;
897 //thread safety for 0.9.17?
898 pa_assert_se(dbname
= pa_state_path(EQ_STATE_DB
, FALSE
));
899 pa_assert_se(database
= pa_database_open(dbname
, TRUE
));
902 pa_database_set(database
, &key
, &data
, TRUE
);
903 pa_database_sync(database
);
904 pa_database_close(database
);
908 static void remove_profile(pa_core
*c
, char *name
){
910 pa_database
*database
;
912 key
.size
= strlen(key
.data
);
913 pa_assert_se(database
= pa_shared_get(c
, EQDB
));
914 pa_database_unset(database
, &key
);
915 pa_database_sync(database
);
918 static const char* load_profile(struct userdata
*u
, size_t channel
, char *name
){
921 const size_t profile_size
= CHANNEL_PROFILE_SIZE
* sizeof(float);
923 key
.size
= strlen(key
.data
);
924 if(pa_database_get(u
->database
, &key
, &value
) != NULL
){
925 if(value
.size
== profile_size
){
926 float *profile
= (float *) value
.data
;
927 a_i
= pa_aupdate_write_begin(u
->a_H
[channel
]);
928 u
->Xs
[channel
][a_i
] = profile
[0];
929 memcpy(u
->Hs
[channel
][a_i
], profile
+ 1, FILTER_SIZE
* sizeof(float));
930 fix_filter(u
->Hs
[channel
][a_i
], u
->fft_size
);
931 pa_aupdate_write_end(u
->a_H
[channel
]);
932 pa_xfree(u
->base_profiles
[channel
]);
933 u
->base_profiles
[channel
] = pa_xstrdup(name
);
935 return "incompatible size";
937 pa_datum_free(&value
);
939 return "profile doesn't exist";
944 static void load_state(struct userdata
*u
){
948 pa_database
*database
;
950 char *state_name
= u
->name
;
951 pa_assert_se(dbname
= pa_state_path(EQ_STATE_DB
, FALSE
));
952 database
= pa_database_open(dbname
, FALSE
);
955 pa_log("No resume state");
959 key
.data
= state_name
;
960 key
.size
= strlen(key
.data
);
962 if(pa_database_get(database
, &key
, &value
) != NULL
){
963 if(value
.size
> FILTER_STATE_SIZE
* sizeof(float) + sizeof(uint16_t)){
964 float *state
= (float *) value
.data
;
967 for(size_t c
= 0; c
< u
->channels
; ++c
){
968 a_i
= pa_aupdate_write_begin(u
->a_H
[c
]);
969 H
= state
+ c
* CHANNEL_PROFILE_SIZE
+ 1;
970 u
->Xs
[c
][a_i
] = state
[c
* CHANNEL_PROFILE_SIZE
];
971 memcpy(u
->Hs
[c
][a_i
], H
, FILTER_SIZE
* sizeof(float));
972 pa_aupdate_write_end(u
->a_H
[c
]);
974 unpack(((char *)value
.data
) + FILTER_STATE_SIZE
* sizeof(float), value
.size
- FILTER_STATE_SIZE
* sizeof(float), &names
, &n_profs
);
975 n_profs
= PA_MIN(n_profs
, u
->channels
);
976 for(size_t c
= 0; c
< n_profs
; ++c
){
977 pa_xfree(u
->base_profiles
[c
]);
978 u
->base_profiles
[c
] = names
[c
];
982 pa_datum_free(&value
);
984 pa_log("resume state exists but is wrong size!");
986 pa_database_close(database
);
989 /* Called from main context */
990 static pa_bool_t
sink_input_may_move_to_cb(pa_sink_input
*i
, pa_sink
*dest
) {
993 pa_sink_input_assert_ref(i
);
994 pa_assert_se(u
= i
->userdata
);
996 return u
->sink
!= dest
;
999 /* Called from main context */
1000 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1003 pa_sink_input_assert_ref(i
);
1004 pa_assert_se(u
= i
->userdata
);
1006 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
1007 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
1009 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
1012 int pa__init(pa_module
*m
) {
1019 pa_sink_input_new_data sink_input_data
;
1020 pa_sink_new_data sink_data
;
1027 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1028 pa_log("Failed to parse module arguments.");
1032 if (!(master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "master", NULL
), PA_NAMEREG_SINK
))) {
1033 pa_log("Master sink not found, trying default");
1034 master
= pa_namereg_get_default_sink(m
->core
);
1036 pa_log("no default sink found!");
1041 ss
= master
->sample_spec
;
1042 ss
.format
= PA_SAMPLE_FLOAT32
;
1043 map
= master
->channel_map
;
1044 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
1045 pa_log("Invalid sample format specification or channel map");
1048 fs
= pa_frame_size(&ss
);
1050 u
= pa_xnew0(struct userdata
, 1);
1054 u
->set_default
= TRUE
;
1055 pa_modargs_get_value_boolean(ma
, "set_default", &u
->set_default
);
1057 u
->channels
= ss
.channels
;
1058 u
->fft_size
= pow(2, ceil(log(ss
.rate
) / log(2)));//probably unstable near corner cases of powers of 2
1059 pa_log_debug("fft size: %ld", u
->fft_size
);
1060 u
->window_size
= 15999;
1061 if(u
->window_size
% 2 == 0){
1064 u
->R
= (u
->window_size
+ 1) / 2;
1065 u
->overlap_size
= u
->window_size
- u
->R
;
1066 u
->samples_gathered
= 0;
1067 u
->input_buffer_max
= 0;
1068 u
->a_H
= pa_xnew0(pa_aupdate
*, u
->channels
);
1069 u
->Xs
= pa_xnew0(float *, u
->channels
);
1070 u
->Hs
= pa_xnew0(float **, u
->channels
);
1071 for(size_t c
= 0; c
< u
->channels
; ++c
){
1072 u
->Xs
[c
] = pa_xnew0(float, 2);
1073 u
->Hs
[c
] = pa_xnew0(float *, 2);
1074 for(size_t i
= 0; i
< 2; ++i
){
1075 u
->Hs
[c
][i
] = alloc(FILTER_SIZE
, sizeof(float));
1078 u
->W
= alloc(u
->window_size
, sizeof(float));
1079 u
->work_buffer
= alloc(u
->fft_size
, sizeof(float));
1080 memset(u
->work_buffer
, 0, u
->fft_size
*sizeof(float));
1081 u
->input
= pa_xnew0(float *, u
->channels
);
1082 u
->overlap_accum
= pa_xnew0(float *, u
->channels
);
1083 for(size_t c
= 0; c
< u
->channels
; ++c
){
1084 u
->a_H
[c
] = pa_aupdate_new();
1086 u
->overlap_accum
[c
] = alloc(u
->overlap_size
, sizeof(float));
1088 u
->output_window
= alloc((FILTER_SIZE
), sizeof(fftwf_complex
));
1089 u
->forward_plan
= fftwf_plan_dft_r2c_1d(u
->fft_size
, u
->work_buffer
, u
->output_window
, FFTW_ESTIMATE
);
1090 u
->inverse_plan
= fftwf_plan_dft_c2r_1d(u
->fft_size
, u
->output_window
, u
->work_buffer
, FFTW_ESTIMATE
);
1092 hanning_window(u
->W
, u
->window_size
);
1093 u
->first_iteration
= TRUE
;
1095 u
->base_profiles
= pa_xnew0(char *, u
->channels
);
1096 for(size_t c
= 0; c
< u
->channels
; ++c
){
1097 u
->base_profiles
[c
] = pa_xstrdup("default");
1101 pa_sink_new_data_init(&sink_data
);
1102 sink_data
.driver
= __FILE__
;
1103 sink_data
.module
= m
;
1104 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1105 sink_data
.name
= pa_sprintf_malloc("%s.equalizer", master
->name
);
1106 pa_sink_new_data_set_sample_spec(&sink_data
, &ss
);
1107 pa_sink_new_data_set_channel_map(&sink_data
, &map
);
1108 z
= pa_proplist_gets(master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1109 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "FFT based equalizer on %s",z
? z
: master
->name
);
1110 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, master
->name
);
1111 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1113 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1114 pa_log("Invalid properties");
1115 pa_sink_new_data_done(&sink_data
);
1119 u
->sink
= pa_sink_new(m
->core
, &sink_data
,
1120 PA_SINK_HW_MUTE_CTRL
|PA_SINK_HW_VOLUME_CTRL
|PA_SINK_DECIBEL_VOLUME
|
1121 (master
->flags
& (PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
)));
1122 pa_sink_new_data_done(&sink_data
);
1125 pa_log("Failed to create sink.");
1128 u
->name
=pa_xstrdup(u
->sink
->name
);
1129 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1130 u
->sink
->set_state
= sink_set_state_cb
;
1131 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1132 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1133 u
->sink
->set_volume
= sink_set_volume_cb
;
1134 u
->sink
->set_mute
= sink_set_mute_cb
;
1135 u
->sink
->userdata
= u
;
1136 u
->input_q
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0, fs
, 1, 1, 0, &u
->sink
->silence
);
1138 pa_sink_set_asyncmsgq(u
->sink
, master
->asyncmsgq
);
1139 //pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->R*fs, &ss));
1141 /* Create sink input */
1142 pa_sink_input_new_data_init(&sink_input_data
);
1143 sink_input_data
.driver
= __FILE__
;
1144 sink_input_data
.module
= m
;
1145 sink_input_data
.sink
= master
;
1146 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "Equalized Stream");
1147 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1148 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &ss
);
1149 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &map
);
1151 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1152 pa_sink_input_new_data_done(&sink_input_data
);
1157 u
->sink_input
->pop
= sink_input_pop_cb
;
1158 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1159 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1160 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1161 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1162 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1163 u
->sink_input
->kill
= sink_input_kill_cb
;
1164 u
->sink_input
->attach
= sink_input_attach_cb
;
1165 u
->sink_input
->detach
= sink_input_detach_cb
;
1166 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1167 u
->sink_input
->may_move_to
= sink_input_may_move_to_cb
;
1168 u
->sink_input
->moving
= sink_input_moving_cb
;
1169 u
->sink_input
->volume_changed
= sink_input_volume_changed_cb
;
1170 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1172 u
->sink_input
->userdata
= u
;
1174 pa_sink_put(u
->sink
);
1175 pa_sink_input_put(u
->sink_input
);
1177 pa_modargs_free(ma
);
1182 //default filter to these
1183 for(size_t c
= 0; c
< u
->channels
; ++c
){
1184 a_i
= pa_aupdate_write_begin(u
->a_H
[c
]);
1186 u
->Xs
[c
][a_i
] = 1.0f
;
1187 for(size_t i
= 0; i
< FILTER_SIZE
; ++i
){
1188 H
[i
] = 1.0 / sqrtf(2.0f
);
1190 fix_filter(H
, u
->fft_size
);
1191 pa_aupdate_write_end(u
->a_H
[c
]);
1193 //load old parameters
1200 pa_modargs_free(ma
);
1208 int pa__get_n_used(pa_module
*m
) {
1212 pa_assert_se(u
= m
->userdata
);
1214 return pa_sink_linked_by(u
->sink
);
1217 void pa__done(pa_module
*m
) {
1222 if (!(u
= m
->userdata
))
1229 for(size_t c
= 0; c
< u
->channels
; ++c
){
1230 pa_xfree(u
->base_profiles
[c
]);
1232 pa_xfree(u
->base_profiles
);
1234 /* See comments in sink_input_kill_cb() above regarding
1235 * destruction order! */
1238 pa_sink_input_unlink(u
->sink_input
);
1241 pa_sink_unlink(u
->sink
);
1244 pa_sink_input_unref(u
->sink_input
);
1247 pa_sink_unref(u
->sink
);
1249 pa_memblockq_free(u
->input_q
);
1251 fftwf_destroy_plan(u
->inverse_plan
);
1252 fftwf_destroy_plan(u
->forward_plan
);
1253 pa_xfree(u
->output_window
);
1254 for(size_t c
=0; c
< u
->channels
; ++c
){
1255 pa_aupdate_free(u
->a_H
[c
]);
1256 pa_xfree(u
->overlap_accum
[c
]);
1257 pa_xfree(u
->input
[c
]);
1260 pa_xfree(u
->overlap_accum
);
1262 pa_xfree(u
->work_buffer
);
1264 for(size_t c
= 0; c
< u
->channels
; ++c
){
1266 for(size_t i
= 0; i
< 2; ++i
){
1267 pa_xfree(u
->Hs
[c
][i
]);
1280 * DBus Routines and Callbacks
1282 #define EXTNAME "org.PulseAudio.Ext.Equalizing1"
1283 #define MANAGER_PATH "/org/pulseaudio/equalizing1"
1284 #define MANAGER_IFACE EXTNAME ".Manager"
1285 #define EQUALIZER_IFACE EXTNAME ".Equalizer"
1286 static void manager_get_revision(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1287 static void manager_get_sinks(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1288 static void manager_get_profiles(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1289 static void manager_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1290 static void manager_handle_remove_profile(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1291 static void equalizer_get_revision(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1292 static void equalizer_get_sample_rate(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1293 static void equalizer_get_filter_rate(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1294 static void equalizer_get_n_coefs(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1295 static void equalizer_get_n_channels(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1296 static void equalizer_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1297 static void equalizer_handle_seed_filter(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1298 static void equalizer_handle_get_filter_points(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1299 static void equalizer_handle_get_filter(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1300 static void equalizer_handle_set_filter(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1301 static void equalizer_handle_save_profile(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1302 static void equalizer_handle_load_profile(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1303 static void equalizer_handle_save_state(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1304 static void equalizer_handle_get_profile_name(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
);
1305 enum manager_method_index
{
1306 MANAGER_METHOD_REMOVE_PROFILE
,
1310 pa_dbus_arg_info remove_profile_args
[]={
1314 static pa_dbus_method_handler manager_methods
[MANAGER_METHOD_MAX
]={
1315 [MANAGER_METHOD_REMOVE_PROFILE
]{
1316 .method_name
="RemoveProfile",
1317 .arguments
=remove_profile_args
,
1318 .n_arguments
=sizeof(remove_profile_args
)/sizeof(pa_dbus_arg_info
),
1319 .receive_cb
=manager_handle_remove_profile
}
1322 enum manager_handler_index
{
1323 MANAGER_HANDLER_REVISION
,
1324 MANAGER_HANDLER_EQUALIZED_SINKS
,
1325 MANAGER_HANDLER_PROFILES
,
1329 static pa_dbus_property_handler manager_handlers
[MANAGER_HANDLER_MAX
]={
1330 [MANAGER_HANDLER_REVISION
]={.property_name
="InterfaceRevision",.type
="u",.get_cb
=manager_get_revision
,.set_cb
=NULL
},
1331 [MANAGER_HANDLER_EQUALIZED_SINKS
]={.property_name
="EqualizedSinks",.type
="ao",.get_cb
=manager_get_sinks
,.set_cb
=NULL
},
1332 [MANAGER_HANDLER_PROFILES
]={.property_name
="Profiles",.type
="as",.get_cb
=manager_get_profiles
,.set_cb
=NULL
}
1335 pa_dbus_arg_info sink_args
[]={
1339 enum manager_signal_index
{
1340 MANAGER_SIGNAL_SINK_ADDED
,
1341 MANAGER_SIGNAL_SINK_REMOVED
,
1342 MANAGER_SIGNAL_PROFILES_CHANGED
,
1346 static pa_dbus_signal_info manager_signals
[MANAGER_SIGNAL_MAX
]={
1347 [MANAGER_SIGNAL_SINK_ADDED
]={.name
="SinkAdded", .arguments
=sink_args
, .n_arguments
=sizeof(sink_args
)/sizeof(pa_dbus_arg_info
)},
1348 [MANAGER_SIGNAL_SINK_REMOVED
]={.name
="SinkRemoved", .arguments
=sink_args
, .n_arguments
=sizeof(sink_args
)/sizeof(pa_dbus_arg_info
)},
1349 [MANAGER_SIGNAL_PROFILES_CHANGED
]={.name
="ProfilesChanged", .arguments
=NULL
, .n_arguments
=0}
1352 static pa_dbus_interface_info manager_info
={
1353 .name
=MANAGER_IFACE
,
1354 .method_handlers
=manager_methods
,
1355 .n_method_handlers
=MANAGER_METHOD_MAX
,
1356 .property_handlers
=manager_handlers
,
1357 .n_property_handlers
=MANAGER_HANDLER_MAX
,
1358 .get_all_properties_cb
=manager_get_all
,
1359 .signals
=manager_signals
,
1360 .n_signals
=MANAGER_SIGNAL_MAX
1363 enum equalizer_method_index
{
1364 EQUALIZER_METHOD_FILTER_POINTS
,
1365 EQUALIZER_METHOD_SEED_FILTER
,
1366 EQUALIZER_METHOD_SAVE_PROFILE
,
1367 EQUALIZER_METHOD_LOAD_PROFILE
,
1368 EQUALIZER_METHOD_SET_FILTER
,
1369 EQUALIZER_METHOD_GET_FILTER
,
1370 EQUALIZER_METHOD_SAVE_STATE
,
1371 EQUALIZER_METHOD_GET_PROFILE_NAME
,
1372 EQUALIZER_METHOD_MAX
1375 enum equalizer_handler_index
{
1376 EQUALIZER_HANDLER_REVISION
,
1377 EQUALIZER_HANDLER_SAMPLERATE
,
1378 EQUALIZER_HANDLER_FILTERSAMPLERATE
,
1379 EQUALIZER_HANDLER_N_COEFS
,
1380 EQUALIZER_HANDLER_N_CHANNELS
,
1381 EQUALIZER_HANDLER_MAX
1384 pa_dbus_arg_info filter_points_args
[]={
1385 {"channel", "u","in"},
1388 {"preamp", "d","out"}
1390 pa_dbus_arg_info seed_filter_args
[]={
1391 {"channel", "u","in"},
1394 {"preamp", "d","in"}
1397 pa_dbus_arg_info set_filter_args
[]={
1398 {"channel", "u","in"},
1400 {"preamp", "d","in"}
1402 pa_dbus_arg_info get_filter_args
[]={
1403 {"channel", "u","in"},
1405 {"preamp", "d","out"}
1408 pa_dbus_arg_info save_profile_args
[]={
1409 {"channel", "u","in"},
1412 pa_dbus_arg_info load_profile_args
[]={
1413 {"channel", "u","in"},
1416 pa_dbus_arg_info base_profile_name_args
[]={
1417 {"channel", "u","in"},
1421 static pa_dbus_method_handler equalizer_methods
[EQUALIZER_METHOD_MAX
]={
1422 [EQUALIZER_METHOD_SEED_FILTER
]{
1423 .method_name
="SeedFilter",
1424 .arguments
=seed_filter_args
,
1425 .n_arguments
=sizeof(seed_filter_args
)/sizeof(pa_dbus_arg_info
),
1426 .receive_cb
=equalizer_handle_seed_filter
},
1427 [EQUALIZER_METHOD_FILTER_POINTS
]{
1428 .method_name
="FilterAtPoints",
1429 .arguments
=filter_points_args
,
1430 .n_arguments
=sizeof(filter_points_args
)/sizeof(pa_dbus_arg_info
),
1431 .receive_cb
=equalizer_handle_get_filter_points
},
1432 [EQUALIZER_METHOD_SET_FILTER
]{
1433 .method_name
="SetFilter",
1434 .arguments
=set_filter_args
,
1435 .n_arguments
=sizeof(set_filter_args
)/sizeof(pa_dbus_arg_info
),
1436 .receive_cb
=equalizer_handle_set_filter
},
1437 [EQUALIZER_METHOD_GET_FILTER
]{
1438 .method_name
="GetFilter",
1439 .arguments
=get_filter_args
,
1440 .n_arguments
=sizeof(get_filter_args
)/sizeof(pa_dbus_arg_info
),
1441 .receive_cb
=equalizer_handle_get_filter
},
1442 [EQUALIZER_METHOD_SAVE_PROFILE
]{
1443 .method_name
="SaveProfile",
1444 .arguments
=save_profile_args
,
1445 .n_arguments
=sizeof(save_profile_args
)/sizeof(pa_dbus_arg_info
),
1446 .receive_cb
=equalizer_handle_save_profile
},
1447 [EQUALIZER_METHOD_LOAD_PROFILE
]{
1448 .method_name
="LoadProfile",
1449 .arguments
=load_profile_args
,
1450 .n_arguments
=sizeof(load_profile_args
)/sizeof(pa_dbus_arg_info
),
1451 .receive_cb
=equalizer_handle_load_profile
},
1452 [EQUALIZER_METHOD_SAVE_STATE
]{
1453 .method_name
="SaveState",
1456 .receive_cb
=equalizer_handle_save_state
},
1457 [EQUALIZER_METHOD_GET_PROFILE_NAME
]{
1458 .method_name
="BaseProfile",
1459 .arguments
=base_profile_name_args
,
1460 .n_arguments
=sizeof(base_profile_name_args
)/sizeof(pa_dbus_arg_info
),
1461 .receive_cb
=equalizer_handle_get_profile_name
}
1464 static pa_dbus_property_handler equalizer_handlers
[EQUALIZER_HANDLER_MAX
]={
1465 [EQUALIZER_HANDLER_REVISION
]={.property_name
="InterfaceRevision",.type
="u",.get_cb
=equalizer_get_revision
,.set_cb
=NULL
},
1466 [EQUALIZER_HANDLER_SAMPLERATE
]{.property_name
="SampleRate",.type
="u",.get_cb
=equalizer_get_sample_rate
,.set_cb
=NULL
},
1467 [EQUALIZER_HANDLER_FILTERSAMPLERATE
]{.property_name
="FilterSampleRate",.type
="u",.get_cb
=equalizer_get_filter_rate
,.set_cb
=NULL
},
1468 [EQUALIZER_HANDLER_N_COEFS
]{.property_name
="NFilterCoefficients",.type
="u",.get_cb
=equalizer_get_n_coefs
,.set_cb
=NULL
},
1469 [EQUALIZER_HANDLER_N_CHANNELS
]{.property_name
="NChannels",.type
="u",.get_cb
=equalizer_get_n_channels
,.set_cb
=NULL
},
1472 enum equalizer_signal_index
{
1473 EQUALIZER_SIGNAL_FILTER_CHANGED
,
1474 EQUALIZER_SIGNAL_SINK_RECONFIGURED
,
1475 EQUALIZER_SIGNAL_MAX
1478 static pa_dbus_signal_info equalizer_signals
[EQUALIZER_SIGNAL_MAX
]={
1479 [EQUALIZER_SIGNAL_FILTER_CHANGED
]={.name
="FilterChanged", .arguments
=NULL
, .n_arguments
=0},
1480 [EQUALIZER_SIGNAL_SINK_RECONFIGURED
]={.name
="SinkReconfigured", .arguments
=NULL
, .n_arguments
=0},
1483 static pa_dbus_interface_info equalizer_info
={
1484 .name
=EQUALIZER_IFACE
,
1485 .method_handlers
=equalizer_methods
,
1486 .n_method_handlers
=EQUALIZER_METHOD_MAX
,
1487 .property_handlers
=equalizer_handlers
,
1488 .n_property_handlers
=EQUALIZER_HANDLER_MAX
,
1489 .get_all_properties_cb
=equalizer_get_all
,
1490 .signals
=equalizer_signals
,
1491 .n_signals
=EQUALIZER_SIGNAL_MAX
1494 void dbus_init(struct userdata
*u
){
1496 DBusMessage
*signal
= NULL
;
1497 pa_idxset
*sink_list
= NULL
;
1498 u
->dbus_protocol
=pa_dbus_protocol_get(u
->sink
->core
);
1499 u
->dbus_path
=pa_sprintf_malloc("/org/pulseaudio/core1/sink%d", u
->sink
->index
);
1501 pa_dbus_protocol_add_interface(u
->dbus_protocol
, u
->dbus_path
, &equalizer_info
, u
);
1502 sink_list
= pa_shared_get(u
->sink
->core
, SINKLIST
);
1503 u
->database
= pa_shared_get(u
->sink
->core
, EQDB
);
1504 if(sink_list
== NULL
){
1506 sink_list
=pa_idxset_new(&pa_idxset_trivial_hash_func
, &pa_idxset_trivial_compare_func
);
1507 pa_shared_set(u
->sink
->core
, SINKLIST
, sink_list
);
1508 pa_assert_se(dbname
= pa_state_path("equalizer-presets", FALSE
));
1509 pa_assert_se(u
->database
= pa_database_open(dbname
, TRUE
));
1511 pa_shared_set(u
->sink
->core
, EQDB
, u
->database
);
1512 pa_dbus_protocol_add_interface(u
->dbus_protocol
, MANAGER_PATH
, &manager_info
, u
->sink
->core
);
1513 pa_dbus_protocol_register_extension(u
->dbus_protocol
, EXTNAME
);
1515 pa_idxset_put(sink_list
, u
, &dummy
);
1517 pa_assert_se((signal
= dbus_message_new_signal(MANAGER_PATH
, MANAGER_IFACE
, manager_signals
[MANAGER_SIGNAL_SINK_ADDED
].name
)));
1518 dbus_message_append_args(signal
, DBUS_TYPE_OBJECT_PATH
, &u
->dbus_path
, DBUS_TYPE_INVALID
);
1519 pa_dbus_protocol_send_signal(u
->dbus_protocol
, signal
);
1520 dbus_message_unref(signal
);
1523 void dbus_done(struct userdata
*u
){
1524 pa_idxset
*sink_list
;
1527 DBusMessage
*signal
= NULL
;
1528 pa_assert_se((signal
= dbus_message_new_signal(MANAGER_PATH
, MANAGER_IFACE
, manager_signals
[MANAGER_SIGNAL_SINK_REMOVED
].name
)));
1529 dbus_message_append_args(signal
, DBUS_TYPE_OBJECT_PATH
, &u
->dbus_path
, DBUS_TYPE_INVALID
);
1530 pa_dbus_protocol_send_signal(u
->dbus_protocol
, signal
);
1531 dbus_message_unref(signal
);
1533 pa_assert_se(sink_list
=pa_shared_get(u
->sink
->core
,SINKLIST
));
1534 pa_idxset_remove_by_data(sink_list
,u
,&dummy
);
1535 if(pa_idxset_size(sink_list
)==0){
1536 pa_dbus_protocol_unregister_extension(u
->dbus_protocol
, EXTNAME
);
1537 pa_dbus_protocol_remove_interface(u
->dbus_protocol
, MANAGER_PATH
, manager_info
.name
);
1538 pa_shared_remove(u
->sink
->core
, EQDB
);
1539 pa_database_close(u
->database
);
1540 pa_shared_remove(u
->sink
->core
, SINKLIST
);
1541 pa_xfree(sink_list
);
1543 pa_dbus_protocol_remove_interface(u
->dbus_protocol
, u
->dbus_path
, equalizer_info
.name
);
1544 pa_xfree(u
->dbus_path
);
1545 pa_dbus_protocol_unref(u
->dbus_protocol
);
1548 void manager_handle_remove_profile(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
1550 pa_core
*c
= (pa_core
*)_u
;
1551 DBusMessage
*signal
= NULL
;
1552 pa_dbus_protocol
*dbus_protocol
;
1557 dbus_error_init(&error
);
1558 if(!dbus_message_get_args(msg
, &error
,
1559 DBUS_TYPE_STRING
, &name
,
1560 DBUS_TYPE_INVALID
)){
1561 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
1562 dbus_error_free(&error
);
1565 remove_profile(c
,name
);
1566 pa_dbus_send_empty_reply(conn
, msg
);
1568 pa_assert_se((signal
= dbus_message_new_signal(MANAGER_PATH
, MANAGER_IFACE
, manager_signals
[MANAGER_SIGNAL_PROFILES_CHANGED
].name
)));
1569 dbus_protocol
= pa_dbus_protocol_get(c
);
1570 pa_dbus_protocol_send_signal(dbus_protocol
, signal
);
1571 pa_dbus_protocol_unref(dbus_protocol
);
1572 dbus_message_unref(signal
);
1575 void manager_get_revision(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
1577 pa_dbus_send_basic_value_reply(conn
, msg
, DBUS_TYPE_UINT32
, &rev
);
1580 static void get_sinks(pa_core
*u
, char ***names
, unsigned *n_sinks
){
1582 struct userdata
*sink_u
= NULL
;
1584 pa_idxset
*sink_list
;
1589 pa_assert_se(sink_list
= pa_shared_get(u
, SINKLIST
));
1590 *n_sinks
= (unsigned) pa_idxset_size(sink_list
);
1591 *names
= *n_sinks
> 0 ? pa_xnew0(char *,*n_sinks
) : NULL
;
1592 for(uint32_t i
= 0; i
< *n_sinks
; ++i
){
1593 sink_u
= (struct userdata
*) pa_idxset_iterate(sink_list
, &iter
, &dummy
);
1594 (*names
)[i
] = pa_xstrdup(sink_u
->dbus_path
);
1598 void manager_get_sinks(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
1600 char **names
= NULL
;
1605 get_sinks((pa_core
*) _u
, &names
, &n
);
1606 pa_dbus_send_basic_array_variant_reply(conn
, msg
, DBUS_TYPE_OBJECT_PATH
, names
, n
);
1607 for(unsigned i
= 0; i
< n
; ++i
){
1613 static void get_profiles(pa_core
*c
, char ***names
, unsigned *n
){
1615 pa_database
*database
;
1616 pa_datum key
, next_key
;
1617 pa_strlist
*head
=NULL
, *iter
;
1619 pa_assert_se(database
= pa_shared_get(c
, EQDB
));
1624 done
= !pa_database_first(database
, &key
, NULL
);
1627 done
= !pa_database_next(database
, &key
, &next_key
, NULL
);
1628 name
=pa_xmalloc(key
.size
+ 1);
1629 memcpy(name
, key
.data
, key
.size
);
1630 name
[key
.size
] = '\0';
1631 pa_datum_free(&key
);
1632 head
= pa_strlist_prepend(head
, name
);
1637 (*names
) = *n
> 0 ? pa_xnew0(char *, *n
) : NULL
;
1639 for(unsigned i
= 0; i
< *n
; ++i
){
1640 (*names
)[*n
- 1 - i
] = pa_xstrdup(pa_strlist_data(iter
));
1641 iter
= pa_strlist_next(iter
);
1643 pa_strlist_free(head
);
1646 void manager_get_profiles(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
1653 get_profiles((pa_core
*)_u
, &names
, &n
);
1654 pa_dbus_send_basic_array_variant_reply(conn
, msg
, DBUS_TYPE_STRING
, names
, n
);
1655 for(unsigned i
= 0; i
< n
; ++i
){
1661 void manager_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
1663 char **names
= NULL
;
1665 DBusMessage
*reply
= NULL
;
1666 DBusMessageIter msg_iter
, dict_iter
;
1670 pa_assert_se(c
= _u
);
1672 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
1673 dbus_message_iter_init_append(reply
, &msg_iter
);
1674 pa_assert_se(dbus_message_iter_open_container(&msg_iter
, DBUS_TYPE_ARRAY
, "{sv}", &dict_iter
));
1677 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, manager_handlers
[MANAGER_HANDLER_REVISION
].property_name
, DBUS_TYPE_UINT32
, &rev
);
1679 get_sinks(c
, &names
, &n
);
1680 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter
,manager_handlers
[MANAGER_HANDLER_EQUALIZED_SINKS
].property_name
, DBUS_TYPE_OBJECT_PATH
, names
, n
);
1681 for(unsigned i
= 0; i
< n
; ++i
){
1686 get_profiles(c
, &names
, &n
);
1687 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter
, manager_handlers
[MANAGER_HANDLER_PROFILES
].property_name
, DBUS_TYPE_STRING
, names
, n
);
1688 for(unsigned i
= 0; i
< n
; ++i
){
1692 pa_assert_se(dbus_message_iter_close_container(&msg_iter
, &dict_iter
));
1693 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
1694 dbus_message_unref(reply
);
1697 void equalizer_handle_seed_filter(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
1698 struct userdata
*u
=(struct userdata
*) _u
;
1700 DBusMessage
*signal
= NULL
;
1702 uint32_t *xs
, channel
, r_channel
;
1703 double *_ys
, preamp
;
1704 unsigned x_npoints
, y_npoints
, a_i
;
1706 pa_bool_t points_good
= TRUE
;
1711 dbus_error_init(&error
);
1713 if(!dbus_message_get_args(msg
, &error
,
1714 DBUS_TYPE_UINT32
, &channel
,
1715 DBUS_TYPE_ARRAY
, DBUS_TYPE_UINT32
, &xs
, &x_npoints
,
1716 DBUS_TYPE_ARRAY
, DBUS_TYPE_DOUBLE
, &_ys
, &y_npoints
,
1717 DBUS_TYPE_DOUBLE
, &preamp
,
1718 DBUS_TYPE_INVALID
)){
1719 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
1720 dbus_error_free(&error
);
1723 if(channel
> u
->channels
){
1724 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
1725 dbus_error_free(&error
);
1728 for(size_t i
= 0; i
< x_npoints
; ++i
){
1729 if(xs
[i
] >= FILTER_SIZE
){
1730 points_good
= FALSE
;
1734 if(!is_monotonic(xs
, x_npoints
) || !points_good
){
1735 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "xs must be monotonic and 0<=x<=%ld", u
->fft_size
/ 2);
1736 dbus_error_free(&error
);
1738 }else if(x_npoints
!= y_npoints
|| x_npoints
< 2 || x_npoints
> FILTER_SIZE
){
1739 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "xs and ys must be the same length and 2<=l<=%ld!", FILTER_SIZE
);
1740 dbus_error_free(&error
);
1742 }else if(xs
[0] != 0 || xs
[x_npoints
- 1] != u
->fft_size
/ 2){
1743 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "xs[0] must be 0 and xs[-1]=fft_size/2");
1744 dbus_error_free(&error
);
1748 ys
= pa_xmalloc(x_npoints
* sizeof(float));
1749 for(uint32_t i
= 0; i
< x_npoints
; ++i
){
1750 ys
[i
] = (float) _ys
[i
];
1752 r_channel
= channel
== u
->channels
? 0 : channel
;
1753 a_i
= pa_aupdate_write_begin(u
->a_H
[r_channel
]);
1754 H
= u
->Hs
[r_channel
][a_i
];
1755 u
->Xs
[r_channel
][a_i
] = preamp
;
1756 interpolate(H
, FILTER_SIZE
, xs
, ys
, x_npoints
);
1757 fix_filter(H
, u
->fft_size
);
1758 if(channel
== u
->channels
){
1759 for(size_t c
= 1; c
< u
->channels
; ++c
){
1760 unsigned b_i
= pa_aupdate_write_begin(u
->a_H
[c
]);
1761 float *H_p
= u
->Hs
[c
][b_i
];
1762 u
->Xs
[c
][b_i
] = preamp
;
1763 memcpy(H_p
, H
, FILTER_SIZE
* sizeof(float));
1764 pa_aupdate_write_end(u
->a_H
[c
]);
1767 pa_aupdate_write_end(u
->a_H
[r_channel
]);
1771 pa_dbus_send_empty_reply(conn
, msg
);
1773 pa_assert_se((signal
= dbus_message_new_signal(u
->dbus_path
, EQUALIZER_IFACE
, equalizer_signals
[EQUALIZER_SIGNAL_FILTER_CHANGED
].name
)));
1774 pa_dbus_protocol_send_signal(u
->dbus_protocol
, signal
);
1775 dbus_message_unref(signal
);
1778 void equalizer_handle_get_filter_points(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
1779 struct userdata
*u
= (struct userdata
*) _u
;
1780 uint32_t *xs
, channel
, r_channel
;
1782 unsigned x_npoints
, a_i
;
1784 pa_bool_t points_good
=TRUE
;
1785 DBusMessage
*reply
= NULL
;
1786 DBusMessageIter msg_iter
;
1793 dbus_error_init(&error
);
1794 if(!dbus_message_get_args(msg
, &error
,
1795 DBUS_TYPE_UINT32
, &channel
,
1796 DBUS_TYPE_ARRAY
, DBUS_TYPE_UINT32
, &xs
, &x_npoints
,
1797 DBUS_TYPE_INVALID
)){
1798 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
1799 dbus_error_free(&error
);
1802 if(channel
> u
->channels
){
1803 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
1804 dbus_error_free(&error
);
1808 for(size_t i
= 0; i
< x_npoints
; ++i
){
1809 if(xs
[i
] >= FILTER_SIZE
){
1815 if(x_npoints
> FILTER_SIZE
|| !points_good
){
1816 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "xs indices/length must be <= %ld!", FILTER_SIZE
);
1817 dbus_error_free(&error
);
1821 r_channel
= channel
== u
->channels
? 0 : channel
;
1822 ys
= pa_xmalloc(x_npoints
* sizeof(double));
1823 a_i
= pa_aupdate_read_begin(u
->a_H
[r_channel
]);
1824 H
= u
->Hs
[r_channel
][a_i
];
1825 preamp
= u
->Xs
[r_channel
][a_i
];
1826 for(uint32_t i
= 0; i
< x_npoints
; ++i
){
1827 ys
[i
] = H
[xs
[i
]] * u
->fft_size
;
1829 pa_aupdate_read_end(u
->a_H
[r_channel
]);
1831 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
1832 dbus_message_iter_init_append(reply
, &msg_iter
);
1834 pa_dbus_append_basic_array(&msg_iter
, DBUS_TYPE_DOUBLE
, ys
, x_npoints
);
1835 pa_dbus_append_basic_variant(&msg_iter
, DBUS_TYPE_DOUBLE
, &preamp
);
1837 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
1838 dbus_message_unref(reply
);
1842 static void get_filter(struct userdata
*u
, size_t channel
, double **H_
, double *preamp
){
1845 size_t r_channel
= channel
== u
->channels
? 0 : channel
;
1846 *H_
= pa_xnew0(double, FILTER_SIZE
);
1847 a_i
= pa_aupdate_read_begin(u
->a_H
[r_channel
]);
1848 H
= u
->Hs
[r_channel
][a_i
];
1849 for(size_t i
= 0;i
< FILTER_SIZE
; ++i
){
1850 (*H_
)[i
] = H
[i
] * u
->fft_size
;
1852 *preamp
= u
->Xs
[r_channel
][a_i
];
1854 pa_aupdate_read_end(u
->a_H
[r_channel
]);
1857 void equalizer_handle_get_filter(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
1862 DBusMessage
*reply
= NULL
;
1863 DBusMessageIter msg_iter
;
1865 pa_assert_se(u
= (struct userdata
*) _u
);
1869 dbus_error_init(&error
);
1870 if(!dbus_message_get_args(msg
, &error
,
1871 DBUS_TYPE_UINT32
, &channel
,
1872 DBUS_TYPE_INVALID
)){
1873 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
1874 dbus_error_free(&error
);
1877 if(channel
> u
->channels
){
1878 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
1879 dbus_error_free(&error
);
1883 n_coefs
= CHANNEL_PROFILE_SIZE
;
1886 get_filter(u
, channel
, &H_
, &preamp
);
1887 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
1888 dbus_message_iter_init_append(reply
, &msg_iter
);
1890 pa_dbus_append_basic_array(&msg_iter
, DBUS_TYPE_DOUBLE
, H_
, n_coefs
);
1891 pa_dbus_append_basic_variant(&msg_iter
, DBUS_TYPE_DOUBLE
, &preamp
);
1893 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
1894 dbus_message_unref(reply
);
1898 static void set_filter(struct userdata
*u
, size_t channel
, double *H_
, double preamp
){
1900 size_t r_channel
= channel
== u
->channels
? 0 : channel
;
1903 a_i
= pa_aupdate_write_begin(u
->a_H
[r_channel
]);
1904 u
->Xs
[r_channel
][a_i
] = (float) preamp
;
1905 H
= u
->Hs
[r_channel
][a_i
];
1906 for(size_t i
= 0; i
< FILTER_SIZE
; ++i
){
1907 H
[i
] = (float) H_
[i
];
1909 fix_filter(H
, u
->fft_size
);
1910 if(channel
== u
->channels
){
1911 for(size_t c
= 1; c
< u
->channels
; ++c
){
1912 unsigned b_i
= pa_aupdate_write_begin(u
->a_H
[c
]);
1913 u
->Xs
[c
][b_i
] = u
->Xs
[r_channel
][a_i
];
1914 memcpy(u
->Hs
[c
][b_i
], u
->Hs
[r_channel
][a_i
], FILTER_SIZE
* sizeof(float));
1915 pa_aupdate_write_end(u
->a_H
[c
]);
1918 pa_aupdate_write_end(u
->a_H
[r_channel
]);
1921 void equalizer_handle_set_filter(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
1926 DBusMessage
*signal
= NULL
;
1928 pa_assert_se(u
= (struct userdata
*) _u
);
1932 dbus_error_init(&error
);
1933 if(!dbus_message_get_args(msg
, &error
,
1934 DBUS_TYPE_UINT32
, &channel
,
1935 DBUS_TYPE_ARRAY
, DBUS_TYPE_DOUBLE
, &H
, &_n_coefs
,
1936 DBUS_TYPE_DOUBLE
, &preamp
,
1937 DBUS_TYPE_INVALID
)){
1938 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
1939 dbus_error_free(&error
);
1942 if(channel
> u
->channels
){
1943 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
1944 dbus_error_free(&error
);
1947 if(_n_coefs
!= FILTER_SIZE
){
1948 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "This filter takes exactly %ld coefficients, you gave %d", FILTER_SIZE
, _n_coefs
);
1951 set_filter(u
, channel
, H
, preamp
);
1953 pa_dbus_send_empty_reply(conn
, msg
);
1955 pa_assert_se((signal
= dbus_message_new_signal(u
->dbus_path
, EQUALIZER_IFACE
, equalizer_signals
[EQUALIZER_SIGNAL_FILTER_CHANGED
].name
)));
1956 pa_dbus_protocol_send_signal(u
->dbus_protocol
, signal
);
1957 dbus_message_unref(signal
);
1960 void equalizer_handle_save_profile(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
1961 struct userdata
*u
= (struct userdata
*) _u
;
1963 uint32_t channel
, r_channel
;
1964 DBusMessage
*signal
= NULL
;
1969 dbus_error_init(&error
);
1971 if(!dbus_message_get_args(msg
, &error
,
1972 DBUS_TYPE_UINT32
, &channel
,
1973 DBUS_TYPE_STRING
, &name
,
1974 DBUS_TYPE_INVALID
)){
1975 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
1976 dbus_error_free(&error
);
1979 if(channel
> u
->channels
){
1980 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
1981 dbus_error_free(&error
);
1984 r_channel
= channel
== u
->channels
? 0 : channel
;
1985 save_profile(u
, r_channel
, name
);
1986 pa_dbus_send_empty_reply(conn
, msg
);
1988 pa_assert_se((signal
= dbus_message_new_signal(MANAGER_PATH
, MANAGER_IFACE
, manager_signals
[MANAGER_SIGNAL_PROFILES_CHANGED
].name
)));
1989 pa_dbus_protocol_send_signal(u
->dbus_protocol
, signal
);
1990 dbus_message_unref(signal
);
1993 void equalizer_handle_load_profile(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
1994 struct userdata
*u
= (struct userdata
*) _u
;
1997 uint32_t channel
, r_channel
;
1998 const char *err_msg
= NULL
;
1999 DBusMessage
*signal
= NULL
;
2004 dbus_error_init(&error
);
2006 if(!dbus_message_get_args(msg
, &error
,
2007 DBUS_TYPE_UINT32
, &channel
,
2008 DBUS_TYPE_STRING
, &name
,
2009 DBUS_TYPE_INVALID
)){
2010 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
2011 dbus_error_free(&error
);
2014 if(channel
> u
->channels
){
2015 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
2016 dbus_error_free(&error
);
2019 r_channel
= channel
== u
->channels
? 0 : channel
;
2021 err_msg
= load_profile(u
, r_channel
, name
);
2022 if(err_msg
!= NULL
){
2023 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_FAILED
, "error loading profile %s: %s", name
, err_msg
);
2024 dbus_error_free(&error
);
2027 if(channel
== u
->channels
){
2028 for(uint32_t c
= 1; c
< u
->channels
; ++c
){
2029 load_profile(u
, c
, name
);
2032 pa_dbus_send_empty_reply(conn
, msg
);
2034 pa_assert_se((signal
= dbus_message_new_signal(u
->dbus_path
, EQUALIZER_IFACE
, equalizer_signals
[EQUALIZER_SIGNAL_FILTER_CHANGED
].name
)));
2035 pa_dbus_protocol_send_signal(u
->dbus_protocol
, signal
);
2036 dbus_message_unref(signal
);
2039 void equalizer_handle_save_state(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
2040 struct userdata
*u
= (struct userdata
*) _u
;
2046 pa_dbus_send_empty_reply(conn
, msg
);
2049 void equalizer_handle_get_profile_name(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2050 struct userdata
*u
= (struct userdata
*) _u
;
2052 uint32_t channel
, r_channel
;
2057 dbus_error_init(&error
);
2059 if(!dbus_message_get_args(msg
, &error
,
2060 DBUS_TYPE_UINT32
, &channel
,
2061 DBUS_TYPE_INVALID
)){
2062 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
2063 dbus_error_free(&error
);
2066 if(channel
> u
->channels
){
2067 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "invalid channel: %d", channel
);
2068 dbus_error_free(&error
);
2071 r_channel
= channel
== u
->channels
? 0 : channel
;
2072 pa_assert(u
->base_profiles
[r_channel
]);
2073 pa_dbus_send_basic_value_reply(conn
,msg
, DBUS_TYPE_STRING
, &u
->base_profiles
[r_channel
]);
2076 void equalizer_get_revision(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2078 pa_dbus_send_basic_value_reply(conn
, msg
, DBUS_TYPE_UINT32
, &rev
);
2081 void equalizer_get_n_channels(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2084 pa_assert_se(u
= (struct userdata
*) _u
);
2088 channels
= (uint32_t) u
->channels
;
2089 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &channels
);
2092 void equalizer_get_n_coefs(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2095 pa_assert_se(u
= (struct userdata
*) _u
);
2099 n_coefs
= (uint32_t) CHANNEL_PROFILE_SIZE
;
2100 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &n_coefs
);
2103 void equalizer_get_sample_rate(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2106 pa_assert_se(u
= (struct userdata
*) _u
);
2110 rate
= (uint32_t) u
->sink
->sample_spec
.rate
;
2111 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &rate
);
2114 void equalizer_get_filter_rate(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2117 pa_assert_se(u
= (struct userdata
*) _u
);
2121 fft_size
= (uint32_t) u
->fft_size
;
2122 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &fft_size
);
2125 void equalizer_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
){
2127 DBusMessage
*reply
= NULL
;
2128 DBusMessageIter msg_iter
, dict_iter
;
2129 uint32_t rev
, n_coefs
, rate
, fft_size
, channels
;
2130 pa_assert_se(u
= (struct userdata
*) _u
);
2134 n_coefs
= (uint32_t) CHANNEL_PROFILE_SIZE
;
2135 rate
= (uint32_t) u
->sink
->sample_spec
.rate
;
2136 fft_size
= (uint32_t) u
->fft_size
;
2137 channels
= (uint32_t) u
->channels
;
2139 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
2140 dbus_message_iter_init_append(reply
, &msg_iter
);
2141 pa_assert_se(dbus_message_iter_open_container(&msg_iter
, DBUS_TYPE_ARRAY
, "{sv}", &dict_iter
));
2143 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, equalizer_handlers
[EQUALIZER_HANDLER_REVISION
].property_name
, DBUS_TYPE_UINT32
, &rev
);
2144 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, equalizer_handlers
[EQUALIZER_HANDLER_SAMPLERATE
].property_name
, DBUS_TYPE_UINT32
, &rate
);
2145 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, equalizer_handlers
[EQUALIZER_HANDLER_FILTERSAMPLERATE
].property_name
, DBUS_TYPE_UINT32
, &fft_size
);
2146 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, equalizer_handlers
[EQUALIZER_HANDLER_N_COEFS
].property_name
, DBUS_TYPE_UINT32
, &n_coefs
);
2147 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, equalizer_handlers
[EQUALIZER_HANDLER_N_CHANNELS
].property_name
, DBUS_TYPE_UINT32
, &channels
);
2149 pa_assert_se(dbus_message_iter_close_container(&msg_iter
, &dict_iter
));
2150 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
2151 dbus_message_unref(reply
);