cccode.c

OFDM下卷积码译码器CC码的源代码

#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
    int lenPnctrMode;
    int rateID;
    int sizeOfSrcBlock;
    int maxSizeOfCodeword=144;
    int sizeOfCodedBlock;
    int maxSizeOfSrcBlock=120;
    int sizeOfBinaryIn;
    int numOfDelay=6;
    int numOfStatus=64;
    int m_InfHamming=8*120+1;
    double m_InfSoft=100000.0;
    unsigned char pPnctrModeX[10];
    unsigned char pPnctrModeY[10];
    unsigned char *cdoutwrd;
   // maxSizeOfSrcBlock=120;
   // maxSizeOfCodeword=144;
   // m_InfHamming=8*maxSizeOfSrcBlock+1;//Hamming distance can never be larger than this value
   // m_InfSoft=100000.0;//set to a value large enough

    unsigned char pMsgInput[960];//maxSizeOfSrcBlock];//in bit
    unsigned char pEncoderOutput[1920];//maxSizeOfSrcBlock];//in bit
    unsigned char pOutputTable[4*64];
   // numOfDelay=6;//memory length
   // numOfStatus=(1<<numOfDelay);
    
    unsigned char pStatusTransferTable[128];//numOfStatus];
    unsigned char pOutputTable[256];//numOfStatus];
    unsigned char pPuncture[1304];//maxSizeOfCodeword];//Note X and Y part

   // unsigned char pPrevStatusOfSurvivorPath[8*120*64];//maxSizeOfSrcBlock*numOfStatus];
    int pPathMetricHamming[128];//numOfStatus];//Hamming metric
    double pPathMetricSoft[128];//numOfStatus];//Soft metric for soft decision Viterbi Algorithm
    unsigned char pRevDepunctureBin[1304];//maxSizeOfCodeword];
    unsigned char pStatusSelPath[961];//maxSizeOfSrcBlock+1];//The path selected
    
    double pRevDepunctureSoft[1304];
    unsigned char *decoder_out;


    void generateCCTables(void);
    void setMsgInput(const unsigned char *d_in);

    void setParameters(int _rateID);
    void Encoder(const unsigned char *d_in,unsigned char *d_out);
    void Encoder2(const unsigned char *d_in,unsigned char *d_out2);
void myCC(int _rateID)
{ 
    
    setParameters(_rateID);
    generateCCTables();//generate the status transfer table and output table
}

void setParameters(int _rateID)
{
    int i;
    int Len;
    int index;
    
    rateID=_rateID;
    lenPnctrMode=5;
    sizeOfSrcBlock=120;//bytes of the input block
    sizeOfCodedBlock=144;//bytes of the output punctured block
    pPnctrModeX[0]=1;
    pPnctrModeX[1]=0;
    pPnctrModeX[2]=1;
    pPnctrModeX[3]=0;
    pPnctrModeX[4]=1;

    pPnctrModeY[0]=1;
    pPnctrModeY[1]=1;
    pPnctrModeY[2]=0;
    pPnctrModeY[3]=1;
    pPnctrModeY[4]=0;
//puncture mode of X:1,0,1 0 1; Y:1 1 0 1 0
           // CC rate: 5/6
        lenPnctrMode=5;
        sizeOfSrcBlock=40;//bytes of the input block
        sizeOfCodedBlock=48;//bytes of the output punctured block
     
    sizeOfBinaryIn=8*sizeOfSrcBlock;
    
    Len=8*sizeOfCodedBlock;
    for(i=0;i<Len;i++)
    {
        index=i%lenPnctrMode;
        pPuncture[i*2]=pPnctrModeX[index];
        pPuncture[i*2+1]=pPnctrModeY[index];
    }
}

//Set input of CC encoder
//m[0],m[1],...,m[K-1] are in bytes
//where K is sizeOfSrcBlock,bytes number of the input block
//MSB of m[0] first
void setMsgInput(const unsigned char *d_in)
{
    int i,j;
    int index;
    unsigned char a;
    
    index=0;
    for(i=0;i<sizeOfSrcBlock;i++)
    {
        a=d_in[i];
        for(j=0;j<8;j++)
        {
            pMsgInput[index]=(a>>(8-1-j))&0x01;
            index++;
        }
    }
}

void generateCCTables(void)
{
    int currentStatus,nextStatus;
    int maskCode;
    int d;
    int i;
    unsigned char SS[10];

    maskCode=numOfStatus-1;

    for(currentStatus=0;currentStatus<numOfStatus;currentStatus++)
    {
        for(i=0;i<numOfDelay;i++)//Set the next status: S[1] S[2],...,S[6]
        {
            SS[i+1]=(currentStatus>>i)&0x01;
        }
        nextStatus=(currentStatus<<1)&maskCode;

        for(d=0;d<=1;d++)//input 0 and 1
        {
            nextStatus&=0xfffe;//reset the LSB 
            nextStatus|=(d&0x01);//set LSB of the next status to d
            SS[0]=d;
            pOutputTable[4*currentStatus+2*d]=(SS[0]+SS[1]+SS[2]+SS[3]+SS[6])%2;//get X
            pOutputTable[4*currentStatus+2*d+1]=(SS[0]+SS[2]+SS[3]+SS[5]+SS[6])%2;//get Y

            pStatusTransferTable[2*currentStatus+d]=nextStatus;
        }
    }
}


//CC encoder,without puncture(打孔)
//Output format:[X0 Y0 X1 Y1 X2 Y2...]

//CC encoder:
//d_in: input in bytes
//d_out: outut in bytes
void Encoder(const unsigned char *d_in,unsigned char *d_out)
{
    int i,j;
    int Len;
    int index;
    unsigned char a;
    int Status;
    int d;

    Status=0;

    Len=2*sizeOfBinaryIn;//Note it contains X and Y parts
    setMsgInput(d_in);
    
    for(i=0;i<sizeOfBinaryIn;i++)
    {
        d=pMsgInput[i];
        pEncoderOutput[2*i]=pOutputTable[4*Status+2*d];        
        pEncoderOutput[2*i+1]=pOutputTable[4*Status+2*d+1];
        Status=pStatusTransferTable[2*Status+d];
    }
    
    index=0;
    j=0;
    a=0x00;
    for(i=0;i<Len;i++)
    {
        if(0==pPuncture[i])
        {
            continue;
        }
        a|=(pEncoderOutput[i]<<(8-1-j));
        j++;
        if(8==j)
        {
            j=0;
            d_out[index]=a;
            a=0x00;
            index++;
        }
    }
}
main()
{   unsigned char msg[40]={0x49,0x31,0x40,0xBF,0xD4,0xBA,0xA1,0x12,0xF2,0x74,
                           0x96,0x30,0x27,0xD4,0x88,0x9C,0x96,0xE3,0xA9,0x52,
                           0xB3,0x15,0xAB,0xFD,0x92,0x53,0x07,0x32,0xC0,0x62,
                           0x48,0xF0,0x19,0x22,0xE0,0x91,0x62,0x1A,0xC1,0x00};

    myCC(2);
    Encoder(msg,cdoutwrd);

}