#include <string.h>
|
#include "drv/global.h"
|
#include "f2f.h"
|
#include "jitter.h"
|
#include <alg.h>
|
#include <math.h>
|
|
|
#define MAX_LOGIC_CHANNEL 36
|
|
extern int dual_dsp;
|
extern int dsp_index;
|
|
static float rx_channel[MAX_LOGIC_CHANNEL][NUM_SAMPLES];
|
static float tx_channel[MAX_LOGIC_CHANNEL][NUM_SAMPLES];
|
|
extern int sport1a_buf[2][NUM_SAMPLES*SLOTS];
|
extern int sport1b_buf[2][NUM_SAMPLES*SLOTS];
|
|
//usb
|
extern int sport2a_buf[2][NUM_SAMPLES*2];
|
extern int sport4a_buf[2][NUM_SAMPLES*2];
|
extern int sport5a_buf[2][NUM_SAMPLES*2];
|
|
extern int sport0a_buf[2][NUM_SAMPLES*SLOTS];
|
extern int sport0b_buf[2][NUM_SAMPLES*SLOTS];
|
|
|
|
|
extern int local_input_channels_num ;
|
extern int local_output_channels_num ;
|
extern int dante_input_channels_num ;
|
extern int dante_output_channels_num ;
|
|
|
//extern jitter_mem* pusb_input_jitter ;
|
//extern jitter_mem* pusb_output_jitter ;
|
float usb_input[NUM_SAMPLES], usb_output[NUM_SAMPLES];
|
|
|
float* rx_channel_ptr[]={
|
rx_channel[0],rx_channel[1],rx_channel[2],rx_channel[3]
|
,rx_channel[4],rx_channel[5],rx_channel[6],rx_channel[7]
|
,rx_channel[8],rx_channel[9],rx_channel[10] , rx_channel[11]
|
,rx_channel[12],rx_channel[13], rx_channel[14] ,rx_channel[15]
|
,rx_channel[16] ,rx_channel[17], rx_channel[18], rx_channel[19]
|
,rx_channel[20] ,rx_channel[21] ,rx_channel[22] ,rx_channel[23]
|
,rx_channel[24] ,rx_channel[25] ,rx_channel[26] ,rx_channel[27]
|
,rx_channel[28] ,rx_channel[29] ,rx_channel[30] ,rx_channel[31]
|
,rx_channel[32] ,rx_channel[33], rx_channel[34] ,rx_channel[35]
|
};
|
|
float* tx_channel_ptr[]={
|
tx_channel[0] ,tx_channel[1] ,tx_channel[2] ,tx_channel[3]
|
,tx_channel[4] ,tx_channel[5] ,tx_channel[6] ,tx_channel[7]
|
,tx_channel[8] ,tx_channel[9] ,tx_channel[10] ,tx_channel[11]
|
,tx_channel[12] ,tx_channel[13] ,tx_channel[14] ,tx_channel[15]
|
,tx_channel[16] ,tx_channel[17], tx_channel[18] ,tx_channel[19]
|
,tx_channel[20] ,tx_channel[21] ,tx_channel[22] ,tx_channel[23]
|
,tx_channel[24] ,tx_channel[25] ,tx_channel[26] ,tx_channel[27]
|
,tx_channel[28] ,tx_channel[29] ,tx_channel[30] ,tx_channel[31]
|
,tx_channel[32] ,tx_channel[33], tx_channel[34] ,tx_channel[35]
|
};
|
|
// Structures to hold floating point data for each AD1939
|
//ad1939_float_data fBlockA;
|
|
inline void floatData(float *output, const int *input, unsigned int instep, unsigned int length)
|
{
|
int i;
|
|
|
for(i = 0; i < length; i++)
|
{
|
output[i] = __builtin_conv_RtoF(input[instep*i]);
|
}
|
}
|
|
|
// Unoptimized function to convert the outgoing floating-point data to 1.31 fixed-point format.
|
inline void fixData(int *output, const float *input, unsigned int outstep, unsigned int length)
|
{
|
int i;
|
|
for(i = 0; i < length; i++)
|
{
|
output[outstep*i] = __builtin_conv_FtoR(input[i]);
|
}
|
}
|
|
|
void input_fflush(const unsigned int blockIndex)
|
{
|
extern int input_num_channels;
|
extern int usb_dma_count, dma_count;
|
|
floatData( get_rx_channel(0), sport1a_buf[blockIndex]+7,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(1), sport1a_buf[blockIndex]+6,SLOTS, NUM_SAMPLES);
|
|
floatData( get_rx_channel(2), sport1a_buf[blockIndex]+5,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(3), sport1a_buf[blockIndex]+4,SLOTS, NUM_SAMPLES);
|
|
if(input_num_channels > 4){
|
floatData( get_rx_channel(4), sport1a_buf[blockIndex]+3,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(5), sport1a_buf[blockIndex]+2,SLOTS, NUM_SAMPLES);
|
|
floatData( get_rx_channel(6), sport1a_buf[blockIndex]+1,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(7), sport1a_buf[blockIndex]+0,SLOTS, NUM_SAMPLES);
|
}
|
|
if(input_num_channels > 8) {
|
floatData( get_rx_channel(8), sport1b_buf[blockIndex]+7,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(9), sport1b_buf[blockIndex]+6,SLOTS, NUM_SAMPLES);
|
|
floatData( get_rx_channel(10), sport1b_buf[blockIndex]+5,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(11), sport1b_buf[blockIndex]+4,SLOTS, NUM_SAMPLES);
|
|
floatData( get_rx_channel(12), sport1b_buf[blockIndex]+3,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(13), sport1b_buf[blockIndex]+2,SLOTS, NUM_SAMPLES);
|
|
floatData( get_rx_channel(14), sport1b_buf[blockIndex]+1,SLOTS, NUM_SAMPLES);
|
floatData( get_rx_channel(15), sport1b_buf[blockIndex]+0,SLOTS, NUM_SAMPLES);
|
}
|
|
memcpy(get_rx_channel(input_num_channels+1), usb_input, NUM_SAMPLES);
|
|
}
|
|
|
void usb_input_fflush(const unsigned int blockIndex)
|
{
|
int i=0;
|
float diff =0;
|
float f =0;
|
|
floatData(usb_input, sport5a_buf[blockIndex]+0,2, NUM_SAMPLES);//
|
|
for(i=1;i<NUM_SAMPLES;i++) {
|
f = fabs(usb_input[i] - usb_input[i-1]);
|
if(f > diff){
|
diff = f;
|
}
|
}
|
|
if(diff <= 0.00001){
|
memset(usb_input, 0, NUM_SAMPLES);
|
}
|
}
|
|
|
void usb_output_fflush(const unsigned int blockIndex)
|
{
|
|
fixData(sport4a_buf[blockIndex]+0, usb_output, 2, NUM_SAMPLES);
|
fixData(sport4a_buf[blockIndex]+1, usb_output, 2, NUM_SAMPLES);
|
}
|
|
void output_empty(void)
|
{
|
int i;
|
|
for(i=0;i<MAX_LOGIC_CHANNEL;i++){
|
memset(get_rx_channel(i),0,NUM_SAMPLES);
|
}
|
}
|
|
|
|
void output_fflush(const unsigned int blockIndex)
|
{
|
extern int output_num_channels;
|
|
#if 0
|
#include <math.h>
|
int i;
|
float pcm[NUM_SAMPLES];
|
// float pcm2[NUM_SAMPLES];
|
static int t=0;
|
|
for(i=0;i<NUM_SAMPLES;i++){
|
pcm[i] = 0.5*sinf(2*3.1415926*1000*t/48000);
|
// pcm2[i]=0xbebeafad;
|
t++;
|
}
|
if(t>=48000){
|
t =0;
|
}
|
#endif
|
fixData(sport0a_buf[blockIndex]+7, get_rx_channel(0), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+6, get_rx_channel(1), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+5, get_rx_channel(2), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+4, get_rx_channel(3), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+3, get_rx_channel(4), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+2, get_rx_channel(5), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+1, get_rx_channel(6), SLOTS, NUM_SAMPLES);
|
fixData(sport0a_buf[blockIndex]+0, get_rx_channel(7), SLOTS, NUM_SAMPLES);
|
|
if(output_num_channels > 8) {
|
fixData(sport0b_buf[blockIndex]+7, get_rx_channel(8), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+6, get_rx_channel(9), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+5, get_rx_channel(10), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+4, get_rx_channel(11), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+3, get_rx_channel(12), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+2, get_rx_channel(13), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+1, get_rx_channel(14), SLOTS, NUM_SAMPLES);
|
fixData(sport0b_buf[blockIndex]+0, get_rx_channel(15), SLOTS, NUM_SAMPLES);
|
}
|
|
//to usb.
|
memcpy(usb_output,get_rx_channel(output_num_channels) ,NUM_SAMPLES);
|
}
|
