⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 class.cpp

📁 一个很好的vitebi编译码程序
💻 CPP
📖 第 1 页 / 共 2 页
字号:
        for(i=0;i<RemainBitLen;i++)
        {
                if((ByteLength-RemainBitLen+i)>=0)
                {
                        RemainBit[i]=Data[ByteLength-RemainBitLen+i];
                }
        }

}

void MVitebiDecode::Input(char *Data,int BitLength)
{
        int i,j,k,b,l,Counter,ByteNum,BitNum,RemainBitLen1;
        Byte CodeMeasurement,m;
        int Max,MaxMeasurement,MaxPath,MaxFrontState,POldStartSite,PNewStartSite,MOldStartSite,MNewStartSite;
        unsigned char CodeIn,Code;
        unsigned char Select[8]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
        if(BitLength==0)
        {
                if(Buffer!=NULL)
                        delete Buffer;
                Buffer=NULL;
                BufBitLen=0;
                return;
        }
        i=BitLength/n0;//输出比特长度
        RemainBitLen1=(BitLength+RemainBitLen)%n0;
        if(BufBitLen!=i)
        {
                if(Buffer!=NULL)
                        delete Buffer;
                Buffer=NULL;
                if(i>0){
                        BufBitLen=i;
                        Buffer=new Byte[BufBitLen/8+1];
                        memset(Buffer,0,BufBitLen/8+1);
                }
                else{
                        BufBitLen=0;
                }
        }
        else{
                if(BufBitLen!=0)
                {
                        memset(Buffer,0,BufBitLen/8+1);
                }
        }
        Counter=0;
        for(i=-RemainBitLen;i<BitLength-RemainBitLen1;i=i+n0)
        {
                New=(Old+1)%2;
                POldStartSite=Old*PathStoreLength*Row;//PathStore[]的起始位置
                PNewStartSite=New*PathStoreLength*Row;//PathStore[]的起始位置
                MOldStartSite=Old*Row;   // Measurement[]的起始位置
                MNewStartSite=New*Row;   //(此四变量是为了减少下面循环的运算量)
                MaxMeasurement=0;        //寻找最大比特度量的中间变量(所有状态)
                CodeIn=0;
//取编码数据
                if(i<0)
                {
                        for(j=0;j<RemainBitLen;j++)
                        {
                                if((RemainBit[j])!=0)
                                {
                                        CodeIn=CodeIn|Select[8-n0+j];
                                }
                        }
                        for(j=RemainBitLen;j<n0;j++)
                        {
                                ByteNum=(i+j)/8;
                                BitNum=(i+j)%8;
                                if((Data[ByteNum]&Select[BitNum])!=0)
                                {
                                        CodeIn=CodeIn|Select[8-n0+j];
                                }
                        }
                }
                else
                {
                        for(j=0;j<n0;j++)
                        {
                                ByteNum=(i+j)/8;
                                BitNum=(i+j)%8;
                                if((Data[ByteNum]&Select[BitNum])!=0)
                                {
                                        CodeIn=CodeIn|Select[8-n0+j];
                                }
                        }
                }
                for(j=0;j<Row;j++)    //对每个状态进行计算
                {
                        Max=0;                 //寻找最大比特度量路径(一个状态)的中间变量
                        for(k=0;k<PathNum;k++)//对进入一个状态的每条路径进行计算比特度量
                        {
                                Code=State[j*Column+k*3+1];     //取子码
                                CodeMeasurement=0;
                                for(l=0;l<n0;l++)
                                {
                                        CodeMeasurement=CodeMeasurement+((~(Code^CodeIn)>>l)&0x01);
                                }
                 	        if((b=CodeMeasurement+Measurement[MOldStartSite+State[j*Column+k*3]])>Max)//求bit度量最大的前态,输出及其度量
                                {
                                        Max=b;
                                        MaxPath=k;      //最大比特度量路径(一个状态)
                                }
                        }
                        Measurement[MNewStartSite+j]=Max;//更新度量寄存器
                        if(Max>MaxMeasurement)          //Max为最大比特度量(一个状态)
                        {
                                MaxMeasurement=Max;     //MaxMeasurement为最大比特度量(所有状态)
                                MaxFrontState=State[j*Column+MaxPath*3]; //最大度量状态的前态(所有状态)
                        }
                        memcpy(&PathStore[PNewStartSite+j*PathStoreLength],&PathStore[POldStartSite+State[j*Column+MaxPath*3]*PathStoreLength],PathStoreLength);
                        PathStore[PNewStartSite+j*PathStoreLength+NowStoreSite]=State[j*Column+MaxPath*3+2];//最大比特度量的译码
                }                                               //NowStoreSite为PathStore[new]里进行更新的位置,同时也为PathStore[old]里进行输出的位置
        	if(MaxMeasurement>150000)               //防止bit度量溢出
                {
	             for(j=0;j<Row;j++)
	                    Measurement[MNewStartSite+j]=Measurement[MNewStartSite+j]-100000;
	        }
           	if(NowStoreLength==PathStoreLength)  //当路径存储器满时,输出结果
                {
                        b=POldStartSite+MaxFrontState*PathStoreLength+NowStoreSite;//在PathStore[Old]里应输出结果的位置
                        for(j=0,m=BitSite;j<k0;j++)
                        {
                                ByteNum=Counter/8;
                                BitNum=Counter%8;
                                if((PathStore[b]&m)!=0)
                                        Buffer[ByteNum]=Buffer[ByteNum]|Select[BitNum];
                                Counter++;
                                m=m>>1;
                        }
                }
                Old=New;
                NowStoreSite=(NowStoreSite+1)%PathStoreLength;    //更新
                if(NowStoreLength<PathStoreLength)              //存储记数加一
                {
	                NowStoreLength++;
                }
        }
//输出剩余数据
        for(i=0;i<42;i++)
        {

        }

}

//**********************************************************************
//名称:MPuncturedDecoder
//功能:卷积码的增信删余译码
//**********************************************************************
MPuncturedDecoder::MPuncturedDecoder()
{
       Buffer=new unsigned char[1];
       BufferLen=1;
       PathStore=new unsigned char[1];
       Measurement=new int[1];
       NowStoreLength=0;
       NowStoreSite=0;
       Old=0;
       RemainData=new Byte[1];
       RemainDataLen=0;
       State=new int[1];
       ReBuffer=new Byte[1];
       ReBufferLen=1;
       DivData=new Byte[1];
       PunSite=new Byte[1];
       CodeIn=new Byte[1];
}

MPuncturedDecoder::~MPuncturedDecoder()
{
       if(Buffer!=NULL)
               delete Buffer;
       if(PathStore!=NULL)
               delete PathStore;
       if(Measurement!=NULL)
               delete Measurement;
       if(RemainData!=NULL)
               delete RemainData;
       if(State!=NULL)
               delete State;
       if(CodeIn!=NULL)
               delete CodeIn;
       if(ReBuffer!=NULL)
               delete ReBuffer;
       if(DivData!=NULL)
               delete DivData;
        if(PunSite!=NULL)
                delete PunSite;
}

void MPuncturedDecoder::Initial(int n,int k,int m,int *Member,Byte *Site)
{
        int i;
        NowStoreLength=0;
        NowStoreSite=0;
        Old=0;
        SendNum=n;
        k0=k;
        DivDataLen=2*(n-1);

        if(PunSite!=NULL)
                delete PunSite;
        PunSite=new Byte[DivDataLen];
        for(i=0;i<DivDataLen;i=i+2)
        {
                PunSite[i]=Site[i/2];
                PunSite[i+1]=Site[(n-1)+i/2];
        }
        CreatMatrix.Input(2,1,m,Member);
        TransferState.Input(2,1,m,CreatMatrix.Buffer);
        if(State!=NULL)
                delete State;
        State=new int[(TransferState.Row)*(TransferState.Column)];
        memcpy(State,TransferState.Buffer,sizeof(int)*TransferState.Row*TransferState.Column);
//        State=TransferState.Buffer;

	for(i=0,Row=1;i<m;i++){//状态表行数
		Row=Row*2;
	}
	for(i=0,PathNum=1;i<1;i++){//状态表列数
		PathNum=PathNum*2;
	}
        BitSite=PathNum/2;
        Column=PathNum*3;
        PathStoreLength=m*7;     //路径存储长度
        if(PathStore!=NULL)      //申请路径寄存器并清零
        {
                delete PathStore;
        }
        PathStore=new Byte[2*PathStoreLength*Row];
        memset(PathStore,0,2*PathStoreLength*Row);
        if(Measurement!=NULL)      //申请比特度量寄存器并清零
        {
                delete Measurement;
        }
        Measurement=new int[2*Row];
        memset(Measurement,0,sizeof(int)*2*Row);
        if(RemainData!=NULL)
        {
                delete RemainData;
        }
        RemainData=new Byte[DivDataLen-1];
        RemainDataLen=0;
        if(CodeIn!=NULL)
                delete CodeIn;
        CodeIn=new Byte[2];
}

void MPuncturedDecoder::Input(Byte *Data,int DataLen)
{
        int i,j,k,b,l,p,Counter,ByteNum,Counter1;
        Byte CodeMeasurement,m;
        int Max,MaxMeasurement,MaxPath,MaxFrontState,POldStartSite,PNewStartSite,MOldStartSite,MNewStartSite;
        unsigned char Code;
        if(DataLen==0)
        {
                if(Buffer!=NULL)
                        delete Buffer;
                Buffer=NULL;
                BufferLen=0;
                return;
        }
        i=((((DataLen+RemainDataLen)/SendNum)*DivDataLen)-PathStoreLength*2+NowStoreLength*2)/2;//输出比特长度
//        i=(((DataLen+RemainDataLen)/SendNum)*DivDataLen);//输出比特长度

        if(BufferLen!=i)
        {
                if(Buffer!=NULL)
                        delete Buffer;
                Buffer=NULL;
                if(i>0){
                        BufferLen=i;
                        Buffer=new Byte[BufferLen];
                        memset(Buffer,0,BufferLen);
                }
                else{
                        BufferLen=0;
                }
        }
        else{
                if(BufferLen!=0)
                {
                        memset(Buffer,0,BufferLen);
                }
        }
        if(ReBufferLen!=(DataLen+RemainDataLen))
        {
                if(ReBuffer!=NULL)
                        delete ReBuffer;
                ReBuffer=NULL;
                ReBufferLen=DataLen+RemainDataLen;
                ReBuffer=new Byte[ReBufferLen];
        }
        memcpy(ReBuffer,RemainData,RemainDataLen);
        memcpy(ReBuffer+RemainDataLen,Data,DataLen);
//保留剩余数据
        RemainDataLen=(DataLen+RemainDataLen)%SendNum;
        for(i=0;i<RemainDataLen;i++)
        {
                if((ReBufferLen-RemainDataLen+i)>=0)
                {
                        RemainData[i]=ReBuffer[ReBufferLen-RemainDataLen+i];
                }
        }
        Counter=0;
        Counter1=0;
        for(i=0;i<ReBufferLen-RemainDataLen;i=i+SendNum)
        {
                for(p=0;p<DivDataLen;p=p+2)
                {
                        New=(Old+1)%2;
                        POldStartSite=Old*PathStoreLength*Row;//PathStore[]的起始位置
                        PNewStartSite=New*PathStoreLength*Row;//PathStore[]的起始位置
                        MOldStartSite=Old*Row;   // Measurement[]的起始位置
                        MNewStartSite=New*Row;   //(此四变量是为了减少下面循环的运算量)
                        MaxMeasurement=0;        //寻找最大比特度量的中间变量(所有状态)
//取编码数据
                        if((PunSite[p])!=0)
                        {
                                CodeIn[0]=ReBuffer[Counter1];
                                Counter1++;
                        }
                        else
                        {
                                CodeIn[0]=2;
                        }
                        if(PunSite[p+1]!=0)
                        {
                                CodeIn[1]=ReBuffer[Counter1];
                                Counter1++;
                        }
                        else
                        {
                                CodeIn[1]=2;
                        }
                        for(j=0;j<Row;j++)    //对每个状态进行计算
                        {
                                Max=0;                 //寻找最大比特度量路径(一个状态)的中间变量
                                for(k=0;k<PathNum;k++)//对进入一个状态的每条路径进行计算比特度量
                                {
                                        Code=State[j*Column+k*3+1];     //取子码
                                        CodeMeasurement=0;
                                        for(l=0;l<2;l++)
                                        {
                                                if(CodeIn[l]==((Code>>(1-l))&0x01))
                                                        CodeMeasurement=CodeMeasurement+1;
                                        }
                 	                if((b=CodeMeasurement+Measurement[MOldStartSite+State[j*Column+k*3]])>Max)//求bit度量最大的前态,输出及其度量
                                        {
                                                Max=b;
                                                MaxPath=k;      //最大比特度量路径(一个状态)
                                        }
                                }
                                Measurement[MNewStartSite+j]=Max;//更新度量寄存器
                                if(Max>MaxMeasurement)          //Max为最大比特度量(一个状态)
                                {
                                        MaxMeasurement=Max;     //MaxMeasurement为最大比特度量(所有状态)
                                        MaxFrontState=State[j*Column+MaxPath*3]; //最大度量状态的前态(所有状态)
                                }
                                memcpy(&PathStore[PNewStartSite+j*PathStoreLength],&PathStore[POldStartSite+State[j*Column+MaxPath*3]*PathStoreLength],PathStoreLength);
                                PathStore[PNewStartSite+j*PathStoreLength+NowStoreSite]=State[j*Column+MaxPath*3+2];//最大比特度量的译码
                        }                                               //NowStoreSite为PathStore[new]里进行更新的位置,同时也为PathStore[old]里进行输出的位置
                	if(MaxMeasurement>150000)               //防止bit度量溢出
                        {
        	             for(j=0;j<Row;j++)
	                            Measurement[MNewStartSite+j]=Measurement[MNewStartSite+j]-100000;
	                }
                   	if(NowStoreLength==PathStoreLength)  //当路径存储器满时,输出结果
                        {
                                b=POldStartSite+MaxFrontState*PathStoreLength+NowStoreSite;//在PathStore[Old]里应输出结果的位置
                                if((PathStore[b]&0x01)!=0)
                                        Buffer[Counter]=1;
                                Counter++;
                        }
                        Old=New;
                        NowStoreSite=(NowStoreSite+1)%PathStoreLength;    //更新
                        if(NowStoreLength<PathStoreLength)              //存储记数加一
                        {
	                        NowStoreLength++;
                        }
                }
        }
}


⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -