#include <std.h>
#include <log.h>
#include <swi.h>
#include "echocfg.h"
#include "echo.h"

int cancelerLoad = 0;
int decoderLoad = 0;
int encoderLoad = 0;

int echoInFrame  = 0;           			// 當前回音輸入幀數(shù)量
int echoOutFrame = 2;           			// 當前回音輸出幀數(shù)量
int encoderFrame  = 0;          			// 當前語音輸入幀數(shù)量
int decoderFrame  = 0;          			// 當前語音輸出幀數(shù)量

int audioInBuf[AUDIOBUFLEN];    			// 語音輸入數(shù)據(jù)
int audioOutBuf[AUDIOBUFLEN];   			// 語音輸出數(shù)據(jù)
int codeInBuf[CODEBUFLEN];       		// 編碼輸入數(shù)據(jù)
int codeOutBuf[CODEBUFLEN];    			// 編碼輸出數(shù)據(jù)

extern Void ECHO_load(int load);
static Void cancelerAlg(int *input, int *output);
static Void decoderAlg(int *input, int *output);
static Void encoderAlg(int *input, int *output);

Void main(int argc, char *argv[])
{
    									// 循環(huán)等待
}

Void canceler(Void)
{
    int *src, *dst;    
    src = audioInBuf + (echoInFrame * ECHOFRAMELEN);
    dst = audioOutBuf + (echoOutFrame * ECHOFRAMELEN);
    
    cancelerAlg(src, dst);
    if (++echoInFrame >= (AUDIOBUFLEN / ECHOFRAMELEN)) {
        echoInFrame = 0;
    }
    if (++echoOutFrame >= (AUDIOBUFLEN / ECHOFRAMELEN)) {
        echoOutFrame = 0;
    }
}

Void decoder(Void)
{
    int *src, *dst;
    src = codeInBuf + (decoderFrame * CODEFRAMELEN);
    dst = audioOutBuf + (decoderFrame * AUDIOFRAMELEN);

    decoderAlg(src, dst);
    if (++decoderFrame >= (AUDIOBUFLEN / AUDIOFRAMELEN)) {
        decoderFrame = 0;
    }
}

Void encoder(Void)
{
    int *src, *dst;    
    src = audioInBuf + (encoderFrame * AUDIOFRAMELEN);
    dst = codeOutBuf + (encoderFrame * CODEFRAMELEN);
    encoderAlg(src, dst);

    if (++encoderFrame >= (AUDIOBUFLEN / AUDIOFRAMELEN)) {
        encoderFrame = 0;
    }
}

static Void cancelerAlg(int *input, int *output)
{
    static int oldLoad = 0;    
    if (oldLoad != cancelerLoad) {
        oldLoad = cancelerLoad;
        LOG_printf(&trace,
            "Cancel: new load = %d000 instructions every 2.5 ms", cancelerLoad);
    }
    
    if (cancelerLoad) {
        ECHO_load(cancelerLoad);
    }
}

static Void decoderAlg(int *input, int *output)
{
    static int oldLoad = 0;    
    if (oldLoad != decoderLoad) {
        oldLoad = decoderLoad;
        LOG_printf(&trace,
            "Decode: new load = %d000 instructions every 22.5 ms", decoderLoad);
    }
    
    if (decoderLoad) {
        ECHO_load(decoderLoad);
    }
}

static Void encoderAlg(int *input, int *output)
{
    static int oldLoad = 0;    
    if (oldLoad != encoderLoad) {
        oldLoad = encoderLoad;
        LOG_printf(&trace,
            "Encode: new load = %d000 instructions every 22.5 ms", encoderLoad);
    }
    
    if (encoderLoad) {
        ECHO_load(encoderLoad);
    }
}