gr_align_on_samplenumbers_ss.cc

这是用python语言写的一个数字广播的信号处理工具包。利用它

          d_in_presync=!all_syncs_found;
          if(!d_in_presync)
          {
            for(unsigned int k=0;k<ninputs;k++)
            {
              d_state[k].sync_found=false;
              d_state[i].sync_end_found=false;
            }
#ifdef DEBUG_TOCONSUME
            printf("presync END\n");
#endif
          }
        }
      }
    }
    if(d_in_presync || all_diffs_zero)
    {
      for(unsigned int i=0;i<ninputs;i++)
      {
         memcpy(&(((unsigned short*)output_items[i])[j]),&(((const unsigned short*)input_items[i])[d_state[i].ninput_items_used]),common_end*item_size);
         //consume(i,common_end);
         d_state[i].ninput_items-=common_end;
         d_state[i].ninput_items_used+=common_end;
         min_ninput_items=std::min(d_state[i].ninput_items,min_ninput_items);
#ifdef DEBUG_TOCONSUME
         if(common_end<256)
           tcPrintf("common_end %i\n",common_end);
#endif
      }
      //min_ninput_items-=common_end;
      noutput_items_produced+=common_end;
      //return common_end;
    } else
    {
      //printf("sync 2");
      for(unsigned int i=0;i<ninputs;i++)
      {
        int toconsume=std::min((d_state[i].diff_end+diff_comp_end_max)*d_nchan*2,d_state[i].ninput_items);
        toconsume=toconsume/(d_nchan*2);
        toconsume=toconsume*(d_nchan*2);
        d_state[i].ninput_items-=toconsume;
        d_state[i].ninput_items_used+=toconsume;
        min_ninput_items=std::min(d_state[i].ninput_items,min_ninput_items);
#ifdef DEBUG_TOCONSUME
      static int toconsume_counter=0;
      toconsume_counter++;
      //if(toconsume_counter>10)
      {
        tcPrintf("toconsume=%i diff_end[%i]*d_nchan*2=%i diff_comp_end_max*d_nchan*2=%i ninput_items[%i]=%i\n",toconsume,i,d_state[i].diff_end*d_nchan*2,diff_comp_end_max*d_nchan*2,i,ninput_items[i]);
        toconsume_counter=0;
      }
#endif
        //printf("toconsume[%i]=%i\n",i,toconsume);
        //consume(i,toconsume);//skip the difference in samplenumber items
      }
      //return 0;
    }
  }
  for(unsigned int i=0;i<ninputs;i++)
    consume(i,d_state[i].ninput_items_used);
#ifdef DEBUG_TOCONSUME
  if(noutput_items_produced<256)
    tcPrintf("noutput_items_produced %i\n",noutput_items_produced);
#endif
  return noutput_items_produced;
}


#else /*ALIGN_ADVANCED_IMPLEMENTATION*/
int
gr_align_on_samplenumbers_ss::general_work (int noutput_items,
        gr_vector_int &ninput_items,
        gr_vector_const_void_star &input_items,
        gr_vector_void_star &output_items)
{
#ifdef DEBUG_TOCONSUME
  static int dcount=0;
  bool dprint=false;
  dcount++;
  if(dcount>2000)
  {
    dcount=0;
    dprint=true;
  } 
#endif
  const size_t item_size = output_signature()->sizeof_stream_item (0);
  const unsigned ninputs = input_items.size();
  
  int common_end=noutput_items;
  //int diff_min=INT_MAX;
  //int diff_max=INT_MIN;
  for(unsigned int i=0;i<ninputs;i++)
  {
    unsigned short * uin=(unsigned short*)input_items[i];
    unsigned int  x_high16bits = uin[0];
    unsigned int  x_low16bits = uin[1];
    d_state[i].ucounter_begin = x_high16bits<<16 | x_low16bits;
    d_state[i].diff=d_state[0].ucounter_end-d_state[i].ucounter_end;//Result is a signed value,Will wrap around on 32 bit boundary
    x_high16bits = uin[d_nchan*2];
    x_low16bits = uin[d_nchan*2+1];
    unsigned int ucounter_begin2 = x_high16bits<<16 | x_low16bits;
    if((d_state[i].ucounter_begin+1)!=(ucounter_begin2))
      if(ucounter_begin2==0)
      {
#ifdef DEBUG_TOCONSUME
        ePrintf("SYNC counters are 0\n");
#endif
      }
      else
      {
        ePrintf("Error: counter not continuous.\n ucounter_begin[%i]=%i +1 !=  ucounter_begin2=%i\n",i,d_state[i].ucounter_begin,ucounter_begin2);
      }
      
    //diff_comp[i]=ucounter[i]-ucounter[0];
    //diff_min=std::min(diff[i],diff_min);
    //diff_max=std::max(diff[i],diff_max);
    common_end=std::max(std::min(ninput_items[i],common_end),0);
  }
  common_end=common_end/(d_nchan*2);
  common_end=common_end*(d_nchan*2);
#ifdef DEBUG_TOCONSUME
  if(common_end<d_nchan*2)
  {
    printf(" common_end %i\n",common_end);
    for(int j=0;j<ninputs;j++)
      printf("ninput_items[%i]=%i\n",j,ninput_items[j]);
  }
#endif
  bool all_diffs_zero=true;
  bool sync_found=false;
  int diff_comp_end_max=0;
  for(unsigned int i=0;i<ninputs;i++)
  {
    unsigned short * uin=(unsigned short*)input_items[i];
    int common_last=common_end-(d_nchan*2);
    unsigned int  x_high16bits = uin[common_last];
    unsigned int  x_low16bits = uin[common_last+1];
    d_state[i].ucounter_end = x_high16bits<<16 | x_low16bits;
    d_state[i].diff_end=d_state[0].ucounter_end-d_state[i].ucounter_end;//Result is a signed value,Will wrap around on 32 bit boundary
    d_state[i].diff_comp_end=d_state[i].ucounter_end-d_state[0].ucounter_end;
    //diff_end_min=std::min(diff_end[i],diff_end_min);
    //diff_end_max=std::max(diff_end[i],diff_end_max);
    diff_comp_end_max=std::max(d_state[i].diff_comp_end,diff_comp_end_max);
#ifdef DEBUG_TOCONSUME
    if(d_state[i].diff_end!=d_state[i].diff)
    {
      //samples_lost_or_syncstart=true;
      printf("Us%i %i %i ",i,d_state[i].diff_end,d_state[i].diff);
    }
#endif
    all_diffs_zero=all_diffs_zero && (0==d_state[i].diff_end);
    if((d_state[i].ucounter_end<d_state[i].ucounter_begin+(unsigned)(common_last/(d_nchan*2))) || (0==d_state[i].ucounter_end) || (0==d_state[i].ucounter_begin)) //(unsigned)(common_last/(d_nchan*2)))
    {
      sync_found=true;//sync_found or 32 bit counter  wraparound (0xffffffff -> 0x00000000)
#ifdef DEBUG_TOCONSUME
      tcPrintf("SYNC diff_end[%i]=%i ucounter_end[%i]=%i ucounter_begin[%i]=%i \n",i,d_state[i].diff_end,i,d_state[i].ucounter_end,i,d_state[i].ucounter_begin);
      tcPrintf("ucounter_end=%i < %i = ucounter_begin+(unsigned)(common_last/(d_nchan*2) \n",d_state[i].ucounter_end,d_state[i].ucounter_begin+(unsigned)(common_last/(d_nchan*2)));

      printf("ucounter_end[%i]=%i ucounter_begin[%i]=%i\n",i,d_state[i].ucounter_end,i,d_state[i].ucounter_begin);      
      int expected_sync_position=common_last - d_state[i].ucounter_end*(d_nchan*2);
      if(0==uin[expected_sync_position] && 0==uin[expected_sync_position+1])
      {
        printf("sync found on input %i at position %i \n",i,expected_sync_position);
        //sync_start[i]=expected_sync_position;
      } else
      {
        printf("sync found on input %i position unclear, expected at %i value there %i\n",i,expected_sync_position,uin[expected_sync_position]<<16 | uin[expected_sync_position+1]);
        //sync_start[i]=-1;
      }
    } else
    {
      tcPrintf("NOsync diff_end[%i]=%i ucounter_end[%i]=%i ucounter_begin[%i]=%i \n",i,d_state[i].diff_end,i,d_state[i].ucounter_end,i,d_state[i].ucounter_begin);
#endif    
    }
  }
  bool problem=false;
  for(unsigned int i=0;i<ninputs;i++)
    if((d_state[i].diff_end+diff_comp_end_max) >0x4000000)
      {
        problem=true;
        ePrintf("Warning: counter diff greater as 64 Million\n");
        ePrintf("         You might want to swap master and slave.\n");
        ePrintf("          i=%i,d_state[i].diff_end+diff_comp_end_max=%i,d_state[i].diff_end=%i,diff_comp_end_max=%i,ucounter[i]=%i,ucounter[0]=%i\n",
                          i,d_state[i].diff_end+diff_comp_end_max,d_state[i].diff_end,diff_comp_end_max,d_state[i].ucounter_end,d_state[0].ucounter_end);
        //ePrintf("        toconsume=%i\n",toconsume); 
      }
  if(sync_found || all_diffs_zero || problem)
  {
#ifdef DEBUG_TOCONSUME
    if(all_diffs_zero) tcPrintf("ZERO\n");
    if(sync_found) tcPrintf("SYNC\n");
#endif
    for(unsigned int i=0;i<ninputs;i++)
    {
       memcpy(output_items[i],input_items[i],common_end*item_size);
       consume(i,common_end);
#ifdef DEBUG_TOCONSUME
      if(common_end<256)
        tcPrintf("common_end %i\n",common_end);
#endif
    }
    return common_end;
  } else
  {
    //int minconsume=0;//common_end/(2*d_nchan*2);
    //min_consume=min_consume*d_nchan*2;  
    for(unsigned int i=0;i<ninputs;i++)
    {
      int toconsume=std::min((d_state[i].diff_end+diff_comp_end_max)*d_nchan*2,ninput_items[i]);
      toconsume=toconsume/(d_nchan*2);
      toconsume=toconsume*(d_nchan*2);
#ifdef DEBUG_TOCONSUME
      //printf("dcount %i\n",dcount);
      static int toconsume_counter=0;
      toconsume_counter++;
      //if(toconsume_counter>10)
      {
        tcPrintf("toconsume=%i diff_end[[%i]*d_nchan*2=%i diff_comp_end_max)*d_nchan*2=%i ninput_items[%i]=%i\n",
                  toconsume,i,d_state[i].diff_end*d_nchan*2,diff_comp_end_max*d_nchan*2,i,ninput_items[i]);
        toconsume_counter=0;
      }
#endif
      consume(i,toconsume);//skip the difference in samplenumber items
      //printf("toconsume%i %i diff_comp_end_max %i diff_end[[%i] %i\n",i,toconsume,diff_comp_end_max,i,d_state[i].diff_end);
    }
    return 0;
  }
  return -1;//Should never come here
}
#endif /*ALIGN_ADVANCED_IMPLEMENTATION*/