#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <math.h>
|
#include <time.h>
|
#include <vector.h>
|
#include <alg.h>
|
|
#include "drv/global.h"
|
#include "f2f.h"
|
#include "execute.h"
|
#include "scene.h"
|
#include "drv/fft.h"
|
|
|
volatile int sp_flag =0;
|
volatile int inputcnt=0;
|
volatile int dma_count=0;
|
int dsp_status =0 ;
|
|
extern int scene_loading;
|
extern void* haec,*hans;
|
|
int usb_input_cnt =0 ;
|
int usb_dma_count =0;
|
int usb_sp_flag =0;
|
|
double proc_secs;/////////////////////////////////////////////////
|
static double clock_start,clock_stop;
|
|
|
#define LEVEL_DETECT_PERIOD (70*RATE_SAMPLES/1000/NUM_SAMPLES) //µçƽ¼ÆËã100msÒ»´Î
|
|
#define MAX(x,y) ((x)>(y)?(x):(y))
|
|
|
|
double cpu_get_process_ulitity(void)
|
{
|
return proc_secs;
|
}
|
volatile int test_count = 0;
|
void sport_usb_isr(int sig_int)
|
{
|
usb_input_cnt++;
|
usb_input_cnt &= 0x1;
|
|
if(scene_loading == 0){
|
usb_input_fflush(usb_input_cnt);
|
usb_output_fflush(usb_input_cnt);
|
}
|
usb_dma_count++;// = dma_count;
|
|
usb_sp_flag = 1;
|
|
|
}
|
|
void sport_isr(int sig_int)
|
{
|
float secs;
|
|
inputcnt++;
|
inputcnt &= 0x1;
|
|
if( scene_loading == 0){
|
|
clock_start = clock();
|
|
input_fflush(inputcnt);
|
scene_running();
|
output_fflush(inputcnt);
|
|
clock_stop = clock();
|
secs = ((double) (clock_stop - clock_start))/ CLOCKS_PER_SEC_NLP;
|
|
alg_aec_timer_handler(haec, secs);
|
alg_ans_timer_handler(hans, secs);
|
if(secs > proc_secs) {
|
proc_secs = secs;
|
}
|
}
|
else{
|
output_empty();
|
output_fflush(inputcnt);
|
}
|
|
dsp_status = dsp_running_ok;
|
dma_count++;
|
}
|
|
|
int BuiltIn_Expander(void *Expander, int channel_id)
|
{
|
float* in_ptr = get_rx_channel(channel_id);
|
float* out_ptr = get_tx_channel(channel_id);
|
|
alg_expander_process(Expander,in_ptr,out_ptr);
|
exchange_ptr(channel_id,channel_id);
|
|
return 0;
|
}
|
|
|
int input_execute(pinput_handle handle)
|
{
|
int i;
|
|
for(i=0;i<handle->output_num;i++){
|
float* in_ptr = get_rx_channel(handle->il_id[i]);
|
float* out_ptr = get_tx_channel(handle->ol_id[i]);
|
|
if(handle->input[i].type){
|
alg_sg_process(handle->input[i].hgen,in_ptr);
|
}
|
|
if(handle->input[i].mute){
|
if(handle->input[i].time>0){
|
fgain_step(in_ptr,out_ptr,&handle->input[i].old_gain,FADE_OUT_GAIN,handle->input[i].step_gain,NUM_SAMPLES);
|
handle->input[i].time --;
|
}
|
else{
|
memset(out_ptr, 0 ,NUM_SAMPLES);
|
}
|
}
|
else{
|
if(handle->input[i].gain <= -72.0){
|
memset(out_ptr, 0 ,NUM_SAMPLES);
|
}
|
else if(handle->input[i].time>0){
|
fgain_step(in_ptr,out_ptr,&handle->input[i].old_gain, handle->input[i].gain,handle->input[i].step_gain,NUM_SAMPLES);
|
handle->input[i].time --;
|
|
}
|
else{
|
// alg_expander_process(handle->input[i].hExpander,in_ptr,out_ptr);
|
fgain_proc(in_ptr,out_ptr,&handle->input[i].old_gain,&handle->input[i].gain,NUM_SAMPLES);
|
}
|
}
|
|
|
if(handle->input[i].delay>0){
|
memset(out_ptr,0,NUM_SAMPLES);
|
handle->input[i].delay-=NUM_SAMPLES;
|
}
|
else if(handle->input[i].phase){
|
vecsmltf(out_ptr, -1, out_ptr ,NUM_SAMPLES);
|
}
|
|
exchange_ptr(handle->ol_id[i],handle->ol_id[i]);
|
}
|
|
return 0;
|
}
|
|
|
int meter_execute(pmeter_handle handle)
|
{
|
int i;
|
|
|
for(i=0;i< handle->input_num;i++){
|
float* ptr = get_rx_channel(handle->il_id[i]);
|
float curMaxData = fpeak_data(ptr,NUM_SAMPLES);
|
|
|
handle->maxLevel[i] = MAX(handle->maxLevel[i], curMaxData );
|
|
|
if(handle->period[i] < RATE_SAMPLES*0.05){
|
handle->period[i] += NUM_SAMPLES;
|
continue;
|
}
|
|
handle->period[i] =0;
|
|
if(handle->maxLevel[i] == 0){
|
handle->level[i] = -12000;
|
}
|
else{
|
handle->level[i] = 2000 * log10f(handle->maxLevel[i]);
|
if(handle->level[i]<-32767){
|
handle->level[i] = -32767;
|
}
|
}
|
|
handle->maxLevel[i] = 0;
|
|
}
|
|
|
return 0;
|
}
|
|
int delay_execute(pdelay_handle handle)
|
{
|
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
if(!handle->bypass){
|
|
alg_delay_process(handle->halg,in_ptr,out_ptr);
|
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}
|
|
return 0;
|
}
|
|
int eq_execute(peq_handle handle)
|
{
|
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
if(!handle->bypass){
|
alg_eq_filter(handle->halg,in_ptr,out_ptr);
|
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}
|
|
return 0;
|
}
|
|
|
int expander_execute(pexpander_handle handle)
|
{
|
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
if(!handle->bypass){
|
alg_expander_process(handle->halg,in_ptr,out_ptr);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
handle->level[0]=alg_expander_get_reducedb(handle->halg)*100.0f;
|
handle->period=0;
|
}
|
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}else{
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
handle->level[0]= 0;
|
handle->period=0;
|
}
|
}
|
|
return 0;
|
}
|
|
int compressor_execute(pcompressor_handle handle)
|
{
|
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
if(!handle->bypass){
|
|
alg_compress_process(handle->halg,in_ptr,out_ptr);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
//float pg = fpeak_data(out_ptr,NUM_SAMPLES);
|
//handle->level[0]=alg_compress_get_db(handle->halg)*100.0f;
|
//handle->level[1]=pg==0?-12000:2000*log10f(pg);
|
handle->level[0]=alg_compress_get_db(handle->halg)*100.0f;
|
handle->level[1]=alg_compress_get_output_db(handle->halg)*100.0f;
|
handle->period=0;
|
}
|
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}
|
else{
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
handle->level[0]= 0;
|
handle->level[1]= -12000;
|
handle->period=0;
|
}
|
}
|
|
return 0;
|
}
|
|
#if 0
|
int mixer_execute(pmixer_handle handle)
|
{
|
static float xin[MAX_MIXER_INPUT][NUM_SAMPLES];
|
static float xout[MAX_MIXER_OUTPUT][NUM_SAMPLES];
|
|
int i,j;
|
|
for(i=0;i<handle->input_num;i++){
|
memcpy(xin[i],get_rx_channel(handle->il_id[i]),NUM_SAMPLES);
|
}
|
|
alg_mixer_process2((float*)&xin, (float*)&xout, handle->gain, handle->output_num,handle->input_num,NUM_SAMPLES);
|
//alg_mixer_process5((const float**)xin, (float**)xout, handle->gain, handle->weight ,handle->output_num,handle->input_num,NUM_SAMPLES);
|
|
for(i=0;i<handle->output_num;i++){
|
memcpy(get_rx_channel(handle->ol_id[i]),xout[i],NUM_SAMPLES);
|
}
|
|
return 0;
|
|
}
|
#else
|
int mixer_execute(pmixer_handle handle)
|
{
|
int i, j;
|
|
for(i =0 ;i < handle->output_num ;i ++) {
|
float *xout = get_tx_channel(handle->ol_id[i]);
|
|
memset(xout, 0 , NUM_SAMPLES);
|
|
for(j =0 ;j < handle->input_num;j++) {
|
if(handle->mask[i][j/16]&(1<<(j&15))) {
|
alg_mixer_process(xout, get_rx_channel(handle->il_id[j]) ,xout, handle->gain[i][j], NUM_SAMPLES );
|
}
|
}
|
}
|
|
for(i=0;i<handle->output_num;i++){
|
exchange_ptr(handle->ol_id[i],handle->ol_id[i]);
|
}
|
|
return 0;
|
|
}
|
#endif
|
|
int crossover_execute(pcrossover_handle handle)
|
{
|
float* in_ptr ;
|
float* out_ptr ;
|
|
|
if(!handle->lowbypass){
|
in_ptr = get_rx_channel(handle->il_id[0]);
|
out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
alg_filter_process(handle->hLowalg,in_ptr,out_ptr);
|
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}
|
|
if(!handle->highbypass){
|
in_ptr = get_rx_channel(handle->il_id[0]);
|
out_ptr = get_tx_channel(handle->ol_id[0]);
|
alg_filter_process(handle->hHighalg,in_ptr,out_ptr);
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}
|
|
|
return 0;
|
}
|
|
int gain_execute(pgain_handle handle)
|
{
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
fgain_proc(in_ptr,out_ptr,&handle->old_gain,&handle->gain,NUM_SAMPLES);
|
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
|
return 0;
|
}
|
|
|
int output_execute(poutput_handle handle)
|
{
|
int i;
|
|
for(i=0;i<handle->output_num;i++){
|
float* in_ptr = get_rx_channel(handle->il_id[i]);
|
float* out_ptr = get_tx_channel(handle->ol_id[i]);
|
|
if(handle->output[i].mute){
|
if(handle->output[i].time>0){
|
fgain_step(in_ptr,out_ptr,&handle->output[i].old_gain,FADE_OUT_GAIN,handle->output[i].step_gain,NUM_SAMPLES);
|
handle->output[i].time --;
|
}
|
else{
|
memset(out_ptr, 0 ,NUM_SAMPLES);
|
}
|
//
|
}
|
else{
|
if(handle->output[i].gain <= -72.0){
|
memset(out_ptr, 0 ,NUM_SAMPLES);
|
}
|
else if(handle->output[i].time>0){
|
fgain_step(in_ptr,out_ptr,&handle->output[i].old_gain, handle->output[i].gain,handle->output[i].step_gain,NUM_SAMPLES);
|
handle->output[i].time --;
|
|
}
|
else{
|
fgain_proc(in_ptr,out_ptr,&handle->output[i].old_gain,&handle->output[i].gain,NUM_SAMPLES);
|
}
|
|
}
|
|
if(handle->output[i].phase){
|
vecsmltf(out_ptr, -1, out_ptr ,NUM_SAMPLES);
|
}
|
|
exchange_ptr(handle->il_id[i],handle->ol_id[i]);
|
}
|
|
return 0;
|
}
|
|
|
int feedback_execute(pfeedback_handle handle)
|
{
|
#if 1
|
int i,ret;
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
ptag_feedback pfeedback = handle->param_ptr;
|
|
alg_nhs_set_bypass(handle->halg, handle->bypass);
|
|
if(!handle->bypass){
|
alg_nhs_process(handle->halg,in_ptr,out_ptr);
|
//alg_nhs_process(handle->halg,in_ptr,out_ptr,handle->bypass);/////////////////////////////////
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
for(i=0;i<FEEDBACK_FILTERS_NUM;i++){
|
handle->level[2*i] = alg_nhs_get_unit_frequency(handle->halg,i);
|
handle->level[2*i+1] = alg_nhs_get_unit_gain(handle->halg,i)*100;
|
pfeedback->flt_group[i].fc = handle->level[2*i];
|
pfeedback->flt_group[i].gain = handle->level[2*i+1];
|
}
|
handle->period=0;
|
}
|
|
exchange_ptr(handle->ol_id[0], handle->ol_id[0]);
|
// feedback_num++;
|
}
|
else{
|
alg_nhs_process(handle->halg,in_ptr,out_ptr);
|
//alg_nhs_process(handle->halg,in_ptr,out_ptr,handle->bypass);/////////////////////////////////////////////
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
for(i=0;i<FEEDBACK_FILTERS_NUM;i++){
|
//handle->level[2*i] =20;
|
//handle->level[2*i+1]= 0;
|
handle->level[2*i] = alg_nhs_get_unit_frequency(handle->halg,i);
|
handle->level[2*i+1] = alg_nhs_get_unit_gain(handle->halg,i)*100;
|
}
|
handle->period=0;
|
}
|
}
|
#endif
|
return 0;
|
}
|
|
#if 1
|
int automixer_execute(pautomixer_handle handle)
|
{
|
int i;
|
float* pin[AUTOMIXER_CHANNEL_NUM];
|
float* pout[AUTOMIXER_CHANNEL_NUM+1];
|
|
if(handle->bypass){
|
memset(get_rx_channel(handle->input_num) ,0 , NUM_SAMPLES);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
for(i=0;i<handle->input_num;i++){
|
handle->level[2*i] = -12000;
|
handle->level[2*i+1]=-12000;
|
}
|
handle->period=0;
|
}
|
}
|
else{
|
for(i=0;i<handle->input_num;i++){
|
pin[i] = get_rx_channel(handle->il_id[i]);
|
pout[i] = get_tx_channel(handle->ol_id[i]);
|
}
|
pout[i] = get_tx_channel(handle->ol_id[i]);
|
|
alg_automixer_process(handle->halg,pin,pout);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
for(i=0;i<handle->input_num;i++){
|
handle->level[2*i] = alg_automixer_get_level(handle->halg,i)*100;
|
handle->level[2*i+1]=alg_automixer_get_autogain(handle->halg,i)*100;
|
}
|
handle->period=0;
|
}
|
for(i=0;i<handle->output_num;i++){
|
exchange_ptr(handle->ol_id[i], handle->ol_id[i]);
|
}
|
}
|
|
|
return 0;
|
}
|
#else
|
int automixer_execute(pautomixer_handle handle)
|
{
|
int i;
|
float* pin[AUTOMIXER_CHANNEL_NUM];
|
float* pout[AUTOMIXER_CHANNEL_NUM+1];
|
|
if(handle->bypass){
|
memset(get_rx_channel(handle->input_num) ,0 , NUM_SAMPLES);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
for(i=0;i<handle->input_num;i++){
|
handle->level[2*i] = -12000;
|
handle->level[2*i+1]=-12000;
|
}
|
handle->period=0;
|
}
|
}
|
else{
|
for(i=0;i<handle->input_num;i++){
|
pin[i] = get_rx_channel(handle->il_id[i]);
|
pout[i] = get_tx_channel(handle->ol_id[i]);
|
}
|
pout[i] = get_tx_channel(handle->ol_id[i]);
|
|
alg_pri_automixer_process(handle->halg,pin,pout);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
for(i=0;i<handle->input_num;i++){
|
handle->level[2*i] = alg_pri_automixer_get_level(handle->halg,i)*100;
|
handle->level[2*i+1]=alg_pri_automixer_get_autogain(handle->halg,i)*100;
|
}
|
handle->period=0;
|
}
|
for(i=0;i<handle->output_num;i++){
|
exchange_ptr(handle->ol_id[i], handle->ol_id[i]);
|
}
|
}
|
|
|
return 0;
|
}
|
#endif
|
|
int fir_execute(pcommon_handle handle)
|
{
|
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
if(!handle->bypass){
|
//alg_fir_process(handle->halg,in_ptr,out_ptr);
|
exchange_ptr(handle->ol_id[0],handle->ol_id[0]);
|
}
|
|
return 0;
|
}
|
|
|
int agc_execute(pagc_handle handle)
|
{
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
if(!handle->bypass){
|
|
alg_agc_process(handle->halg,in_ptr,out_ptr);
|
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
handle->level[0] = alg_agc_input_level(handle->halg)*100;
|
handle->level[1] = alg_agc_output_level(handle->halg)*100;
|
|
handle->period=0;
|
}
|
exchange_ptr(handle->ol_id[0], handle->ol_id[0]);
|
}
|
else{
|
handle->period++;
|
if (handle->period >= LEVEL_DETECT_PERIOD){
|
handle->level[0] = -12000;
|
handle->level[1]= -12000;
|
|
handle->period=0;
|
}
|
}
|
|
return 0;
|
}
|
|
int aec_execute(paec_handle handle)
|
{
|
#if 1
|
if(handle == NULL) {
|
return -1;
|
}
|
|
if(!handle->bypass){
|
float* ne_ptr = get_rx_channel(handle->il_id[0]);
|
float* far_ptr = get_rx_channel(handle->il_id[1]);
|
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
alg_aec_process(handle->halg,ne_ptr ,far_ptr, out_ptr);
|
|
exchange_ptr(handle->il_id[0],handle->ol_id[0]);
|
}
|
#endif
|
return 0;
|
}
|
|
int ans_execute(pans_handle handle)
|
{
|
if(handle == NULL) {
|
return -1;
|
}
|
|
if(!handle->bypass){
|
float* in_ptr = get_rx_channel(handle->il_id[0]);
|
float* out_ptr = get_tx_channel(handle->ol_id[0]);
|
|
alg_ans_process(handle->halg,in_ptr , out_ptr);
|
|
exchange_ptr(handle->il_id[0],handle->ol_id[0]);
|
}
|
|
return 0;
|
}
|
|
int sysctl_execute(psysctl_handle handle)
|
{
|
int i;
|
|
for(i=0;i<handle->input_num;i++){
|
float* in_ptr = get_rx_channel(handle->il_id[i]);
|
float* out_ptr = get_tx_channel(handle->ol_id[i]);
|
|
|
if(handle->mute){
|
if(handle->time>0){
|
fgain_step(in_ptr,out_ptr,&handle->old_gain[i],FADE_OUT_GAIN,handle->step_gain[i],NUM_SAMPLES);
|
handle->time --;
|
}
|
else{
|
memset(out_ptr, 0 ,NUM_SAMPLES);
|
}
|
}
|
else{
|
if(handle->time>0){
|
fgain_step(in_ptr,out_ptr,&handle->old_gain[i],handle->gain,handle->step_gain[i],NUM_SAMPLES);
|
handle->time --;
|
}
|
else{
|
fgain_proc(in_ptr,out_ptr,&handle->old_gain[i],&handle->gain,NUM_SAMPLES);
|
}
|
}
|
|
exchange_ptr(handle->il_id[i],handle->ol_id[i]);
|
}
|
return 0;
|
}
|
|
int selector_execute(pselector_handle handle)
|
{
|
int i,j;
|
|
for(i=0;i<handle->output_num;i++){
|
float* out_ptr = get_tx_channel(handle->ol_id[i]);
|
memset(out_ptr,0,NUM_SAMPLES);
|
|
for(j=0;j<handle->input_num;j++){
|
if((handle->mask[i][j/16]>>(j&15))&0x1){
|
float* in_ptr = get_rx_channel(handle->il_id[j]);
|
|
alg_mixer_process(out_ptr,in_ptr,out_ptr,0 ,NUM_SAMPLES);
|
}
|
}
|
}
|
|
for(j=0;j<handle->output_num;j++){
|
exchange_ptr(handle->ol_id[j],handle->ol_id[j]);
|
}
|
|
return 0;
|
}
|
|
|
