void
pseudo_tcp_channel_free(PseudoTcpChannel *tcp) {
signal_free(tcp->on_connected);
signal_free(tcp->on_data_received);
// TODO: how to free pseudo_tcp?
free(tcp);
}
void
config_free (struct config *config)
{
struct mbox *mbox = config->mailboxes, *mbox_o;
while (mbox) {
mbox_o = mbox;
mbox = mbox->next;
mbox_free (mbox_o);
}
struct signal *signal = config->signals, *signal_o;
while (signal) {
signal_o = signal;
signal = signal->next;
signal_free (signal_o);
}
free (config_filename);
config_filename = NULL;
free (config);
}
void PICLANG_next()
{
picos_size_t command;
picos_size_t a,b,c;// parameters, can be shared
picos_signed_t siga;// a, but signed.
signed char sch1;// signed char parameters
char ch1;// char parameter
static bit flag1;
extern char ARG_buffer[ARG_SIZE];
if(curr_process.page_size == 0)
return;
if(picos_processes[picos_curr_process].expires == 0)
{
if((curr_process.bitmap & PICLANG_BLOCKING_CALL) == 0 || PICLANG_debug == true)// Check for blocking call
{
PICLANG_save(PICLANG_SUSPENDED);
return;
}
}
if(picos_processes[picos_curr_process].signal_sent != PICOS_NUM_SIGNALS)
{
if(signal_valid_id(picos_processes[picos_curr_process].signal_sent) == false)
{
PICLANG_exception(THREAD_INVALID_SIGNAL);
return;
}
curr_process.pc = signals[picos_processes[picos_curr_process].signal_sent].sig_action_addr;
signal_free(picos_processes[picos_curr_process].signal_sent);
picos_processes[picos_curr_process].signal_sent = PICOS_NUM_SIGNALS;
}
command = PICLANG_get_next_word();
if(curr_process.status != PICLANG_SUCCESS)
return;
if(PICLANG_debug == true)
PICLANG_debug_out(command);
switch(command)
{
case PICLANG_UMINUS:
{
picos_signed_t inv = (picos_signed_t)PICLANG_pop();
PICLANG_pushl(-inv);
break;
}
case PICLANG_ADD:
PICLANG_pushl(PICLANG_pop() + PICLANG_pop());
PICLANG_update_arith_status();
break;
case PICLANG_MOD:case PICLANG_DIV:
{
// a/b --> c rem a
b = PICLANG_pop();
a = PICLANG_pop();
c = 0;
while(a >= b)
{
a -= b;
c++;
}
if(command == PICLANG_MOD)
PICLANG_pushl(a);
else
PICLANG_pushl(c);
PICLANG_update_arith_status();
break;
}
case PICLANG_SUB:
{
b = PICLANG_pop();
a = PICLANG_pop();
PICLANG_pushl(a - b);
PICLANG_update_arith_status();
break;
}
case PICLANG_MULT:
a = PICLANG_pop();
b = PICLANG_pop();
c = a*b;
PICLANG_pushl(c);
PICLANG_update_arith_status();
break;
case PICLANG_PUSHL:
a = PICLANG_get_next_word();
PICLANG_pushl(a);
break;
case PICLANG_PUSH:
{
a = PICLANG_get_next_word();
b = PAGE_get(a,picos_curr_process);
if(error_code != SUCCESS)
PICLANG_exception(error_code);
else
PICLANG_pushl(b);
break;
}
case PICLANG_DROP:
PICLANG_pop();
break;
case PICLANG_SWAP:
a = PICLANG_pop();
b = PICLANG_pop();
PICLANG_pushl(a);
PICLANG_pushl(b);
break;
case PICLANG_POP:
{
a = PICLANG_get_next_word();
b = PICLANG_pop();
PAGE_set(a,b,picos_curr_process);
break;
}
case PICLANG_ARGC:
PICLANG_pushl(picos_processes[picos_curr_process].nargs);
break;
case PICLANG_ARGV:
{
a = PICLANG_pop();
sch1 = ARG_get(a);
if(sch1 < 0)
{
PICLANG_exception(PICLANG_INVALID_PARAMETER);
break;
}
b = (picos_size_t)sch1;
PICLANG_pushl(b);
break;
}
case PICLANG_PRINT:
{
a = PICLANG_pop();
putch(a);
IO_flush();
break;
}
case PICLANG_DEREF:
{
a = PICLANG_pop();// array index
b = PICLANG_pop();// array starting address
PICLANG_next_dereference(b+a,command);
break;
}
case PICLANG_BSL: case PICLANG_BSR:// bit shifts
{
a /*shift_amount*/ = PICLANG_pop();
b /*val*/ = PICLANG_pop();
if(command == PICLANG_BSL)
b <<= a;
else
b >>= a;
PICLANG_pushl(b);
PICLANG_update_arith_status();
break;
}
case PICLANG_FPUTD:
{
char hex_val[PICOS_SIZE_T_DECIMAL_DIGITS];//ch1 = index
dec_to_word(hex_val,PICLANG_pop());
ch1 = 0;
flag1 = false;
for(;ch1 < 5;ch1++)
{
if(flag1 == true || hex_val[ch1] != 0x30)
{
SRAM_write(SRAM_PICLANG_RAW_FILE_BUFFER+PICLANG_file_buffer_index++,&hex_val[ch1],sizeof(char));
flag1 = true;
}
if(PICLANG_file_buffer_index >= FS_BUFFER_SIZE)
{
picfs_dump(picos_processes[picos_curr_process].program_file);
SRAM_write(SRAM_PICLANG_NEXT_SWAP_ADDR,(void*)picfs_buffer,FS_BUFFER_SIZE);
memset((char*)picfs_buffer,0,FS_BUFFER_SIZE);
SRAM_write(SRAM_PICLANG_RAW_FILE_BUFFER,(void*)picfs_buffer,FS_BUFFER_SIZE);
SRAM_read(SRAM_PICLANG_NEXT_SWAP_ADDR,(void*)picfs_buffer,FS_BUFFER_SIZE);
PICLANG_file_buffer_index = 0;
}
}
if(flag1 == false)
{
ch1 = '0';
SRAM_write(SRAM_PICLANG_RAW_FILE_BUFFER+PICLANG_file_buffer_index++,&ch1,sizeof(char));
if(PICLANG_file_buffer_index >= FS_BUFFER_SIZE)
{
picfs_dump(picos_processes[picos_curr_process].program_file);
SRAM_write(SRAM_PICLANG_NEXT_SWAP_ADDR,(void*)picfs_buffer,FS_BUFFER_SIZE);
memset((char*)picfs_buffer,0,FS_BUFFER_SIZE);
SRAM_write(SRAM_PICLANG_RAW_FILE_BUFFER,(void*)picfs_buffer,FS_BUFFER_SIZE);
SRAM_read(SRAM_PICLANG_NEXT_SWAP_ADDR,(void*)picfs_buffer,FS_BUFFER_SIZE);
PICLANG_file_buffer_index = 0;
}
}
break;
}
case PICLANG_PWDIR:
PICLANG_pushl(curr_dir);
break;
case PICLANG_MOUNT:
a = PICLANG_pop();// device
b = PICLANG_pop();// address of first byte
if(picfs_mount((picos_addr_t)b,(picos_dev_t)a) != SUCCESS)
curr_process.status = error_code;
break;
case PICLANG_CHDIR:
{
a = PICLANG_pop();
picfs_chdir(a);
break;
}
case PICLANG_MOVE:
a = PICLANG_pop();// y
b = PICLANG_pop();// x
IO_move(a,b);
break;
case PICLANG_GETY: case PICLANG_GETX:
IO_getxy(&a,&b);
if(command == PICLANG_GETX)
PICLANG_pushl(a);
else
PICLANG_pushl(b);
break;
case PICLANG_FPUTCH:// KEEP FPUTCH before FFLUSH
{
ch1 = (char)PICLANG_pop();
SRAM_write(SRAM_PICLANG_RAW_FILE_BUFFER+PICLANG_file_buffer_index++,&ch1,sizeof(char));
if(PICLANG_file_buffer_index < FS_BUFFER_SIZE)
break;
}
case PICLANG_FFLUSH:// KEEP FPUTCH before FFLUSH KEEP FFLUSH before FCLEAR
picfs_dump(picos_processes[picos_curr_process].program_file);
case PICLANG_FCLEAR:// KEEP FFLUSH before FCLEAR
SRAM_write(SRAM_PICLANG_NEXT_SWAP_ADDR,(void*)picfs_buffer,FS_BUFFER_SIZE);
memset((char*)picfs_buffer,0,FS_BUFFER_SIZE);
SRAM_write(SRAM_PICLANG_RAW_FILE_BUFFER,(void*)picfs_buffer,FS_BUFFER_SIZE);
SRAM_read(SRAM_PICLANG_NEXT_SWAP_ADDR,(void*)picfs_buffer,FS_BUFFER_SIZE);
PICLANG_file_buffer_index = 0;
break;
case PICLANG_FSTAT:
a = PICLANG_pop();
sch1 = picfs_stat(a);
if(sch1 < 0)
{
PICLANG_set_errno();
sch1 = 0;
}
a = picfs_buffer[ST_SIZE] << 8;
a += picfs_buffer[ST_SIZE+1];
PICLANG_pushl(a);
break;
case PICLANG_READDIR:
a = PICLANG_pop();
sch1 = picfs_readdir(1,a);
if(sch1 != SUCCESS)
PICLANG_set_errno();
PICLANG_pushl(sch1);
break;
case PICLANG_FOPEN:
{
/* mount_t mount;
SRAM_read(curr_dir*sizeof(mount_t)+SRAM_MTAB_ADDR,&mount,sizeof(mount_t));*/
a = PICLANG_pop();
if(a < ARG_SIZE)
{
sch1 = picfs_open(ARG_buffer+a,curr_dir);
}
else if(a < ARG_SIZE + FS_BUFFER_SIZE)
{
a -= ARG_SIZE;
sch1 = picfs_open((const char*)picfs_buffer+a,curr_dir);
}
else
{
c = 0;
a -= ARG_SIZE + picos_processes[picos_curr_process].block_size;
sch1 = PICLANG_next_dereference(a,command);
}
if(sch1 == -1)
PICLANG_set_errno();
PICLANG_pushl(sch1);
break;
}
case PICLANG_FCLOSE:
a = PICLANG_pop();
picfs_close(a);
break;
case PICLANG_FREAD:
a = PICLANG_pop();
sch1 = picfs_load(a);
b = sch1;
if(sch1 < 0)
{
b = -1;
error_code = SUCCESS;
PICLANG_exception(error_code);
}
PICLANG_pushl(b);
break;
case PICLANG_PRINTL:
IO_putd(PICLANG_pop());
IO_flush();
break;
case PICLANG_CLEAR:
clear_output();
break;
case PICLANG_MUTEX_LOCK:
PICLANG_block();
break;
case PICLANG_MUTEX_UNLOCK:
PICLANG_unblock();
break;
case PICLANG_GETCH:
{
PICLANG_block();
PICLANG_pushl(getch());
PICLANG_unblock();
break;
}
case PICLANG_GETD:
{
PICLANG_block();
ch1 = getch();
PICLANG_unblock();
if(ch1 < '0' || ch1 > '9')
{
PICLANG_exception(ARG_INVALID);
break;
}
ch1 -= 0x30;
PICLANG_pushl(ch1);
break;
}
case PICLANG_SPRINT:case PICLANG_SPRINTN:
{
// string addresses start with arguments then const strings in executable
/*string_pointer*/a = PICLANG_pop();
PICLANG_next_dereference(a,command);
IO_flush();
break;
}
case PICLANG_LSOF:
IO_puts("Implement lsof");
break;
case PICLANG_LSMOUNT:
lsmount();
break;
case PICLANG_ERRNO:
PICLANG_pushl(PICLANG_get_errno());
break;
case PICLANG_KVERSION:
a = PICLANG_pop();
if(a > 3)
{
PICLANG_exception(PICFS_EINVAL);
break;
}
if(a == 0)
b = KERNEL_MAJOR_VERSION;
else if(a == 1)
b = KERNEL_MINOR_VERSION;
else if(a == 2)
b = KERNEL_REVISION;
else
b = KERNEL_ID_TAG;
PICLANG_pushl(b);
break;
case PICLANG_SIGNAL:
a = PICLANG_get_next_word();// signal id
b = PICLANG_get_next_word();// signal action
if(a == PICOS_NUM_SIGNALS)
{
signal_free(b);
break;
}
sch1 = signal_assign(a,picos_curr_process,b);
if(sch1 != 0)
PICLANG_exception(error_code);
break;
case PICLANG_SLEEP:
a = PICLANG_pop();
ch1 = picos_curr_process;
PICLANG_save(PICLANG_SUSPENDED);
picos_processes[ch1].expires = (quantum_t)a;
break;
case PICLANG_MORSE:
{
char two[2];
/*addr*/a = PICLANG_pop();
two[1] = PICLANG_pop();//char or string?
if(two[1] == PICLANG_MORSE_STRING)
SRAM_read(a++,two,1);
else
{
two[0] = (char)a;
two[1] = 0;
morse_sound(two);
break;
}
two[1] = 0;
while(two[0] != 0)
{
morse_sound(two);
SRAM_read(a++,two,1);
}
break;
}
case PICLANG_TIME:
{
const TIME_t *thetime = TIME_get();
ch1 = PICLANG_pop();
switch(ch1)
{
case 'Y':
PICLANG_pushl(thetime->year);
break;
case 'm':
PICLANG_pushl(thetime->month);
break;
case 'd':
PICLANG_pushl(thetime->day);
break;
case 'H':
PICLANG_pushl(thetime->hours);
break;
case 'M':
PICLANG_pushl(thetime->minutes);
break;
case 'S':
PICLANG_pushl(thetime->seconds);
break;
default:
PICLANG_exception(PICLANG_INVALID_PARAMETER);
break;
}
break;
}
case PICLANG_SET_TIME:case PICLANG_SET_DATE:
{
TIME_t newtime = *(TIME_get());
if(command == PICLANG_SET_TIME)
{
newtime.minutes = PICLANG_pop();
newtime.hours = PICLANG_pop();
if(newtime.minutes > 59 || newtime.hours > 23)
{
newtime.minutes = newtime.hours = 0;
PICLANG_exception(TIME_INVALID);
}
}
else
{
newtime.year = PICLANG_pop();
newtime.day = PICLANG_pop();
newtime.month = PICLANG_pop();
if(newtime.month > 12 || newtime.day > 31)
{
newtime.month = newtime.day = 0;
PICLANG_exception(TIME_INVALID);
}
}
TIME_set(&newtime);
break;
}
case PICLANG_JZ:case PICLANG_JMP:case PICLANG_CALL:
{
b = curr_process.pc;
a = PICLANG_get_next_word();
if(curr_process.status != PICLANG_SUCCESS)
{
curr_process.pc = b;
break;
}
if(command == PICLANG_CALL)
{
PICLANG_call_push(curr_process.pc);
curr_process.pc = a;
}
else if(command == PICLANG_JMP)
curr_process.pc = a;
else if((curr_process.bitmap & PICLANG_ZERO) == 0)
curr_process.pc = a;
if(curr_process.status != PICLANG_SUCCESS)
{
curr_process.pc = b;
break;
}
break;
}
case PICLANG_RETURN:
{
b = curr_process.pc;
curr_process.pc = PICLANG_call_pop();
if(curr_process.status != PICLANG_SUCCESS)
{
curr_process.pc = b;
break;
}
break;
}
case PICLANG_EXIT:
PICLANG_save(PICLANG_pop());
break;
case PICLANG_LABEL:
break;
case PICLANG_COMPLT:
{
b = PICLANG_pop();
a = PICLANG_pop();
if(a < b)
curr_process.bitmap |= PICLANG_ZERO;
else
curr_process.bitmap &= ~PICLANG_ZERO;
break;
}
case PICLANG_COMPGT:
{
b = PICLANG_pop();
a = PICLANG_pop();
if(a > b)
curr_process.bitmap |= PICLANG_ZERO;
else
curr_process.bitmap &= ~PICLANG_ZERO;
break;
}
case PICLANG_COMPEQ:case PICLANG_COMPNE:
{
b = PICLANG_pop();
a = PICLANG_pop();
if(a == b)
curr_process.bitmap |= PICLANG_ZERO;
else
curr_process.bitmap &= ~PICLANG_ZERO;
if(command == PICLANG_COMPNE)
curr_process.bitmap ^= PICLANG_ZERO;
break;
}
case PICLANG_AND:
a = PICLANG_pop();
b = PICLANG_pop();
PICLANG_pushl(a & b);
break;
case PICLANG_OR:
a = PICLANG_pop();
b = PICLANG_pop();
PICLANG_pushl(a | b);
break;
case PICLANG_NOT:
a = PICLANG_pop();
PICLANG_pushl(~a);
break;
case PICLANG_RAWLOAD:
SRAM_read(SRAM_PICLANG_RAW_FILE_BUFFER,(void*)picfs_buffer,FS_BUFFER_SIZE);
break;
case PICLANG_NUM_COMMANDS:default:
PICLANG_exception(PICLANG_UNKNOWN_COMMAND);
break;
}
}
int main(int argc, char *argv[])
{
int f;
int i;
int16_t amp[8000];
int16_t value;
int signal;
float power[10];
tone_gen_descriptor_t tone_desc;
tone_gen_state_t tone_state;
awgn_state_t noise_source;
fir32_state_t line_model_d2;
fir32_state_t line_model_d3;
fir32_state_t line_model_d4;
fir32_state_t line_model_d5;
fir32_state_t line_model_d6;
fir32_state_t line_model_d7;
fir32_state_t line_model_d8;
fir32_state_t line_model_d9;
fir_float_state_t level_measurement_bp;
signal_load(&local_css, "sound_c1_8k.wav");
signal_load(&far_css, "sound_c3_8k.wav");
fir32_create(&line_model_d2,
line_model_d2_coeffs,
sizeof(line_model_d2_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d3,
line_model_d3_coeffs,
sizeof(line_model_d3_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d4,
line_model_d4_coeffs,
sizeof(line_model_d4_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d5,
line_model_d5_coeffs,
sizeof(line_model_d5_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d6,
line_model_d6_coeffs,
sizeof(line_model_d6_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d7,
line_model_d7_coeffs,
sizeof(line_model_d7_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d8,
line_model_d8_coeffs,
sizeof(line_model_d8_coeffs)/sizeof(int32_t));
fir32_create(&line_model_d9,
line_model_d9_coeffs,
sizeof(line_model_d9_coeffs)/sizeof(int32_t));
fir_float_create(&level_measurement_bp,
level_measurement_bp_coeffs,
sizeof(level_measurement_bp_coeffs)/sizeof(float));
for (f = 10; f < 4000; f++)
{
tone_gen_descriptor_init(&tone_desc,
f,
-10,
0,
0,
1,
0,
0,
0,
true);
tone_gen_init(&tone_state, &tone_desc);
tone_gen(&tone_state, amp, 8000);
for (i = 0; i < 10; i++)
power[i] = 0.0f;
for (i = 0; i < 800; i++)
{
signal = fir32(&line_model_d2, amp[i]);
power[0] += ((signal*signal - power[0])/32.0f);
signal = fir32(&line_model_d3, amp[i]);
power[1] += ((signal*signal - power[1])/32.0f);
signal = fir32(&line_model_d4, amp[i]);
power[2] += ((signal*signal - power[2])/32.0f);
signal = fir32(&line_model_d5, amp[i]);
power[3] += ((signal*signal - power[3])/32.0f);
signal = fir32(&line_model_d6, amp[i]);
power[4] += ((signal*signal - power[4])/32.0f);
signal = fir32(&line_model_d7, amp[i]);
power[5] += ((signal*signal - power[5])/32.0f);
signal = fir32(&line_model_d8, amp[i]);
power[6] += ((signal*signal - power[6])/32.0f);
signal = fir32(&line_model_d9, amp[i]);
power[7] += ((signal*signal - power[7])/32.0f);
signal = fir_float(&level_measurement_bp, amp[i]);
power[8] += ((signal*signal - power[8])/32.0f);
signal = amp[i];
power[9] += ((signal*signal - power[9])/32.0f);
}
printf("%d %f %f %f %f %f %f %f %f %f %f\n",
f,
sqrt(power[0])*LINE_MODEL_D2_GAIN,
sqrt(power[1])*LINE_MODEL_D3_GAIN,
sqrt(power[2])*LINE_MODEL_D4_GAIN,
sqrt(power[3])*LINE_MODEL_D5_GAIN,
sqrt(power[4])*LINE_MODEL_D6_GAIN,
sqrt(power[5])*LINE_MODEL_D7_GAIN,
sqrt(power[6])*LINE_MODEL_D8_GAIN,
sqrt(power[7])*LINE_MODEL_D9_GAIN,
sqrt(power[8]),
sqrt(power[9]));
}
awgn_init_dbm0(&noise_source, 1234567, -20.0f);
for (i = 0; i < 10; i++)
power[i] = 0.0f;
signal_restart(&local_css, 0.0f);
signal_restart(&far_css, 0.0f);
for (i = 0; i < SAMPLE_RATE; i++)
{
value = signal_amp(&local_css);
//value = awgn(&noise_source);
signal = fir32(&line_model_d2, value);
power[0] += ((signal*signal - power[0])/32.0f);
signal = fir32(&line_model_d3, value);
power[1] += ((signal*signal - power[1])/32.0f);
signal = fir32(&line_model_d4, value);
power[2] += ((signal*signal - power[2])/32.0f);
signal = fir32(&line_model_d5, value);
power[3] += ((signal*signal - power[3])/32.0f);
signal = fir32(&line_model_d6, value);
power[4] += ((signal*signal - power[4])/32.0f);
signal = fir32(&line_model_d7, value);
power[5] += ((signal*signal - power[5])/32.0f);
signal = fir32(&line_model_d8, value);
power[6] += ((signal*signal - power[6])/32.0f);
signal = fir32(&line_model_d9, value);
power[7] += ((signal*signal - power[7])/32.0f);
signal = fir_float(&level_measurement_bp, value);
power[8] += ((signal*signal - power[8])/32.0f);
signal = value;
power[9] += ((signal*signal - power[9])/32.0f);
}
for (i = 0; i < 10; i++)
power[i] = 0.0f;
for (i = 0; i < SAMPLE_RATE; i++)
{
value = signal_amp(&local_css);
//value = awgn(&noise_source);
signal = fir32(&line_model_d2, value);
power[0] += ((signal*signal - power[0])/32.0f);
signal = fir32(&line_model_d3, value);
power[1] += ((signal*signal - power[1])/32.0f);
signal = fir32(&line_model_d4, value);
power[2] += ((signal*signal - power[2])/32.0f);
signal = fir32(&line_model_d5, value);
power[3] += ((signal*signal - power[3])/32.0f);
signal = fir32(&line_model_d6, value);
power[4] += ((signal*signal - power[4])/32.0f);
signal = fir32(&line_model_d7, value);
power[5] += ((signal*signal - power[5])/32.0f);
signal = fir32(&line_model_d8, value);
power[6] += ((signal*signal - power[6])/32.0f);
signal = fir32(&line_model_d9, value);
power[7] += ((signal*signal - power[7])/32.0f);
signal = fir_float(&level_measurement_bp, value);
power[8] += ((signal*signal - power[8])/32.0f);
signal = value;
power[9] += ((signal*signal - power[9])/32.0f);
}
printf("%d %f %f %f %f %f %f %f %f %f %f\n",
0,
sqrt(power[0])*LINE_MODEL_D2_GAIN,
sqrt(power[1])*LINE_MODEL_D3_GAIN,
sqrt(power[2])*LINE_MODEL_D4_GAIN,
sqrt(power[3])*LINE_MODEL_D5_GAIN,
sqrt(power[4])*LINE_MODEL_D6_GAIN,
sqrt(power[5])*LINE_MODEL_D7_GAIN,
sqrt(power[6])*LINE_MODEL_D8_GAIN,
sqrt(power[7])*LINE_MODEL_D9_GAIN,
sqrt(power[8]),
sqrt(power[9]));
printf("%d %f %f %f %f %f %f %f %f %f %f\n",
0,
sqrt(power[0]),
sqrt(power[1]),
sqrt(power[2]),
sqrt(power[3]),
sqrt(power[4]),
sqrt(power[5]),
sqrt(power[6]),
sqrt(power[7]),
sqrt(power[8]),
sqrt(power[9]));
printf("%d %f %f %f %f %f %f %f %f %f %f\n",
0,
sqrt(power[0])/sqrt(power[9]),
sqrt(power[1])/sqrt(power[9]),
sqrt(power[2])/sqrt(power[9]),
sqrt(power[3])/sqrt(power[9]),
sqrt(power[4])/sqrt(power[9]),
sqrt(power[5])/sqrt(power[9]),
sqrt(power[6])/sqrt(power[9]),
sqrt(power[7])/sqrt(power[9]),
sqrt(power[8]),
sqrt(power[9]));
printf("%d %f %f %f %f %f %f %f %f %f %f\n",
0,
sqrt(power[0])*LINE_MODEL_D2_GAIN/sqrt(power[9]),
sqrt(power[1])*LINE_MODEL_D3_GAIN/sqrt(power[9]),
sqrt(power[2])*LINE_MODEL_D4_GAIN/sqrt(power[9]),
sqrt(power[3])*LINE_MODEL_D5_GAIN/sqrt(power[9]),
sqrt(power[4])*LINE_MODEL_D6_GAIN/sqrt(power[9]),
sqrt(power[5])*LINE_MODEL_D7_GAIN/sqrt(power[9]),
sqrt(power[6])*LINE_MODEL_D8_GAIN/sqrt(power[9]),
sqrt(power[7])*LINE_MODEL_D9_GAIN/sqrt(power[9]),
sqrt(power[8]),
sqrt(power[9]));
for (i = 0; i < (int) (sizeof(css_c1)/sizeof(css_c1[0])); i++)
printf("%d\n", css_c1[i]);
printf("\n");
for (i = 0; i < (int) (sizeof(css_c1)/sizeof(css_c3[0])); i++)
printf("%d\n", css_c3[i]);
signal_free(&local_css);
signal_free(&far_css);
fir32_free(&line_model_d2);
fir32_free(&line_model_d3);
fir32_free(&line_model_d4);
fir32_free(&line_model_d5);
fir32_free(&line_model_d6);
fir32_free(&line_model_d7);
fir32_free(&line_model_d8);
fir32_free(&line_model_d9);
fir_float_free(&level_measurement_bp);
return 0;
}
static void
signal_monitor_generic_handler (SignalMonitor *m,
SignalName signal,
GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreePath *path,
int *new_order)
{
Signal *s;
if (g_queue_is_empty (m->queue))
{
gchar *path_str;
path_str = gtk_tree_path_to_string (path);
g_error ("Signal queue empty, got signal %s path %s",
signal_name_to_string (signal), path_str);
g_free (path_str);
g_assert_not_reached ();
}
if (m->client != model)
{
g_error ("Model mismatch; expected %p, got %p",
m->client, model);
g_assert_not_reached ();
}
s = g_queue_peek_tail (m->queue);
#if 0
/* For debugging: output signals that are coming in. Leaks memory. */
g_print ("signal=%s path=%s\n", signal_name_to_string (signal),
gtk_tree_path_to_string (path));
#endif
if (s->signal != signal ||
(gtk_tree_path_get_depth (s->path) == 0 &&
gtk_tree_path_get_depth (path) != 0) ||
(gtk_tree_path_get_depth (s->path) != 0 &&
gtk_tree_path_compare (s->path, path) != 0))
{
gchar *path_str, *s_path_str;
s_path_str = gtk_tree_path_to_string (s->path);
path_str = gtk_tree_path_to_string (path);
g_error ("Signals don't match; expected signal %s path %s, got signal %s path %s",
signal_name_to_string (s->signal), s_path_str,
signal_name_to_string (signal), path_str);
g_free (s_path_str);
g_free (path_str);
g_assert_not_reached ();
}
if (signal == ROWS_REORDERED && s->new_order != NULL)
{
int i, len;
g_assert (new_order != NULL);
len = gtk_tree_model_iter_n_children (model, iter);
g_assert (s->len == len);
for (i = 0; i < len; i++)
g_assert (s->new_order[i] == new_order[i]);
}
s = g_queue_pop_tail (m->queue);
signal_free (s);
}
int main(int argc, char *argv[])
{
echo_can_state_t *ctx;
awgn_state_t local_noise_source;
awgn_state_t far_noise_source;
int i;
int clean;
int residue;
int16_t rx;
int16_t tx;
int j;
int k;
tone_gen_descriptor_t tone_desc;
tone_gen_state_t tone_state;
int16_t local_sound[40000];
int local_max;
int local_cur;
int16_t hoth_noise;
//int16_t far_sound[SAMPLE_RATE];
//int16_t result_sound[64000];
//int32_t coeffs[200][128];
//int coeff_index;
int far_cur;
int result_cur;
//int far_tx;
AFfilehandle resulthandle;
AFfilesetup filesetup;
AFfilesetup filesetup2;
//int outframes;
time_t now;
int tone_burst_step;
level_measurement_device_t *power_meter_1;
level_measurement_device_t *power_meter_2;
float pp1;
float pp2;
int model_number;
int use_gui;
power_meter_1 = NULL;
power_meter_2 = NULL;
/* Check which tests we should run */
if (argc < 2)
fprintf(stderr, "Usage: echo tests <list of test numbers>\n");
test_list = 0;
model_number = 0;
use_gui = FALSE;
for (i = 1; i < argc; i++)
{
if (strcasecmp(argv[i], "2a") == 0)
test_list |= PERFORM_TEST_2A;
else if (strcasecmp(argv[i], "2b") == 0)
test_list |= PERFORM_TEST_2B;
else if (strcasecmp(argv[i], "2c") == 0)
test_list |= PERFORM_TEST_2C;
else if (strcasecmp(argv[i], "3a") == 0)
test_list |= PERFORM_TEST_3A;
else if (strcasecmp(argv[i], "3b") == 0)
test_list |= PERFORM_TEST_3B;
else if (strcasecmp(argv[i], "3c") == 0)
test_list |= PERFORM_TEST_3C;
else if (strcasecmp(argv[i], "4") == 0)
test_list |= PERFORM_TEST_4;
else if (strcasecmp(argv[i], "5") == 0)
test_list |= PERFORM_TEST_5;
else if (strcasecmp(argv[i], "6") == 0)
test_list |= PERFORM_TEST_6;
else if (strcasecmp(argv[i], "7") == 0)
test_list |= PERFORM_TEST_7;
else if (strcasecmp(argv[i], "8") == 0)
test_list |= PERFORM_TEST_8;
else if (strcasecmp(argv[i], "9") == 0)
test_list |= PERFORM_TEST_9;
else if (strcasecmp(argv[i], "10a") == 0)
test_list |= PERFORM_TEST_10A;
else if (strcasecmp(argv[i], "10b") == 0)
test_list |= PERFORM_TEST_10B;
else if (strcasecmp(argv[i], "10c") == 0)
test_list |= PERFORM_TEST_10C;
else if (strcasecmp(argv[i], "11") == 0)
test_list |= PERFORM_TEST_11;
else if (strcasecmp(argv[i], "12") == 0)
test_list |= PERFORM_TEST_12;
else if (strcasecmp(argv[i], "13") == 0)
test_list |= PERFORM_TEST_13;
else if (strcasecmp(argv[i], "14") == 0)
test_list |= PERFORM_TEST_14;
else if (strcasecmp(argv[i], "15") == 0)
test_list |= PERFORM_TEST_15;
else if (strcmp(argv[i], "-m") == 0)
{
if (++i < argc)
model_number = atoi(argv[i]);
}
else if (strcmp(argv[i], "-g") == 0)
{
use_gui = TRUE;
}
else
{
fprintf(stderr, "Unknown test '%s' specified\n", argv[i]);
exit(2);
}
}
if (test_list == 0)
{
fprintf(stderr, "No tests have been selected\n");
exit(2);
}
time(&now);
tone_burst_step = 0;
ctx = echo_can_create(TEST_EC_TAPS, 0);
awgn_init_dbm0(&far_noise_source, 7162534, -50.0f);
signal_load(&local_css, "sound_c1_8k.wav");
signal_load(&far_css, "sound_c3_8k.wav");
filesetup = afNewFileSetup();
if (filesetup == AF_NULL_FILESETUP)
{
fprintf(stderr, " Failed to create file setup\n");
exit(2);
}
afInitSampleFormat(filesetup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitRate(filesetup, AF_DEFAULT_TRACK, (float) SAMPLE_RATE);
afInitFileFormat(filesetup, AF_FILE_WAVE);
afInitChannels(filesetup, AF_DEFAULT_TRACK, 6);
filesetup2 = afNewFileSetup();
if (filesetup2 == AF_NULL_FILESETUP)
{
fprintf(stderr, " Failed to create file setup\n");
exit(2);
}
afInitSampleFormat(filesetup2, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitRate(filesetup2, AF_DEFAULT_TRACK, (float) SAMPLE_RATE);
afInitFileFormat(filesetup2, AF_FILE_WAVE);
afInitChannels(filesetup2, AF_DEFAULT_TRACK, 1);
resulthandle = afOpenFile("result_sound.wav", "w", filesetup);
if (resulthandle == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Failed to open result file\n");
exit(2);
}
residuehandle = afOpenFile("residue_sound.wav", "w", filesetup2);
if (residuehandle == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Failed to open residue file\n");
exit(2);
}
local_cur = 0;
far_cur = 0;
result_cur = 0;
if (channel_model_create(model_number))
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
#if defined(ENABLE_GUI)
if (use_gui)
{
start_echo_can_monitor(TEST_EC_TAPS);
echo_can_monitor_line_model_update(line_model.coeffs, line_model.taps);
}
#endif
power_meter_1 = level_measurement_device_create(0);
power_meter_2 = level_measurement_device_create(0);
level_measurement_device(power_meter_1, 0);
#if 0
echo_can_flush(ctx);
/* Converge the canceller */
signal_restart(&local_css);
for (i = 0; i < 800*2; i++)
{
clean = echo_can_update(ctx, 0, 0);
put_residue(clean);
}
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION | ECHO_CAN_USE_NLP | ECHO_CAN_USE_CNG);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
for (i = 0; i < SAMPLE_RATE*10; i++)
{
tx = signal_amp(&local_css);
#if 0
if ((i/10000)%10 == 9)
{
/* Inject a burst of far sound */
if (far_cur >= far_max)
{
far_max = afReadFrames(farhandle, AF_DEFAULT_TRACK, far_sound, SAMPLE_RATE);
if (far_max < 0)
{
fprintf(stderr, " Error reading far sound\n");
exit(2);
}
if (far_max == 0)
break;
far_cur = 0;
}
far_tx = far_sound[far_cur++];
}
else
{
far_tx = 0;
}
#else
far_sound[0] = 0;
far_tx = 0;
#endif
channel_model(&tx, &rx, tx, far_tx);
//rx += awgn(&far_noise_source);
//tx += awgn(&far_noise_source);
clean = echo_can_update(ctx, tx, rx);
#if defined(XYZZY)
if (i%SAMPLE_RATE == 0)
{
if (coeff_index < 200)
{
for (j = 0; j < ctx->taps; j++)
coeffs[coeff_index][j] = ctx->fir_taps32[j];
coeff_index++;
}
}
#endif
result_sound[result_cur++] = tx;
result_sound[result_cur++] = rx;
result_sound[result_cur++] = clean - far_tx;
//result_sound[result_cur++] = ctx->tx_power[2];
//result_sound[result_cur++] = ctx->tx_power[1];
result_sound[result_cur++] = (ctx->tx_power[1] > 64) ? SAMPLE_RATE : -SAMPLE_RATE;
//result_sound[result_cur++] = ctx->tap_set*SAMPLE_RATE;
//result_sound[result_cur++] = (ctx->nonupdate_dwell > 0) ? SAMPLE_RATE : -SAMPLE_RATE;
//result_sound[result_cur++] = ctx->latest_correction >> 8;
//result_sound[result_cur++] = level_measurement_device(tx)/(16.0*65536.0);
//result_sound[result_cur++] = level_measurement_device(tx)/4096.0;
result_sound[result_cur++] = (ctx->tx_power[1] > ctx->rx_power[0]) ? SAMPLE_RATE : -SAMPLE_RATE;
//result_sound[result_cur++] = (ctx->tx_power[1] > ctx->rx_power[0]) ? SAMPLE_RATE : -SAMPLE_RATE;
//result_sound[result_cur++] = (ctx->narrowband_score)*5; // ? SAMPLE_RATE : -SAMPLE_RATE;
//result_sound[result_cur++] = ctx->tap_rotate_counter*10;
result_sound[result_cur++] = ctx->vad;
put_residue(clean - far_tx);
if (result_cur >= 6*SAMPLE_RATE)
{
outframes = afWriteFrames(resulthandle,
AF_DEFAULT_TRACK,
result_sound,
result_cur/6);
if (outframes != result_cur/6)
{
fprintf(stderr, " Error writing result sound\n");
exit(2);
}
result_cur = 0;
}
}
if (result_cur > 0)
{
outframes = afWriteFrames(resulthandle,
AF_DEFAULT_TRACK,
result_sound,
result_cur/6);
if (outframes != result_cur/4)
{
fprintf(stderr, " Error writing result sound\n");
exit(2);
}
}
#endif
/* Test 1 - Steady state residual and returned echo level test */
/* This functionality has been merged with test 2 in newer versions of G.168,
so test 1 no longer exists. */
/* Test 2 - Convergence and steady state residual and returned echo level test */
if ((test_list & PERFORM_TEST_2A))
{
printf("Performing test 2A - Convergence with NLP enabled\n");
/* Test 2A - Convergence with NLP enabled */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION | ECHO_CAN_USE_NLP);
/* Converge the canceller */
signal_restart(&local_css);
for (i = 0; i < 800*2; i++)
{
clean = echo_can_update(ctx, 0, 0);
put_residue(clean);
}
for (i = 0; i < SAMPLE_RATE*50; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
pp1 = level_measurement_device(power_meter_1, rx);
pp2 = level_measurement_device(power_meter_2, clean);
residue = 100.0*pp1/pp2;
put_residue(residue);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_2B))
{
printf("Performing test 2B - Convergence with NLP disabled\n");
/* Test 2B - Convergence with NLP disabled */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
/* Converge a canceller */
signal_restart(&local_css);
for (i = 0; i < 800*2; i++)
{
clean = echo_can_update(ctx, 0, 0);
put_residue(clean);
}
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_2C))
{
printf("Performing test 2C - Convergence with background noise present\n");
/* Test 2C - Convergence with background noise present */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
/* Converge a canceller */
signal_restart(&local_css);
for (i = 0; i < 800*2; i++)
{
clean = echo_can_update(ctx, 0, 0);
put_residue(clean);
}
/* TODO: This uses a crude approx. to Hoth noise. We need the real thing. */
awgn_init_dbm0(&far_noise_source, 7162534, -40.0f);
hoth_noise = 0;
for (i = 0; i < SAMPLE_RATE*5; i++)
{
hoth_noise = hoth_noise*0.625 + awgn(&far_noise_source)*0.375;
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, hoth_noise);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Now freeze adaption, and measure the echo. */
echo_can_adaption_mode(ctx, 0);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
/* Test 3 - Performance under double talk conditions */
if ((test_list & PERFORM_TEST_3A))
{
printf("Performing test 3A - Double talk test with low cancelled-end levels\n");
/* Test 3A - Double talk test with low cancelled-end levels */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
signal_restart(&local_css);
signal_restart(&far_css);
/* Apply double talk, with a weak far end signal */
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
rx = signal_amp(&far_css)/20;
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean - rx);
}
/* Now freeze adaption. */
echo_can_adaption_mode(ctx, 0);
for (i = 0; i < 800*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Now measure the echo */
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_3B))
{
printf("Performing test 3B - Double talk test with high cancelled-end levels\n");
/* Test 3B - Double talk test with high cancelled-end levels */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
signal_restart(&local_css);
signal_restart(&far_css);
/* Converge the canceller */
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Apply double talk */
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
rx = signal_amp(&far_css);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean - rx);
}
/* Now freeze adaption. */
echo_can_adaption_mode(ctx, 0);
for (i = 0; i < 800*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Now measure the echo */
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_3C))
{
printf("Performing test 3C - Double talk test with simulated conversation\n");
/* Test 3C - Double talk test with simulated conversation */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
signal_restart(&local_css);
signal_restart(&far_css);
/* Apply double talk */
for (i = 0; i < 800*56; i++)
{
tx = signal_amp(&local_css);
rx = signal_amp(&far_css);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean - rx);
}
/* Stop the far signal */
for (i = 0; i < 800*14; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Continue measuring the resulting echo */
for (i = 0; i < 800*50; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Reapply double talk */
signal_restart(&far_css);
for (i = 0; i < 800*56; i++)
{
tx = signal_amp(&local_css);
rx = signal_amp(&far_css);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean - rx);
}
/* Now the far signal only */
for (i = 0; i < 800*56; i++)
{
tx = 0;
rx = signal_amp(&far_css);
channel_model(&tx, &rx, 0, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean - rx);
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_4))
{
printf("Performing test 4 - Leak rate test\n");
/* Test 4 - Leak rate test */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
/* Converge a canceller */
signal_restart(&local_css);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Put 2 minutes of silence through it */
for (i = 0; i < SAMPLE_RATE*120; i++)
{
clean = echo_can_update(ctx, 0, 0);
put_residue(clean);
}
/* Now freeze it, and check if it is still well adapted. */
echo_can_adaption_mode(ctx, 0);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_5))
{
printf("Performing test 5 - Infinite return loss convergence test\n");
/* Test 5 - Infinite return loss convergence test */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
/* Converge the canceller */
signal_restart(&local_css);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Now stop echoing, and see we don't do anything unpleasant as the
echo path is open looped. */
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
rx = 0;
tx = codec_munge(tx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_6))
{
printf("Performing test 6 - Non-divergence on narrow-band signals\n");
/* Test 6 - Non-divergence on narrow-band signals */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
/* Converge the canceller */
signal_restart(&local_css);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Now put 5s bursts of a list of tones through the converged canceller, and check
that bothing unpleasant happens. */
for (k = 0; tones_6_4_2_7[k][0]; k++)
{
make_tone_gen_descriptor(&tone_desc,
tones_6_4_2_7[k][0],
-11,
tones_6_4_2_7[k][1],
-9,
1,
0,
0,
0,
1);
tone_gen_init(&tone_state, &tone_desc);
j = 0;
for (i = 0; i < 5; i++)
{
local_max = tone_gen(&tone_state, local_sound, SAMPLE_RATE);
for (j = 0; j < SAMPLE_RATE; j++)
{
tx = local_sound[j];
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
#if defined(ENABLE_GUI)
if (use_gui)
{
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
echo_can_monitor_update_display();
usleep(100000);
}
#endif
}
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_7))
{
printf("Performing test 7 - Stability\n");
/* Test 7 - Stability */
/* Put tones through an unconverged canceller, and check nothing unpleasant
happens. */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
make_tone_gen_descriptor(&tone_desc,
tones_6_4_2_7[0][0],
-11,
tones_6_4_2_7[0][1],
-9,
1,
0,
0,
0,
1);
tone_gen_init(&tone_state, &tone_desc);
j = 0;
for (i = 0; i < 120; i++)
{
local_max = tone_gen(&tone_state, local_sound, SAMPLE_RATE);
for (j = 0; j < SAMPLE_RATE; j++)
{
tx = local_sound[j];
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
#if defined(ENABLE_GUI)
if (use_gui)
{
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
echo_can_monitor_update_display();
usleep(100000);
}
#endif
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
if ((test_list & PERFORM_TEST_8))
{
printf("Performing test 8 - Non-convergence on No 5, 6, and 7 in-band signalling\n");
/* Test 8 - Non-convergence on No 5, 6, and 7 in-band signalling */
fprintf(stderr, "Test 8 not yet implemented\n");
}
if ((test_list & PERFORM_TEST_9))
{
printf("Performing test 9 - Comfort noise test\n");
/* Test 9 - Comfort noise test */
/* Test 9 part 1 - matching */
echo_can_flush(ctx);
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION);
/* Converge the canceller */
signal_restart(&local_css);
for (i = 0; i < SAMPLE_RATE*5; i++)
{
tx = signal_amp(&local_css);
channel_model(&tx, &rx, tx, 0);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
echo_can_adaption_mode(ctx, ECHO_CAN_USE_ADAPTION | ECHO_CAN_USE_NLP | ECHO_CAN_USE_CNG);
awgn_init_dbm0(&far_noise_source, 7162534, -45.0f);
for (i = 0; i < SAMPLE_RATE*30; i++)
{
tx = 0;
rx = awgn(&far_noise_source);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
awgn_init_dbm0(&local_noise_source, 1234567, -10.0f);
for (i = 0; i < SAMPLE_RATE*2; i++)
{
tx = awgn(&local_noise_source);
rx = awgn(&far_noise_source);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
/* Test 9 part 2 - adjust down */
awgn_init_dbm0(&far_noise_source, 7162534, -55.0f);
for (i = 0; i < SAMPLE_RATE*10; i++)
{
tx = 0;
rx = awgn(&far_noise_source);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
for (i = 0; i < SAMPLE_RATE*2; i++)
{
tx = awgn(&local_noise_source);
rx = awgn(&far_noise_source);
channel_model(&tx, &rx, tx, rx);
clean = echo_can_update(ctx, tx, rx);
put_residue(clean);
}
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_can_update(ctx->fir_taps16[ctx->tap_set], TEST_EC_TAPS);
#endif
}
/* Test 10 - FAX test during call establishment phase */
if ((test_list & PERFORM_TEST_10A))
{
printf("Performing test 10A - Canceller operation on the calling station side\n");
/* Test 10A - Canceller operation on the calling station side */
fprintf(stderr, "Test 10A not yet implemented\n");
}
if ((test_list & PERFORM_TEST_10B))
{
printf("Performing test 10B - Canceller operation on the called station side\n");
/* Test 10B - Canceller operation on the called station side */
fprintf(stderr, "Test 10B not yet implemented\n");
}
if ((test_list & PERFORM_TEST_10C))
{
printf("Performing test 10C - Canceller operation on the calling station side during page\n"
"transmission and page breaks (for further study)\n");
/* Test 10C - Canceller operation on the calling station side during page
transmission and page breaks (for further study) */
fprintf(stderr, "Test 10C not yet implemented\n");
}
if ((test_list & PERFORM_TEST_11))
{
printf("Performing test 11 - Tandem echo canceller test (for further study)\n");
/* Test 11 - Tandem echo canceller test (for further study) */
fprintf(stderr, "Test 11 not yet implemented\n");
}
if ((test_list & PERFORM_TEST_12))
{
printf("Performing test 12 - Residual acoustic echo test (for further study)\n");
/* Test 12 - Residual acoustic echo test (for further study) */
fprintf(stderr, "Test 12 not yet implemented\n");
}
if ((test_list & PERFORM_TEST_13))
{
printf("Performing test 13 - Performance with ITU-T low-bit rate coders in echo path (Optional, under study)\n");
/* Test 13 - Performance with ITU-T low-bit rate coders in echo path
(Optional, under study) */
fprintf(stderr, "Test 13 not yet implemented\n");
}
if ((test_list & PERFORM_TEST_14))
{
printf("Performing test 14 - Performance with V-series low-speed data modems\n");
/* Test 14 - Performance with V-series low-speed data modems */
fprintf(stderr, "Test 14 not yet implemented\n");
}
if ((test_list & PERFORM_TEST_15))
{
printf("Performing test 15 - PCM offset test (Optional)\n");
/* Test 15 - PCM offset test (Optional) */
fprintf(stderr, "Test 15 not yet implemented\n");
}
echo_can_free(ctx);
signal_free(&local_css);
signal_free(&far_css);
if (afCloseFile(resulthandle) != 0)
{
fprintf(stderr, " Cannot close speech file '%s'\n", "result_sound.wav");
exit(2);
}
if (afCloseFile(residuehandle) != 0)
{
fprintf(stderr, " Cannot close speech file '%s'\n", "residue_sound.wav");
exit(2);
}
afFreeFileSetup(filesetup);
afFreeFileSetup(filesetup2);
#if defined(XYZZY)
for (j = 0; j < ctx->taps; j++)
{
for (i = 0; i < coeff_index; i++)
fprintf(stderr, "%d ", coeffs[i][j]);
fprintf(stderr, "\n");
}
#endif
printf("Run time %lds\n", time(NULL) - now);
#if defined(ENABLE_GUI)
if (use_gui)
echo_can_monitor_wait_to_end();
#endif
if (power_meter_1)
level_measurement_device_release(power_meter_1);
if (power_meter_2)
level_measurement_device_release(power_meter_2);
printf("Tests passed.\n");
return 0;
}