fader在音频处理中是比较基础的处理。通常用于平滑的调节音量，或是音频的渐入和渐出效果。

比较常见的fader有line和cubic线型的fader。

line fader即fader的渐变过程是线性的。cubic的渐变过程是三次曲线。

fader主要有三个参数，attuationDb, type, timeMs.

line fader：

通过当前的音量curVolumDb，计算fader的初始gain值：startGain = dbToGain(curVolumDb)

fader结束音量为curVolumDb + attuationDb,那么fader结束的gain值为：endGain = dbToGain(curVolumDb + curVolumDb)

将fader的开始到结束的时间timeMs转化为sample为单位：timeInSample = timeMs * sampleRate / 1000.

那么line fader的step为：step = (endGain - startGain) / timeInSample.

初始化curSample为0， curGain= startGain.

每处理一个sample(sample * curGain), curSample加1. curGain加step，直至curSample等于timeInSample,整个fader过程结束。

5s内衰减5db

5s时间fader in

cubic fader:

cubic fader的原理为，将0~1划分为多个段（假设为segNum）。计算每个Segment端点的gain值：segGain.

由于有segNum个段，那么0~1被离散为segNum + 1个点，每个点的segGain[n]值为（n/(segNum +1)）^3. n=0,1,2...segNum+1;

将0~1之间的segGain map到startGain ~ endGain之间。

对于0~timeInSample之间的点，我们计算当前的sample处于哪个segment,当curSample是当前segment的第一个点时，将curGain设置成segGain[n].

当前segment按line fader一样的方法计算每个点的gain，每处理一个sample, curGain加step.

5s内衰减5db

5s时间fader in

实现代码如下：

在main函数创建两个thread，readThread, ppThread.

readThread每次读取wav文件256个sample，并每次取出64 sample转化成non-interleave的数据，发送到ppThread中。

定义一个全局的三维数组gPpBuf[chNum][bankNum][sampleNum]，将转化成non-interleave的数据放到数组中，维护rp和wp来记录readThread和ppThread的当前读写的bank位置。

在ppThread中，每次接收到64sample做fader处理。

#include<stdio.h>

#include<stdlib.h>

#include<errno.h>

#include<string.h>

#include<pthread.h>

#include<math.h>

typedef struct{

char chunkId[];//"RIFF"

unsigned long chunkSize;

char format[];//"WAVE"

}WAVE_RIFF;

typedef struct{

char chunkId[];//"fmt"

unsigned long chunkSize;

unsigned short audioFormat;

unsigned short chNum;

unsigned long sampleRate;

unsigned long byteRate;//SampleRate * NumChannels * BitsPerSample/8

unsigned short blockAlign;//NumChannels * BitsPerSample/8

unsigned short bitsPerSample;//8,16,32

}WAVE_FMT;

typedef struct{

char chunkId[];//"data"

unsigned long chunkSize;//NumSamples * NumChannels * BitsPerSample/8

}WAVE_DATA;

typedef struct

{

    char fileName[];

    FILE *fp;

    long pos;

    unsigned long totalSampleNum;

    WAVE_RIFF riffChunk;

    WAVE_FMT fmtChunk;

    WAVE_DATA dataChunk;

}WAVE_INFO;

#define READ_SAMPLES 256

#define PP_SAMPLES 64

typedef struct

{

    unsigned short chNum;

    unsigned short bankNum;

    unsigned long samplesPerBank;

    unsigned short bytesPerSample;

    unsigned short bankRp;

    unsigned short bankWp;

    unsigned char ***pData;

    unsigned char fgEos;

}PP_BUF_T;

typedef enum

{

    FADER_TYPE_LINE,

    FADER_TYPE_CUBIC,

}FADER_TYPE_E;

typedef struct

{

    float attuationDb;

    FADER_TYPE_E type;

    unsigned long timeMs;

}FADER_PARAM_T;

typedef struct

{

    FADER_PARAM_T faderParams;

    unsigned long timeInSample;

    float curVolumDb;

    float curGain;

    float startGain;

    float targetGain;

    unsigned long curSample;

    unsigned long sampleRate;

    float *segGain;

    unsigned short segNum;

}FADER_HANDLE_T;

typedef struct

{

    short **pData;

    unsigned short chNum;

    unsigned short samples;

    unsigned short bytesPerSample;

}DATA_INFO_T;

PP_BUF_T gPpBuf;

FADER_HANDLE_T gFaderHandle;

unsigned char fgEnd = ;

float mapSegGainToRealGain(FADER_HANDLE_T *pFaderHandle, float segGain)

{

    float deltaGain = pFaderHandle->targetGain - pFaderHandle->startGain;

    float realGain = deltaGain * segGain + pFaderHandle->startGain;

    return realGain;

}

void faderPrepareShape(FADER_HANDLE_T *pFaderHandle, unsigned short segNum)

{

    unsigned short segIdx;

    pFaderHandle->segGain = (float *)malloc((segNum + ) * sizeof(float));

    pFaderHandle->segNum = segNum;

    float tmp;

    if (pFaderHandle->faderParams.type != FADER_TYPE_CUBIC)

         return;

    //0~1 divide into N seg.

    for (segIdx = ; segIdx < segNum + ; segIdx++)

    {

        tmp = (float)segIdx / segNum;

        pFaderHandle->segGain[segIdx] = tmp * tmp * tmp;

        pFaderHandle->segGain[segIdx] = mapSegGainToRealGain(pFaderHandle, pFaderHandle->segGain[segIdx]);

    }

}

float dbToGain(float db)

{

    return pow(, db/);

}

void faderInit(FADER_HANDLE_T *pFaderHandle, float attuationDb, FADER_TYPE_E type, unsigned long timeMs, unsigned long sampleRate, float curVolumDb)

{

    pFaderHandle->faderParams.attuationDb = attuationDb;

    pFaderHandle->faderParams.type = type;

    pFaderHandle->faderParams.timeMs = timeMs;

    pFaderHandle->timeInSample = timeMs * sampleRate / ;

    pFaderHandle->curGain = pFaderHandle->startGain = dbToGain(curVolumDb);

    pFaderHandle->targetGain = dbToGain(curVolumDb + attuationDb);

    pFaderHandle->curSample = ;

    faderPrepareShape(pFaderHandle, );

    printf("faderInit\n");

}

void faderCalGain(FADER_HANDLE_T *pFaderHandle)

{

    printf("faderCalcGain\n");

    float startGainInCurSeg, endGainInCurSeg, step;

    float deltaGain = pFaderHandle->targetGain - pFaderHandle->startGain;

    unsigned long samplesInSeg = pFaderHandle->timeInSample / pFaderHandle->segNum;

    unsigned short curSeg = (float)pFaderHandle->curSample / samplesInSeg;

    unsigned long startSampleInCurSeg = samplesInSeg * curSeg;

    switch (pFaderHandle->faderParams.type)

    {

        case FADER_TYPE_LINE:

            step = deltaGain / pFaderHandle->timeInSample;

            pFaderHandle->curGain += deltaGain / pFaderHandle->timeInSample;

            //pFaderHandle->curGain = pFaderHandle->startGain + deltaGain * pFaderHandle->curSample / pFaderHandle->timeInSample;

            break;

        case FADER_TYPE_CUBIC:

            startGainInCurSeg = pFaderHandle->segGain[curSeg];

            endGainInCurSeg = pFaderHandle->segGain[curSeg + ];

            step = (endGainInCurSeg - startGainInCurSeg) / samplesInSeg;

            if (pFaderHandle->curSample == startSampleInCurSeg)

                pFaderHandle->curGain = startGainInCurSeg;

            else

                pFaderHandle->curGain += step;

            break;

    }

    printf("curGain:%f, curSample:%ld, timeInSample:%ld\n", pFaderHandle->curGain, pFaderHandle->curSample, pFaderHandle->timeInSample);

}

void fader(FADER_HANDLE_T *pFaderHandle, DATA_INFO_T *pDataInfo)

{

    unsigned short sampleIdx, chIdx;

    for (sampleIdx = ; sampleIdx < pDataInfo->samples; sampleIdx++)

    {

        if (pFaderHandle->curSample != pFaderHandle->timeInSample)

        {

            faderCalGain(pFaderHandle);

            pFaderHandle->curSample++;

        }

        for (chIdx = ; chIdx < pDataInfo->chNum; chIdx++)

        {

            pDataInfo->pData[chIdx][sampleIdx] *= pFaderHandle->curGain;

        }

    }

}

void printWaveHeader(WAVE_INFO *pWaveInfo)

{

    printf("fileName:%s\n", pWaveInfo->fileName);

    printf("riff chunk:\n");

    printf("chunkId:%c%c%c%c\n", pWaveInfo->riffChunk.chunkId[], pWaveInfo->riffChunk.chunkId[], pWaveInfo->riffChunk.chunkId[], pWaveInfo->riffChunk.chunkId[]);

    printf("chunkSize:%ld\n", pWaveInfo->riffChunk.chunkSize);

    printf("format:%c%c%c%c\n", pWaveInfo->riffChunk.format[], pWaveInfo->riffChunk.format[], pWaveInfo->riffChunk.format[], pWaveInfo->riffChunk.format[]);

    printf("fmt chunk:\n");

    printf("chunkId:%c%c%c\n", pWaveInfo->fmtChunk.chunkId[], pWaveInfo->fmtChunk.chunkId[], pWaveInfo->fmtChunk.chunkId[]);

    printf("chunkSize:%ld\n", pWaveInfo->fmtChunk.chunkSize);

    printf("audioFormat:%d\n", pWaveInfo->fmtChunk.audioFormat);

    printf("chNum:%d\n", pWaveInfo->fmtChunk.chNum);

    printf("sampleRate:%ld\n", pWaveInfo->fmtChunk.sampleRate);

    printf("byteRate:%ld\n", pWaveInfo->fmtChunk.byteRate);

    printf("blockAlign:%d\n", pWaveInfo->fmtChunk.blockAlign);

    printf("bitsPerSample:%d\n", pWaveInfo->fmtChunk.bitsPerSample);

    printf("data chunk:\n");

    printf("chunkId:%c%c%c%c\n", pWaveInfo->dataChunk.chunkId[], pWaveInfo->dataChunk.chunkId[], pWaveInfo->dataChunk.chunkId[], pWaveInfo->dataChunk.chunkId[]);

    printf("chunkSize:%ld\n", pWaveInfo->dataChunk.chunkSize);

}

void initWaveInfo(WAVE_INFO *pWaveInfo, unsigned short chNum, unsigned long sampleRate, unsigned short bitsPerSample)

{

    //strncpy(pWaveInfo->riffChunk.chunkId, "RIFF", 4);

    pWaveInfo->riffChunk.chunkId[] = 'R';

    pWaveInfo->riffChunk.chunkId[] = 'I';

    pWaveInfo->riffChunk.chunkId[] = 'F';

    pWaveInfo->riffChunk.chunkId[] = 'F';

    pWaveInfo->riffChunk.chunkSize = ;

    //strncpy(pWaveInfo->riffChunk.format, "WAVE", 4);

    pWaveInfo->riffChunk.format[] = 'W';

    pWaveInfo->riffChunk.format[] = 'A';

    pWaveInfo->riffChunk.format[] = 'V';

    pWaveInfo->riffChunk.format[] = 'E';

    //strncpy(pWaveInfo->fmtChunk.chunkId, "fmt", 3);

    pWaveInfo->fmtChunk.chunkId[] = 'f';

    pWaveInfo->fmtChunk.chunkId[] = 'm';

    pWaveInfo->fmtChunk.chunkId[] = 't';

    pWaveInfo->fmtChunk.chunkId[] = ' ';

    pWaveInfo->fmtChunk.chunkSize = sizeof(WAVE_FMT) - ;

    pWaveInfo->fmtChunk.audioFormat = ;

    pWaveInfo->fmtChunk.chNum = chNum;

    pWaveInfo->fmtChunk.sampleRate = sampleRate;

    pWaveInfo->fmtChunk.byteRate = sampleRate * chNum * bitsPerSample / ;

    pWaveInfo->fmtChunk.blockAlign = chNum * bitsPerSample / ;

    pWaveInfo->fmtChunk.bitsPerSample = bitsPerSample;

    //strncpy(pWaveInfo->dataChunk.chunkId, "data", 4);

    pWaveInfo->dataChunk.chunkId[] = 'd';

    pWaveInfo->dataChunk.chunkId[] = 'a';

    pWaveInfo->dataChunk.chunkId[] = 't';

    pWaveInfo->dataChunk.chunkId[] = 'a';

    pWaveInfo->dataChunk.chunkSize = ;

    pWaveInfo->totalSampleNum = ;

    ///printWaveHeader(pWaveInfo);

}

void rwRiffChunk(WAVE_INFO *pWaveInfo, unsigned char fgRead)

{

    if (fgRead)

    {

        fread((char *)&pWaveInfo->riffChunk.chunkId, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->riffChunk.chunkSize, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->riffChunk.format, , , pWaveInfo->fp);

    }

    else

    {

        fwrite((char *)&pWaveInfo->riffChunk.chunkId, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->riffChunk.chunkSize, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->riffChunk.format, , , pWaveInfo->fp);

    }

}

void rwFmtChunk(WAVE_INFO *pWaveInfo, unsigned char fgRead)

{

    if (fgRead)

    {

        fread((char *)&pWaveInfo->fmtChunk.chunkId, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.chunkSize, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.audioFormat, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.chNum, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.sampleRate, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.byteRate, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.blockAlign, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->fmtChunk.bitsPerSample, , , pWaveInfo->fp);

    }

    else

    {

        fwrite((char *)&pWaveInfo->fmtChunk.chunkId, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.chunkSize, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.audioFormat, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.chNum, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.sampleRate, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.byteRate, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.blockAlign, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->fmtChunk.bitsPerSample, , , pWaveInfo->fp);

    }

}

void rwDataChunk(WAVE_INFO *pWaveInfo, unsigned char fgRead)

{

    if (fgRead)

    {

        fread((char *)&pWaveInfo->dataChunk.chunkId, , , pWaveInfo->fp);

        fread((char *)&pWaveInfo->dataChunk.chunkSize, , , pWaveInfo->fp);

    }

    else

    {

        fwrite((char *)&pWaveInfo->dataChunk.chunkId, , , pWaveInfo->fp);

        fwrite((char *)&pWaveInfo->dataChunk.chunkSize, , , pWaveInfo->fp);

    }

}

void readWaveHeader(char *fileName, WAVE_INFO *pWaveInfo)

{

    size_t retSize;

    strncpy(pWaveInfo->fileName, fileName, strlen(fileName));

    pWaveInfo->fp = fopen(fileName, "rb");

    if (pWaveInfo->fp == NULL)

    {

        printf("fopen fail, errno:%d\n", errno);

        return;

    }

    #if 0

    retSize = fread((char *)&pWaveInfo->riffChunk, sizeof(WAVE_RIFF), , pWaveInfo->fp);

    retSize = fread((char *)&pWaveInfo->fmtChunk, sizeof(WAVE_FMT), , pWaveInfo->fp);

    retSize = fread((char *)&pWaveInfo->dataChunk, sizeof(WAVE_DATA), , pWaveInfo->fp);

    #endif

    rwRiffChunk(pWaveInfo, );

    rwFmtChunk(pWaveInfo, );

    rwDataChunk(pWaveInfo, );

    pWaveInfo->pos = ftell(pWaveInfo->fp);

    pWaveInfo->totalSampleNum = pWaveInfo->dataChunk.chunkSize / (pWaveInfo->fmtChunk.bitsPerSample / );

    fclose(pWaveInfo->fp);

    printWaveHeader(pWaveInfo);

}

void initPpBuf(unsigned short chNum, unsigned short bankNum, unsigned long samplesPerBank, unsigned short bytesPerSample)

{

    unsigned short chIdx, bankIdx;

    gPpBuf.chNum = chNum;

    gPpBuf.bankNum = bankNum;

    gPpBuf.samplesPerBank = samplesPerBank;

    gPpBuf.bytesPerSample = bytesPerSample;

    gPpBuf.bankRp = gPpBuf.bankWp = ;

    gPpBuf.fgEos = ;

    gPpBuf.pData = (unsigned char ***)malloc(chNum * sizeof(unsigned char **));

    for (chIdx = ; chIdx < chNum; chIdx++)

    {

        gPpBuf.pData[chIdx] = (unsigned char **)malloc(bankNum * sizeof(unsigned char *));

        for (bankIdx =; bankIdx < bankNum; bankIdx++)

        {

            gPpBuf.pData[chIdx][bankIdx] = (unsigned char *) malloc(samplesPerBank * bytesPerSample * sizeof(unsigned char));

        }

    }

}

int sendData(unsigned char *writeBuffer, unsigned short chNum)

{

    unsigned short sampleIdx, chIdx, byteIdx;

    //printf("sendData, wp:%d, rp:%d\n", gPpBuf.bankWp, gPpBuf.bankRp);

    if ((gPpBuf.bankWp +  ) % gPpBuf.bankNum == gPpBuf.bankRp)

    {

        //full

        return ;

    }

    else

    {

        for (sampleIdx = ; sampleIdx < PP_SAMPLES; sampleIdx++)

        {

            for (chIdx =; chIdx < chNum; chIdx++)

            {

                for (byteIdx = ; byteIdx < gPpBuf.bytesPerSample; byteIdx++)

                {

               gPpBuf.pData[chIdx][gPpBuf.bankWp][sampleIdx * gPpBuf.bytesPerSample + byteIdx] = writeBuffer[(chIdx + sampleIdx * chNum) * gPpBuf.bytesPerSample + byteIdx];

          }

            }

        }

        gPpBuf.bankWp = (gPpBuf.bankWp + ) % gPpBuf.bankNum;

    }

    return ;

}

int recvData(unsigned char **readBuffer)

{

    unsigned short chIdx;

    //printf("recvData, wp:%d, rp:%d\n", gPpBuf.bankWp, gPpBuf.bankRp);

    if (gPpBuf.bankWp == gPpBuf.bankRp)

    {

        //empty

        return ;

    }

    else

    {

        for (chIdx = ; chIdx < gPpBuf.chNum; chIdx++)

        {

            memcpy(&readBuffer[chIdx][], &gPpBuf.pData[chIdx][gPpBuf.bankRp][], PP_SAMPLES * gPpBuf.bytesPerSample * sizeof(unsigned char));

        }

        gPpBuf.bankRp = (gPpBuf.bankRp + ) % gPpBuf.bankNum;

    }

    return ;

}

void *readThread(void *arg)

{

    char *fileName = (char *)arg;

    size_t retSize;

    WAVE_INFO waveInfo;

    memset(&waveInfo, , sizeof(WAVE_INFO));

    unsigned long bytesPerLoop;

    unsigned short loopIdx, loop;

    unsigned long readCount = ;

    readWaveHeader(fileName, &waveInfo);

    unsigned long readSize = READ_SAMPLES * waveInfo.fmtChunk.chNum * waveInfo.fmtChunk.bitsPerSample / ;

    printf("readSize:%ld\n", readSize);

    unsigned char *readBuffer = (unsigned char *)malloc(readSize * sizeof(unsigned char));

    waveInfo.fp = fopen(fileName, "rb");

    fseek(waveInfo.fp,  waveInfo.pos, SEEK_SET);

    while ()

    {

        retSize = fread(readBuffer, readSize, , waveInfo.fp);

        if (retSize <= )

        {

             printf("fread fail,retSize:%d, %s, eof:%d, readCount:%ld\n", (int) retSize, strerror(errno), feof(waveInfo.fp), readCount);

             gPpBuf.fgEos = ;

             break;

        }

        else

        {

             bytesPerLoop = PP_SAMPLES *waveInfo.fmtChunk.chNum * waveInfo.fmtChunk.bitsPerSample / ;

             loop = readSize / bytesPerLoop;

             loopIdx = ;

             while (loopIdx < loop)

             {

                 if ( != sendData(readBuffer + loopIdx * bytesPerLoop, waveInfo.fmtChunk.chNum))

                 {

                     usleep();

                 }

                 else

                 {

                     loopIdx++;

                 }

             }

             readCount++;

        }

    }

    return NULL;

}

void pp(DATA_INFO_T *pDataInfo)

{

    fader(&gFaderHandle, pDataInfo);

}

void saveOneChInWave(unsigned char *pData, unsigned long size, WAVE_INFO *pWaveInfo)

{

   size_t retSize = ;

   if (pWaveInfo->fp == NULL)

   {

       pWaveInfo->fp = fopen(pWaveInfo->fileName, "wb");

       #if 0

       retSize = fwrite((char *)&pWaveInfo->riffChunk, sizeof(WAVE_RIFF), , pWaveInfo->fp);

       retSize = fwrite((char *)&pWaveInfo->fmtChunk, sizeof(WAVE_FMT), , pWaveInfo->fp);

        retSize = fwrite((char *)&pWaveInfo->dataChunk, sizeof(WAVE_DATA), , pWaveInfo->fp);

        #endif

        rwRiffChunk(pWaveInfo, );

        rwFmtChunk(pWaveInfo, );

        rwDataChunk(pWaveInfo, );

    }

    retSize = fwrite(pData, size, , pWaveInfo->fp);

    pWaveInfo->totalSampleNum += (size / pWaveInfo->fmtChunk.chNum / (pWaveInfo->fmtChunk.bitsPerSample / ));

    pWaveInfo->pos = ftell(pWaveInfo->fp);

}

void updateWaveHeader(WAVE_INFO *pWaveInfo)

{

    size_t retSize;

    pWaveInfo->riffChunk.chunkSize = pWaveInfo->pos - ;

    pWaveInfo->dataChunk.chunkSize = pWaveInfo->totalSampleNum * pWaveInfo->fmtChunk.chNum * pWaveInfo->fmtChunk.bitsPerSample / ;

    fseek(pWaveInfo->fp,  , SEEK_SET);

    #if 0

    retSize = fwrite((char *)&pWaveInfo->riffChunk, sizeof(WAVE_RIFF), , pWaveInfo->fp);

    retSize = fwrite((char *)&pWaveInfo->fmtChunk, sizeof(WAVE_FMT), , pWaveInfo->fp);

    retSize = fwrite((char *)&pWaveInfo->dataChunk, sizeof(WAVE_DATA), , pWaveInfo->fp);

    #endif

    rwRiffChunk(pWaveInfo, );

    rwFmtChunk(pWaveInfo, );

    rwDataChunk(pWaveInfo, );

    fclose(pWaveInfo->fp);

    printWaveHeader(pWaveInfo);

}

void *ppThread(void *arg)

{

    char *fileName = (char *)arg;

    WAVE_INFO waveInfo;

    memset(&waveInfo, , sizeof(waveInfo));

    strncpy(waveInfo.fileName, fileName, strlen(fileName));

    printf("out file:%s\n", waveInfo.fileName);

    waveInfo.fp = NULL;

    initWaveInfo(&waveInfo, , , );

    unsigned char **readBuffer = (unsigned char **)malloc(gPpBuf.chNum * sizeof(unsigned char *));

    unsigned short chIdx;

    for(chIdx = ; chIdx < gPpBuf.chNum; chIdx++)

    {

        readBuffer[chIdx] = (unsigned char *)malloc(PP_SAMPLES * gPpBuf.bytesPerSample * sizeof(unsigned char));

    }

    while ()

    {

        if ( != recvData(readBuffer))

        {

            if (gPpBuf.fgEos)

                break;

            usleep();

        }

        else

        {

            DATA_INFO_T dataInfo;

            dataInfo.chNum = gPpBuf.chNum;

            dataInfo.samples = PP_SAMPLES;

            dataInfo.bytesPerSample = gPpBuf.bytesPerSample;

            dataInfo.pData = (short **)readBuffer;

            pp(&dataInfo);

            saveOneChInWave(readBuffer[], PP_SAMPLES * gPpBuf.bytesPerSample, &waveInfo);

        }

    }

    updateWaveHeader(&waveInfo);

    fgEnd = ;

}

int main(int argc, char **argv)

{

#if 0

    WAVE_INFO inputWaveInfo, outputWaveInfo;

    readWaveHeader(argv[], &inputWaveInfo);

    //initWaveInfo(&outputWaveInfo, 2, 48000, 16);

#endif

#if 1

    pthread_t readThreadId, ppThreadId;

    initPpBuf(, , PP_SAMPLES, );

    memset(&gFaderHandle, , sizeof(FADER_HANDLE_T));

    float curVolumDb = -;

    float attuationDb = ;

    FADER_TYPE_E type = FADER_TYPE_LINE;

    unsigned long timeMs = ;

    unsigned long sampleRate = ;

    faderInit(&gFaderHandle, attuationDb, type, timeMs, sampleRate, curVolumDb);

    pthread_create(&readThreadId, NULL, readThread, argv[]);

    pthread_create(&ppThreadId, NULL, ppThread, argv[]);

    while(!fgEnd)

    {

        sleep();

    }

#endif

    return ;

}

最新文章

  1. 数据库（Database）
  2. [ACM_几何] Wall
  3. 设计模式学习之单例模式（Singleton,创建型模式）（4）
  4. The Brain vs Deep Learning Part I: Computational Complexity — Or Why the Singularity Is Nowhere Near
  5. 网络流sap算法模版
  6. maven系列（1）-maven的介绍与安装
  7. 破解网络投票IP限制、验证码限制、COokie限制、Seesion限制的方法!（转）
  8. php中CURL技术模拟登陆抓取数据实战，抓取某校教务处学生成绩。
  9. Python函数式编程初级学习
  10. SequoiaDB 架构指南
  11. Base64编码和解码算法
  12. javascript的函数相关属性和方法
  13. android studio 9.png 报错
  14. AJAX请求小项目
  15. linux查看硬盘占用情况
  16. js 元素大小缩放实例
  17. VS Code使用 Vue工程配置 eslint
  18. Redis热点Key发现及常见解决方案！
  19. 根据百度API获得经纬度，然后根据经纬度在获得城市信息
  20. spark提交任务的两种的方法

热门文章

  1. CTF长久练习平台
  2. ArcGIS Server Manager 重置密码
  3. C++11智能指针（unique_ptr、shared_ptr、weak_ptr)（转）
  4. pytest-pytest-html生成HTML测试报告
  5. 数据预处理 | python 第三方库 imblearn 处理样本分布不均衡问题
  6. 题解【AcWing487】金明的预算方案
  7. 多模块打war包
  8. [CF1216C] White Sheet - 离散化,模拟
  9. ASPxGridView 排序、分页、加载数据必需的三个函数
  10. wget安装nginx