echo.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef struct echo_cancellation	echo_cancellation_t

Functions
struct audio_frame *	echo_cancel (struct echo_cancellation *state, struct audio_frame *frame)
void	echo_cancellation_destroy (struct echo_cancellation *state)
struct echo_cancellation *	echo_cancellation_init (void)
void	echo_play (struct echo_cancellation *state, struct audio_frame *frame)

Typedef Documentation

echo_cancellation_t

typedef struct echo_cancellation echo_cancellation_t

Definition at line 59 of file echo.h.

Function Documentation

echo_cancel()

struct audio_frame * echo_cancel	(	struct echo_cancellation *	state,
		struct audio_frame *	frame )

Definition at line 235 of file echo.cpp.

{
        struct audio_frame *res;
 
        std::lock_guard lk(s->lock);
 
        if(frame->ch_count != 1) {
                static int prints = 0;
                if(prints++ % 100 == 0)
                        error_msg(MOD_NAME "Echo cancellation needs 1 captured channel. Disabling echo cancellation.\n"
                                        "Use '--audio-capture-channels 1' parameter to capture single channel.\n");
                return frame;
        }
 
 
        if(frame->sample_rate != s->frame.sample_rate ||
                        frame->bps != s->frame.bps) {
                reconfigure_echo(s, frame->sample_rate, frame->bps);
        }
 
 
        size_t in_frame_samples = frame->data_len / frame->bps;
 
        size_t ringbuf_free_samples = ring_get_available_write_size(s->near_end_ringbuf.get()) / 2;
        if(in_frame_samples > ringbuf_free_samples){
                in_frame_samples = ringbuf_free_samples;
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Near end ringbuf overflow\n");
        }
 
        if(s->next_expected_near < steady_clock::now()){
                /* It is possible that the capture thread starts late or
                 * freezes, which could create an unwanted delay between far
                 * and near ends.  To partialy protect against this, drop the
                 * contents of far end buffer, when the last frame arrived more
                 * than 1s ago.
                 */
                auto diff = steady_clock::now() - s->next_expected_near;
                long long delay = std::chrono::duration_cast<std::chrono::microseconds>(diff).count();
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Near samples late by %lldus\n", delay);
 
                int current = ring_get_current_size(s->far_end_ringbuf.get());
                //drop only whole frames
                current = (current / SAMPLES_PER_FRAME) * SAMPLES_PER_FRAME;
                ring_advance_read_idx(s->far_end_ringbuf.get(), current);
        }
        s->next_expected_near = steady_clock::now() + std::chrono::seconds(1);
 
        if(frame->bps != 2){
                //Need to change bps, put whole incoming frame into ringbuf
                void *ptr1;
                int size1;
                void *ptr2;
                int size2;
                ring_get_write_regions(s->near_end_ringbuf.get(), in_frame_samples * 2,
                                &ptr1, &size1, &ptr2, &size2);
 
                int in_bytes1 = (size1 / 2) * frame->bps;
                change_bps(static_cast<char *>(ptr1), 2, frame->data, frame->bps, in_bytes1);
                if(ptr2){
                        change_bps(static_cast<char *>(ptr2), 2, frame->data + in_bytes1, frame->bps, frame->data_len - in_bytes1);
                }
                ring_advance_write_idx(s->near_end_ringbuf.get(), in_frame_samples * 2);
        } else {
                ring_buffer_write(s->near_end_ringbuf.get(), frame->data, frame->data_len);
        }
 
        size_t near_end_samples = ring_get_current_size(s->near_end_ringbuf.get()) / 2;
        size_t far_end_samples = ring_get_current_size(s->far_end_ringbuf.get()) / 2;
 
        if(far_end_samples < near_end_samples){
                log_msg(LOG_LEVEL_INFO, MOD_NAME "Not enough far end samples (%zu near, %zu far)\n", near_end_samples, far_end_samples);
 
                //The delay between far end and near end will always be at least
                //recorded frame length
                s->prefill = in_frame_samples + s->requested_delay;
        }
 
        size_t frames_to_process = near_end_samples / SAMPLES_PER_FRAME;
        if(!frames_to_process){
                return NULL;
        }
 
        size_t out_size = frames_to_process * SAMPLES_PER_FRAME * 2;
        assert(static_cast<size_t>(s->frame.max_size) >= out_size);
        s->frame.data_len = out_size;
        res = &s->frame;
 
        spx_int16_t *out_ptr = (spx_int16_t *)(void *) s->frame.data;
        for(size_t i = 0; i < frames_to_process; i++){
                spx_int16_t near_arr[SAMPLES_PER_FRAME];
                spx_int16_t far_arr[SAMPLES_PER_FRAME];
 
                const void *export_channels[] = {near_arr, far_arr, out_ptr, nullptr};
                if(far_end_samples >= SAMPLES_PER_FRAME){
                        ring_buffer_read(s->far_end_ringbuf.get(), reinterpret_cast<char *>(far_arr), SAMPLES_PER_FRAME * 2);
                        ring_buffer_read(s->near_end_ringbuf.get(), reinterpret_cast<char *>(near_arr), SAMPLES_PER_FRAME * 2);
 
                        speex_echo_cancellation(s->echo_state.get(), near_arr, far_arr, out_ptr); 
                        far_end_samples -= SAMPLES_PER_FRAME;
 
                } else {
                        ring_buffer_read(s->near_end_ringbuf.get(), reinterpret_cast<char *>(out_ptr), SAMPLES_PER_FRAME * 2);
                        export_channels[0] = out_ptr;
                        export_channels[1] = out_ptr;
                        export_channels[2] = out_ptr;
                }
 
                if(s->exporter){
                        audio_export_raw_ch(s->exporter.get(), export_channels, SAMPLES_PER_FRAME);
                }
 
                out_ptr += SAMPLES_PER_FRAME;
        }
 
        return res;
}

References audio_export_raw_ch(), audio_frame::bps, change_bps(), audio_frame::data, audio_frame::data_len, echo_cancellation::echo_state, error_msg, echo_cancellation::exporter, echo_cancellation::far_end_ringbuf, echo_cancellation::frame, frame, echo_cancellation::lock, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), audio_frame::max_size, MOD_NAME, echo_cancellation::near_end_ringbuf, echo_cancellation::next_expected_near, echo_cancellation::prefill, reconfigure_echo(), echo_cancellation::requested_delay, ring_advance_read_idx(), ring_advance_write_idx(), ring_buffer_read(), ring_buffer_write(), ring_get_available_write_size(), ring_get_current_size(), ring_get_write_regions(), audio_frame::sample_rate, and SAMPLES_PER_FRAME.

Referenced by audio_sender_thread().

Here is the call graph for this function:

echo_cancellation_destroy()

void echo_cancellation_destroy

(

struct echo_cancellation *

state

)

Definition at line 174 of file echo.cpp.

{
        delete s;
}

echo_cancellation_init()

struct echo_cancellation * echo_cancellation_init

(

void

)

Definition at line 132 of file echo.cpp.

{
        struct echo_cancellation *s = new echo_cancellation();
 
        int filter_length = DEFAULT_FILTER_LENGTH;
        if(const char *param = get_commandline_param("echo-cancel-filter-length"); param != nullptr){
                char *end;
                int len = strtol(param, &end, 10);
                if(end != param)
                        filter_length = len;
        }
 
        if(const char *param = get_commandline_param("echo-cancel-delay"); param != nullptr){
                char *end;
                int len = strtol(param, &end, 10);
                if(end != param)
                        s->requested_delay = len;
        }
 
        s->echo_state.reset(speex_echo_state_init(SAMPLES_PER_FRAME, filter_length));
 
        s->frame.data = NULL;
        s->frame.sample_rate = s->frame.bps = 0;
 
        const int ringbuf_sample_count = 2 << 15; //should be divisable by SAMPLES_PER_FRAME
        constexpr int bps = 2; //TODO: assuming bps to be 2
 
        s->far_end_ringbuf.reset(ring_buffer_init(ringbuf_sample_count * bps));
        s->near_end_ringbuf.reset(ring_buffer_init(ringbuf_sample_count * bps));
 
        s->frame_data = std::make_unique<spx_int16_t[]>(ringbuf_sample_count);
        s->frame.data = reinterpret_cast<char *>(s->frame_data.get());
        s->frame.max_size = ringbuf_sample_count * sizeof(s->frame_data[0]);
        static_assert(sizeof(s->frame_data[0]) == bps);
 
        log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Echo cancellation initialized with filter length %d samples.\n", filter_length);
 
        s->prefill = 0;
 
        return s;
}

References audio_frame::bps, audio_frame::data, DEFAULT_FILTER_LENGTH, echo_cancellation::echo_state, echo_cancellation::far_end_ringbuf, echo_cancellation::frame, echo_cancellation::frame_data, get_commandline_param(), len, LOG_LEVEL_NOTICE, log_msg(), audio_frame::max_size, MOD_NAME, echo_cancellation::near_end_ringbuf, param, echo_cancellation::prefill, echo_cancellation::requested_delay, ring_buffer_init(), audio_frame::sample_rate, and SAMPLES_PER_FRAME.

Referenced by audio_init().

Here is the call graph for this function:

echo_play()

void echo_play	(	struct echo_cancellation *	state,
		struct audio_frame *	frame )

Definition at line 179 of file echo.cpp.

{
        std::lock_guard lk(s->lock);
 
        if(frame->ch_count != 1) {
                static int prints = 0;
                if(prints++ % 100 == 0) {
                        error_msg(MOD_NAME "Echo cancellation needs 1 played channel. Disabling echo cancellation.\n"
                                        "Use channel mapping and let only one channel played to enable this feature.\n");
                }
                return;
        }
 
        if(s->prefill){
                int target = std::max(SAMPLES_PER_FRAME, (s->prefill / SAMPLES_PER_FRAME) * SAMPLES_PER_FRAME);
                int current = ring_get_current_size(s->far_end_ringbuf.get());
                //buffer can contain small remainder (<SAMPLES_PER_FRAME)
                int to_fill = target - current;
                s->prefill = 0;
                if(to_fill < 0){
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "Pre fill requested to %d, but the buffer is already %d!\n", target, current);
                } else {
                        ring_advance_write_idx(s->far_end_ringbuf.get(), to_fill);
                        log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Pre filling far end with %d samples\n", to_fill);
                }
        }
 
        size_t samples = frame->data_len / frame->bps;
        size_t ringbuf_free_samples = ring_get_available_write_size(s->far_end_ringbuf.get()) / 2;
 
        if(samples > ringbuf_free_samples){
                samples = ringbuf_free_samples;
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Far end ringbuf overflow!\n");
        }
 
        if(frame->bps != 2) {
                void *ptr1;
                int size1;
                void *ptr2;
                int size2;
                ring_get_write_regions(s->far_end_ringbuf.get(), samples * 2,
                                &ptr1, &size1, &ptr2, &size2);
 
                assert(size1 % 2 == 0);
                int in_bytes1 = (size1 / 2) * frame->bps;
                change_bps(static_cast<char *>(ptr1), 2, frame->data, frame->bps, in_bytes1);
                if(ptr2){
                        change_bps(static_cast<char *>(ptr2), 2, frame->data + in_bytes1, frame->bps, frame->data_len - in_bytes1);
                }
 
                ring_advance_write_idx(s->far_end_ringbuf.get(), samples * 2);
        } else {
                ring_buffer_write(s->far_end_ringbuf.get(), frame->data, samples * 2);
        }
}

References change_bps(), error_msg, echo_cancellation::far_end_ringbuf, frame, echo_cancellation::lock, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, echo_cancellation::prefill, ring_advance_write_idx(), ring_buffer_write(), ring_get_available_write_size(), ring_get_current_size(), ring_get_write_regions(), and SAMPLES_PER_FRAME.

Referenced by audio_receiver_thread().

Here is the call graph for this function: