关于DVB同步字节反转及加扰原理及流程图

                                                                                

<?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" />       
同步反转及扰码：
1、原理：
图1中，PN码发生器的寄存器初始值为：100101010000000。MPEG2数据流中，每8个数据帧组成一个数据组。PN码发生器的寄存器在传输每一个数据组的开始时初始化一次，为了提供该初始化信号，每一组数据中的第一个MPEG2数据帧的同步字节按比特反转，即47H反转为B8H。而MPEG2数据流中所有同步字节不参与扰码。
软件编程时，首先用一矩阵radata来模拟PN码发生器的寄存器，并给予与PN码发生器的寄存器相同的初始值。然后对输入的数据进行判断，识别其是同步字节还是信息字节。当输入的数据是信息字节时，信息位与PN码发生器的寄存器矩阵的第14个元素radata(14)
和第15个元素redata(15)进行模2加码即进行扰码，其中结果存入输出矩阵randout。当输入的数据为同步字节时，同步字节不参与扰码，且当该同步字节为每一组数据中的第一个MPEG2数据帧的同步字节时，该同步字节反转。
 
注：1、PN码发生器的寄存器初始值置为：100101010000000
2、PN码发生器在传输每一个数据组（8个数据帧）时初始化一次
3、每一组数据中的第一个MPEG2数据帧的同步字节按比特反转
4、MPEG2数据流中所有同步字节不参与扰码
5、解码部分和译码原理完全相同
以下为实现的源程序：
 
//初始化变量
//     int temp1[8],temp2[8];
       int enable,_redata,enabledata;
       int inputdata[8],outputdata[8];
       int redata[15];//寄存器
       BYTE output[8][204]={0};
 <?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

       for(int m=0;m<=7;m++)
       {
           for( int n=0;n<=187;n++)
              {
 

               //m=0并且n=15表示初始化寄存器和进行同步字节反转的标志
                  if(m==0&&n==0)
                     {
                   //初始化寄存器redata
                 for(int i=0;i<=14;i++)
                             {
                          if(i==0||i==3||i==5||i==7)
                                   {
                                redata[i]=1;
                                   }
                         else
                                   {
                                 redata[i]=0;
                                   }
                             }
                       //同步字节按比特反转
                        output[m][16+n]=~Input[m][16+n];
                     }
 

                  //其余的同步字节不参于加扰，按照原始字节输出
                  else if(m!=0&&n==0)
                     {
                         output[m][16+n]=Input[m][16+n];
                     }
 

            //信息位(非同步字节)进行加扰
                  else
                     {
                      for(int j=0;j<=7;j++)
                            {
                             //读取字节Input里面的信息比特
                             inputdata[j]=Input[m][16+n]%2;
                          //字节Input右移一位
                             Input[m][16+n]>>=1;
                            }
       
 

               //加扰运算
               for (int  i=0;i<=7;i++)  
                        {
                          _redata=redata[13]^redata[14];
                           for(int j=14;j>=1;j--)
                                    {
                               redata[j]=redata[j-1];
                                    }
                       redata[0]=_redata;
                          enabledata=enable&_redata;
                          outputdata[i]=enabledata^inputdata[i];
                        }
 

                   //加扰后的比特赋给字节output
                      for ( i=0;i<=7;i++)
                            {
                             output[m][16+n]=output[m][16+n]|((BYTE)outputdata[i]<<1);
                            }
                     }
              }
       }