#include <unistd.h>
#include <ctype.h>
#include <string.h>

#include "globdef.h"
#include "uidef.h"
#include "fft1def.h"
#include "fft2def.h"
#include "fft3def.h"
#include "sigdef.h"
#include "screendef.h"
#include "seldef.h"
#include "thrdef.h"
#include "txdef.h"
#include "vernr.h"
#include "hwaredef.h"
#include "sdrdef.h"
#include "keyboard_def.h"

int tx_ssb_step2(float *totpwr)
{
int i, k;
float t1, t2;
// ************* Step 2. *************
// Compute the power for each bin within the passband.
// Apply muting in the frequency domain by setting bins with too small
// signal power to zero.
// Collect the sum of the powers from surviving bins and mute the entire
// block in case the total power is below threshold.
// Here we use the agc factor as determined from the the
// previous block and attenuated with the decay factor.
// Note that the agc factor is limited to 20 dB at this point.
// A big pulse will not kill the signal for a long time!!
t1=0;
k=0;
for(i=tx_filter_ia1; i<mic_fftsize; i++)
  {
  t2=micfft[micfft_px+2*i  ]*micfft[micfft_px+2*i  ]+
     micfft[micfft_px+2*i+1]*micfft[micfft_px+2*i+1];
  if(t2 > micfft_bin_minpower)
    {
    k++;
    t1+=t2;
    }
  else
    {
    micfft[micfft_px+2*i  ]=0;
    micfft[micfft_px+2*i+1]=0;
    }
  }
for(i=0; i<=tx_filter_ib1; i++)
  {
  t2=micfft[micfft_px+2*i  ]*micfft[micfft_px+2*i  ]+
     micfft[micfft_px+2*i+1]*micfft[micfft_px+2*i+1];
  if(t2 > micfft_bin_minpower)
    {
    k++;
    t1+=t2;
    }
  else
    {
    micfft[micfft_px+2*i  ]=0;
    micfft[micfft_px+2*i+1]=0;
    }
  }
if(k>0 && t1 < micfft_minpower)
  {
  for(i=tx_filter_ia1; i<mic_fftsize; i++)
    {
    micfft[micfft_px+2*i  ]=0;
    micfft[micfft_px+2*i+1]=0;
    }
  for(i=0; i<=tx_filter_ib1; i++)
    {
    micfft[micfft_px+2*i  ]=0;
    micfft[micfft_px+2*i+1]=0;
    }
  k=0;
  }
totpwr[0]=t1;    
return k;
}

void tx_ssb_step3(float *totamp)
{
int i;
float t1, t2, r1;
// ************* Step 3. *************
// Find out what the average amplitude would become if the old AGC
// factor would be applied. Change the agc factor in case the
// average amplitude is above the limit.
// Note that this step is only executed if k!=0.
// When k==0, the entire block is muted. The operation
// would be meaningless on a zero transform.
t1=sqrt(totamp[0]);
r1=pow(10.0,0.05*txssb.mic_gain);
t2=r1*t1*tx_agc_factor*(tx_highest_bin-tx_lowest_bin+1);
if(t2 > TX_AGC_THRESHOLD*(tx_highest_bin-tx_lowest_bin+1))
  {
  tx_agc_factor=TX_AGC_THRESHOLD/(r1*t1);
  }
t2=tx_agc_factor*(tx_highest_bin-tx_lowest_bin+1)*r1;
t2*=pow(10.0,0.05*(txssb.mic_out_gain-60));
// Apply the AGC within the current fft block.
for(i=tx_filter_ia1; i<mic_fftsize; i++)
  {
  micfft[micfft_px+2*i  ]*=t2;
  micfft[micfft_px+2*i+1]*=t2;
  }
for(i=0; i<=tx_filter_ib1; i++)
  {
  micfft[micfft_px+2*i  ]*=t2;
  micfft[micfft_px+2*i+1]*=t2;
  }
totamp[0]=t1;
}

void tx_ssb_step4(float ampinv,float *t1, float *prat)
{
int i, k, panew;
char mute_current, mute_previous;
float r1, r2, t2;
prat[0]=0;
t1[0]=0;
if( (tx_filter_ia1&1) != 0)tx_ph1*=-1;
panew=(cliptimf_pa+mic_fftsize)&micfft_mask;
if(ampinv == 0)
  {
  mute_current=TRUE;
  }
else
  {  
  mute_current=FALSE;
  }
cliptimf_mute[cliptimf_pa/mic_fftsize]=mute_current;
mute_previous=cliptimf_mute[((cliptimf_pa-mic_fftsize+micfft_bufsiz)&
                           micfft_mask)/mic_fftsize];
// We do nothing in case both the current transform and the
// previous one are muted.
if( (mute_current&mute_previous) == FALSE)
  {  
  if( (mute_current|mute_previous) == FALSE)
    {
// None of the transforms is muted. 
// Do normal (continous) back transformation.
    r1=pow(10.0,0.05*txssb.rf1_gain)/TX_AGC_THRESHOLD;
    t2=0;
    r1*=ampinv;
    for(i=0; i<mic_fftsize; i+=2)
      {
      cliptimf[cliptimf_pa+i  ]=tx_ph1*
                      (cliptimf[cliptimf_pa+i  ]+r1*micfft[micfft_px+i  ]);
      cliptimf[cliptimf_pa+i+1]=tx_ph1*
                      (cliptimf[cliptimf_pa+i+1]+r1*micfft[micfft_px+i+1]);
      t2=cliptimf[cliptimf_pa+i  ]*cliptimf[cliptimf_pa+i  ]+
         cliptimf[cliptimf_pa+i+1]*cliptimf[cliptimf_pa+i+1];
      prat[0]+=t2;
      if(t2>t1[0])t1[0]=t2;
      if(t2 > 1)
        {
        t2=1/sqrt(t2);
        cliptimf[cliptimf_pa+i  ]*=t2;
        cliptimf[cliptimf_pa+i+1]*=t2;
        }
      }
    if( (tx_filter_ia1&1) != 0)r1*=-1;
    for(i=0; i<mic_fftsize; i++)
      {
      cliptimf[panew+i]=r1*micfft[micfft_px+mic_fftsize+i];
      }
    }
  else
    {
// This is the first or the last transform.
// Multiply the beginning and the end with a sine squared window
// to make the start and end filtered with a sine to power 4
// window in total.    
// The first and last transforms are likely to be incorrect
// because muting in the frequency domain will distort the
// signal if only the very strongest bins have survived
// the muting process. This is particularly obvious if the
// microphone signal is a keyed tone which is present only
// a short time in the last or first transform. In such a
// situation the signal would be extended over the entire
// transform in case only a single bin would survive.
// The added sine squared window will remove the abrupt
// start that the signal otherwise would have.
    if(mute_current)
      {
      k=0;
      for(i=mic_fftsize-2; i>=0; i-=2)
        {
        r1=micfft_winfac*micfft_win[k];
        cliptimf[cliptimf_pa+i  ]=tx_ph1*cliptimf[cliptimf_pa+i  ]*r1;
        cliptimf[cliptimf_pa+i+1]=tx_ph1*cliptimf[cliptimf_pa+i+1]*r1;
        k++;
        t2=cliptimf[cliptimf_pa+i  ]*cliptimf[cliptimf_pa+i  ]+
           cliptimf[cliptimf_pa+i+1]*cliptimf[cliptimf_pa+i+1];
        if(t1[0] < MAX_DYNRANGE && t2 < MAX_DYNRANGE)
          {
          cliptimf[cliptimf_pa+i  ]=0;
          cliptimf[cliptimf_pa+i+1]=0;
          }
        else
          {
          prat[0]+=t2;
          if(t2>t1[0])t1[0]=t2;
          if(t2 > 1)
            {
            t2=1/sqrt(t2);
            cliptimf[cliptimf_pa+i  ]*=t2;
            cliptimf[cliptimf_pa+i+1]*=t2;
        t2=cliptimf[cliptimf_pa+i  ]*cliptimf[cliptimf_pa+i  ]+
           cliptimf[cliptimf_pa+i+1]*cliptimf[cliptimf_pa+i+1];
            }
          }
        }
      for(i=0; i<mic_fftsize; i++)
        {
        cliptimf[panew+i]=0;
        }
      }
    else // if(mute_previous)
      {
      r1=pow(10.0,0.05*txssb.rf1_gain)/TX_AGC_THRESHOLD;
      t2=0;
      r1*=ampinv;
      for(i=0; i<mic_fftsize; i+=2)
        {
        r2=r1*micfft_winfac*micfft_win[i>>1];
        cliptimf[cliptimf_pa+i  ]=tx_ph1*r2*micfft[micfft_px+i  ];
        cliptimf[cliptimf_pa+i+1]=tx_ph1*r2*micfft[micfft_px+i+1];
        t2=cliptimf[cliptimf_pa+i  ]*cliptimf[cliptimf_pa+i  ]+
           cliptimf[cliptimf_pa+i+1]*cliptimf[cliptimf_pa+i+1];
        if(t1[0] < MAX_DYNRANGE && t2 < MAX_DYNRANGE)
          {
          cliptimf[cliptimf_pa+i  ]=0;
          cliptimf[cliptimf_pa+i+1]=0;
          }
        else
          {
          prat[0]+=t2;
          if(t2>t1[0])t1[0]=t2;
          if(t2 > 1)
            {
            t2=1/sqrt(t2);
            cliptimf[cliptimf_pa+i  ]*=t2;
            cliptimf[cliptimf_pa+i+1]*=t2;
            }
          }
        }
      if( (tx_filter_ia1&1) != 0)r1*=-1;
      for(i=0; i<mic_fftsize; i++)
        {
        cliptimf[panew+i]=r1*micfft[micfft_px+mic_fftsize+i];
        }
      }
    }
  }
cliptimf_pa=panew;
micfft_px=(micfft_px+micfft_block)&micfft_mask;
}

void tx_ssb_step5(void)
{
int i, j, pb, nx ,nb;
while( ((cliptimf_pa-cliptimf_px+micfft_bufsiz)&micfft_mask) > 
                                                           2*mic_fftsize)
  {                                                  
  pb=(cliptimf_px+2*(mic_fftsize-1))&micfft_mask;
  nx=cliptimf_px/mic_fftsize;
  nb=((cliptimf_px+mic_fftsize)&micfft_mask)/mic_fftsize;
  if(cliptimf_mute[nx]==FALSE/* && cliptimf_mute[nb]==FALSE*/)
    {
    j=mic_fftsize-1;
    for(i=0; i<mic_sizhalf; i++)
      {
      clipfft[clipfft_pa+2*i  ]=cliptimf[cliptimf_px+2*i  ]*micfft_win[i]; 
      clipfft[clipfft_pa+2*i+1]=cliptimf[cliptimf_px+2*i+1]*micfft_win[i]; 
      clipfft[clipfft_pa+2*j  ]=cliptimf[pb  ]*micfft_win[i]; 
      clipfft[clipfft_pa+2*j+1]=cliptimf[pb+1]*micfft_win[i]; 
      j--;
      pb-=2;
      }      
    fftforward(mic_fftsize, mic_fftn, &clipfft[clipfft_pa], 
                                               micfft_table, micfft_permute);
    if(tx_setup_flag == TRUE)
      {
      lir_sched_yield();
      if(screen_count>=MAX_SCREENCOUNT)
        {
        show_txfft(&clipfft[clipfft_pa],0,1,mic_fftsize);
        }
      }
    for(i=tx_filter_ib1+1; i<tx_filter_ia1; i++)
      {
      clipfft[clipfft_pa+2*i  ]=0;
      clipfft[clipfft_pa+2*i+1]=0;
      }
    clipfft_mute[clipfft_pa/alc_block]=FALSE;
    }
  else
    {
    clipfft_mute[clipfft_pa/alc_block]=TRUE;
    }      
  cliptimf_px=(cliptimf_px+mic_fftsize)&micfft_mask;
  clipfft_pa=(clipfft_pa+alc_block)&alc_mask;
  }
}

float tx_ssb_step6(float *prat)
{
int i, k, pb, mute_previous;
float t1, t2, pmax;
mute_previous=clipfft_mute[((clipfft_px-alc_block+alc_bufsiz)
                                                     &alc_mask)/alc_block];
pmax=0;
prat[0]=0;
if(clipfft_mute[clipfft_px/alc_block] == FALSE)
  {
  alctimf_mute[alctimf_pa/alc_fftsize]=FALSE;
  if(mic_fftsize < alc_fftsize)
    {
    i=tx_filter_ia1;
    k=tx_filter_ia2;
    while(i<mic_fftsize)
      {
      clipfft[clipfft_px+2*k  ]=clipfft[clipfft_px+2*i  ];
      clipfft[clipfft_px+2*k+1]=clipfft[clipfft_px+2*i+1];
      i++;
      k++;
      }      
    }  
  for(i=tx_filter_ib1+1; i<tx_filter_ia2; i++)
    {
    clipfft[clipfft_px+2*i]=0;
    clipfft[clipfft_px+2*i+1]=0;
    }      
  fftback(alc_fftsize, alc_fftn, &clipfft[clipfft_px], 
                                              alc_table, alc_permute);
  if(mute_previous) 
    {
    for(i=0; i<alc_sizhalf; i++)
      {
      alctimf[alctimf_pa+2*i  ]=clipfft[clipfft_px+2*i  ];
      alctimf[alctimf_pa+2*i+1]=clipfft[clipfft_px+2*i+1];
      t2=alctimf[alctimf_pa+2*i  ]*alctimf[alctimf_pa+2*i  ]+
         alctimf[alctimf_pa+2*i+1]*alctimf[alctimf_pa+2*i+1];
      prat[0]+=t2;
      if(t2>pmax)pmax=t2;
      tx_forwardpwr*=txpwr_decay;
      if(tx_forwardpwr<t2)tx_forwardpwr=t2;
      alctimf_pwrf[(alctimf_pa>>1)+i]=tx_forwardpwr;
      }
    }
  else
    {
    for(i=0; i<alc_sizhalf; i++)
      {
      alctimf[alctimf_pa+2*i  ]+=clipfft[clipfft_px+2*i  ];
      alctimf[alctimf_pa+2*i+1]+=clipfft[clipfft_px+2*i+1];
      t2=alctimf[alctimf_pa+2*i  ]*alctimf[alctimf_pa+2*i  ]+
         alctimf[alctimf_pa+2*i+1]*alctimf[alctimf_pa+2*i+1];
      prat[0]+=t2;
      if(t2>pmax)pmax=t2;
      tx_forwardpwr*=txpwr_decay;
      if(tx_forwardpwr<t2)tx_forwardpwr=t2;
      alctimf_pwrf[(alctimf_pa>>1)+i]=tx_forwardpwr;
      }
    }
  }
else
  {
  if(mute_previous)
    {
    tx_forwardpwr=0;
    alctimf_mute[alctimf_pa/alc_fftsize]=TRUE;
    }
  else
    {
    alctimf_mute[alctimf_pa/alc_fftsize]=FALSE;
    for(i=0; i<alc_sizhalf; i++)
      {
      t2=alctimf[alctimf_pa+2*i  ]*alctimf[alctimf_pa+2*i  ]+
         alctimf[alctimf_pa+2*i+1]*alctimf[alctimf_pa+2*i+1];
      prat[0]+=t2;
      if(t2>pmax)pmax=t2;
      tx_forwardpwr*=txpwr_decay;
      if(tx_forwardpwr<t2)tx_forwardpwr=t2;
      alctimf_pwrf[(alctimf_pa>>1)+i]=tx_forwardpwr;
      }
    }
  }  
if( alctimf_mute[alctimf_pa/alc_fftsize] == FALSE)
  {
// Store an exponential power fall-off with the same time constant, 50 ms,
// in the reverse direction.
  i=alc_sizhalf-1;
  t1=0;
  while(i >= 0)
    {
    t1*=txpwr_decay;
    if(t1 < alctimf_pwrf[(alctimf_pa>>1)+i])t1=alctimf_pwrf[(alctimf_pa>>1)+i];
    alctimf_pwrd[(alctimf_pa>>1)+i]=t1;
    i--;
    }
  pb=alctimf_pa;
  t1=alctimf_pwrd[(pb>>1)];
  i=0;
  while( pb != ((int)(alctimf_fx+4+alc_bufsiz)&alc_mask) && i == 0)
    {
    t1*=txpwr_decay;
    pb=(pb+alc_mask)&alc_mask;
    if(t1 > alctimf_pwrf[(pb>>1)])
      {
      alctimf_pwrd[(pb>>1)]=t1;
      }
    else
      {
      i=1;
      }  
    }
  }  
alctimf_pa=(alctimf_pa+alc_fftsize)&alc_mask;
if(clipfft_mute[clipfft_px/alc_block] == FALSE)
  {
  for(i=0; i<alc_fftsize; i++)
    {
    alctimf[alctimf_pa+i]=clipfft[clipfft_px+alc_fftsize+i];
    }
  }
else
  {
  for(i=0; i<alc_fftsize; i++)
    {
    alctimf[alctimf_pa+i]=0;
    }
  }
clipfft_px=(clipfft_px+alc_block)&alc_mask;
return pmax;
}

float tx_ssb_step7(float *prat)
{
int i;
float t1, t2, pmax;
if(alctimf_mute[alctimf_pb/alc_fftsize]==FALSE)
  {
  pmax=0;
  prat[0]=0;
  for(i=0; i<alc_sizhalf; i++)
    {
    t1=alctimf_pwrd[(alctimf_pb>>1)+i];    
    if(t1 > 1)
      {
      t1=1/sqrt(t1);
      alctimf[alctimf_pb+2*i  ]*=t1;
      alctimf[alctimf_pb+2*i+1]*=t1;
      }
    t2=alctimf[alctimf_pb+2*i  ]*alctimf[alctimf_pb+2*i  ]+
       alctimf[alctimf_pb+2*i+1]*alctimf[alctimf_pb+2*i+1];
// We do not want more than MAX_DYNRANGE dynamic range.
// any signal below is just rounding errors in muted periods.
    if(t2 < MAX_DYNRANGE)
      {  
      alctimf[alctimf_pb+2*i  ]=0;
      alctimf[alctimf_pb+2*i+1]=0;
      }
    if(t2 > pmax)pmax=t2;
    prat[0]+=t2;
    }
  }
else
  {
  pmax=0;
  prat[0]=0;
  for(i=0; i<alc_fftsize; i++)
    {
    alctimf[alctimf_pb+i]=0;
    }
  }
alctimf_pb=(alctimf_pb+alc_fftsize)&alc_mask;
return pmax;
}

void tx_ssb_step8(void)
{
if(tx_output_flag == 0)
  {
  if( ((alctimf_pb-(int)(alctimf_fx)+alc_bufsiz)&alc_mask) > 4*alc_fftsize)
    {
    tx_output_flag=1;
    tx_resamp_pa=0;
    tx_resamp_px=0;
    }
  }  
if(tx_output_flag == 1)
  {
  resample_tx_output();
  }
}

void use_tx_resamp(float ampfac)
{
int i, j, k, m;
float t1, t2, t3, r1, r2;
// The latest half block of data resides in tx_resamp[alc_fftsize]
// to tx_resamp[2*alc_fftsize-1]
// Copy the previous block from resamp_tmp and multiply with
// the window function.
k=alc_sizhalf;
m=k-1;
t1=0;
for(i=0; i<alc_sizhalf; i++)
  {
  tx_resamp[2*i  ]=resamp_tmp[2*i  ]*alc_win[i]; 
  tx_resamp[2*i+1]=resamp_tmp[2*i+1]*alc_win[i]; 
  resamp_tmp[2*i  ]=ampfac*tx_resamp[2*k  ];
  resamp_tmp[2*i+1]=ampfac*tx_resamp[2*k+1];
  tx_resamp[2*k  ]*=ampfac*alc_win[m];
  tx_resamp[2*k+1]*=ampfac*alc_win[m];
  m--;
  k++;
  } 
fftforward(alc_fftsize, alc_fftn, tx_resamp, alc_table, alc_permute);
// Clear the spectrum outside the desired passband.
// These data points should be very small.
k=txout_fftsize-alc_fftsize;
if(k > 0)
  {
  for(i=alc_sizhalf; i<alc_fftsize; i++)
    {
    tx_resamp[2*(k+i)  ]=tx_resamp[2*i  ];
    tx_resamp[2*(k+i)+1]=tx_resamp[2*i+1];
    }
  k=txout_fftsize-alc_sizhalf;
  for(i=alc_sizhalf; i<k; i++)
    {
    tx_resamp[2*i  ]=0;
    tx_resamp[2*i+1]=0;
    }
  i=tx_filter_ib3+1;
  k=tx_filter_ia3-1;
  t1=1;
  t3=4./tx_filter_ib3;
  t2=0;
  while(k>=i && t1 >0)
    {
    tx_resamp[2*k]*=t1;
    tx_resamp[2*k+1]*=t1;
    tx_resamp[2*i]*=t1;
    tx_resamp[2*i+1]*=t1;
    t2+=t3;
    t1=1-t2*t2;
    i++;
    k--;
    }
  while(k>=i)
    {
    tx_resamp[2*k]=0;
    tx_resamp[2*k+1]=0;
    tx_resamp[2*i]=0;
    tx_resamp[2*i+1]=0;
    i++;
    k--;
    }
  }
if(k < 0)
  {
  lirerr(77676);
  }
//
//if(screen_count>=MAX_SCREENCOUNT)
//  {
//  if(tx_setup_flag == TRUE)show_txfft(tx_resamp,0,2,txout_fftsize);
//  }
// Now we have the output in the frequency domain at the size txout_fftsize
// with a sampling rate that fits our D/A converter. Transform it back
// to the time domain into txout.
fftback(txout_fftsize, txout_fftn, tx_resamp, txout_table, txout_permute);
for(i=0; i<txout_fftsize; i+=2)
  {
  tx_output_phase+=tx_output_phstep;
  if(tx_output_phase > PI_L)tx_output_phase-=2*PI_L;
  if(tx_output_phase < -PI_L)tx_output_phase+=2*PI_L;
  t1=cos(tx_output_phase);
  t2=sin(tx_output_phase);
  r1=tx_resamp[i  ]+txout_tmp[i  ];
  r2=tx_resamp[i+1]+txout_tmp[i+1];
  txout[i  ]=r1*t1+r2*t2;
  txout[i+1]=-r1*t2+r2*t1;
  }
for(i=0; i<txout_fftsize; i++)
  {
  txout_tmp[i]=tx_resamp[txout_fftsize+i];
  }
// The microphone input is real data at the soundcard speed.
// For timing we use the complex samples at half the speed.
tx_wsamps=lir_tx_input_samples()/2;
k=(mictimf_pa-mictimf_px+mictimf_bufsiz)&mictimf_mask;
k+=(micfft_pa-micfft_px+micfft_bufsiz)&micfft_mask;
k+=(cliptimf_pa-cliptimf_px+micfft_bufsiz)&micfft_mask; 
j=(clipfft_pa-clipfft_px+alc_bufsiz)&alc_mask;
j+=(alctimf_pa-((int)(alctimf_fx))+4+alc_bufsiz)&alc_mask;
j+=alc_fftsize;
k+=j/tx_pre_resample;
tx_wsamps+=k/(2*sizeof(float));
// The maximum amplitude should ideally be 1.0 but since
// a litte power outside the passband was removed in the last 
// backwards transform, a small amount of re-peaking could occur
// Set the maximum level to TX_DA_MARGIN of full scale to make sure
// D/A converters will not overflow.
tx_send_to_da();
lir_refresh_screen();
}

void resample_tx_output(void)
{
int i1, i2, i3, i4, mask2;
float t1, t2, t3, t4, t5, t6, t7, r1, r2;
float a1, a2, rdiff;
// The microphone is best sampled at a low sampling speed since
// we do not want much bandwidth nor dynamic range.
// For the output the requirements depend on the circumstances.
// In case the transmitter is used in a wideband up-conversion
// system, the output sampling rate may be very high and the
// requirements on the signal purity might be very high.
// We do the resampling in two steps. First do a fractional
// resampling to a speed near the speed of the microphone
// signal (but perhaps a power of two below the desired output
// speed as indicated by tx_output_upsample.)
// Subsequently, use an FFT to sample up the signal to the
// desired frequency while filtering out the false signals
// that non-linearities in the fractional resampling have
// introduced.
mask2=alc_mask-1;
begin:;
r1=tx_resamp_pa/tx_resample_ratio;
resamp:;
r2=(tx_resamp_pa+2)/tx_resample_ratio;
i2=alctimf_fx+r1+1;
i3=alctimf_fx+r2+1;
i2&=mask2;
i3&=mask2;
if(abs(i3-i2) > 2)
  {
  i2=alctimf_fx+(r1+r2)/2;
  i3=i2+2;
  i2&=mask2;
  i3&=mask2;
  }
else
  {
  if(i3==i2)
    {
    i2=alctimf_fx+r1;
    i2&=mask2;
    if(i3==i2)
      {
      i3=i2+2;
      i3&=mask2;
      }
    }
  }        
i4=(i3+2)&(mask2);
i1=(i2+mask2)&(mask2);
if( ((alctimf_pb-i4+alc_bufsiz)&alc_mask) > 4)
  {
  if(alctimf_mute[i2/alc_fftsize]==FALSE ||
     alctimf_mute[i3/alc_fftsize]==FALSE)
    {
    rdiff=r1+alctimf_fx-i2;
    if(rdiff > alc_bufsiz/2)
      {
      rdiff-=alc_bufsiz;
      }
    rdiff/=2; 
// Use Lagrange's interpolation formula to fit a third degree
// polynomial to 4 points:
//  a1=-rdiff *   (rdiff-1)*(rdiff-2)*alctimf[i1]/6
//     +(rdiff+1)*(rdiff-1)*(rdiff-2)*alctimf[i2]/2
//     -(rdiff+1)* rdiff   *(rdiff-2)*alctimf[i3]/2
//     +(rdiff+1)* rdiff   *(rdiff-1)*alctimf[i4]/6; 
// Rewrite slightly to save a few multiplications - do not
// think the compiler is smart enough to do it for us.
    t1=rdiff-1;
    t2=rdiff-2;
    t3=rdiff+1;
    t4=t1*t2;
    t5=t3*rdiff;
    t6=rdiff*t4;
    t4=t3*t4;
    t7=t5*t2;
    t5=t5*t1;
    a1=((t5*alctimf[i4  ]-t6*alctimf[i1  ])/3+t4*alctimf[i2  ]-t7*alctimf[i3  ])/2;
    a2=((t5*alctimf[i4+1]-t6*alctimf[i1+1])/3+t4*alctimf[i2+1]-t7*alctimf[i3+1])/2;
// The curve fitting is (of course) just an approximation.
// Make sure we do not go outside our range!
    t2=a1*a1+a2*a2;
    if(t2 > tx_resamp_ampfac1)tx_resamp_ampfac1=t2;
    tx_resamp[tx_resamp_pa+alc_fftsize  ]=a1;
    tx_resamp[tx_resamp_pa+alc_fftsize+1]=a2;
    }
  else
    {
    tx_resamp[tx_resamp_pa+alc_fftsize  ]=0;
    tx_resamp[tx_resamp_pa+alc_fftsize+1]=0;
    }
  r1=r2;
  tx_resamp_pa+=2;
  if(tx_resamp_pa >= alc_fftsize)
    {
    alctimf_fx+=r2;
    if(alctimf_fx>alc_bufsiz)alctimf_fx-=alc_bufsiz;
    t1=tx_resamp_ampfac1;
    if(t1 < tx_resamp_ampfac2)t1=tx_resamp_ampfac2;
/*
{int i;
for(i=0; i<alc_sizhalf; i++)
  {
  t2=tx_resamp[alc_fftsize+2*i  ]*tx_resamp[alc_fftsize+2*i  ]+
     tx_resamp[alc_fftsize+2*i+1]*tx_resamp[alc_fftsize+2*i+1];
//fprintf(dmp,"\n%d  %f ",i,sqrt(t2));
  }   }  
*/

    use_tx_resamp(sqrt(1/t1));
    tx_resamp_ampfac2=tx_resamp_ampfac1;
    tx_resamp_ampfac1=1;
    tx_resample_ratio=new_tx_resample_ratio;
    tx_resamp_pa=0;
    goto begin;
    }
  goto resamp;  
  }
}



void tx_bar(int xt,int yt,int val1, int val2)
{
int x, y;
x=xt*text_width;
y=yt*text_height+1;
if(val1 == val2)
  {
  if(val1 >= 0)return;
  lir_fillbox(x,y,TX_BAR_SIZE,text_height-2,7);
  return;
  }
if(val2 > val1)
  { 
  lir_fillbox(x+val1,y,val2-val1,text_height-2,12);
  }
else
  {  
  lir_fillbox(x+val2,y,val1-val2,text_height-2,7);
  } 
}


void show_txfft(float *z, float lim, int type, int siz)
{
int i, ia, ib, k, m;
int pixels_per_bin, bins_per_pixel;
float t1,t2;
char color;
short int *trc;
if(type >= MAX_DISPLAY_TYPES)
  {
  lirerr(762319); 
  return;
  }
trc=&txtrace[type*tx_show_siz];  
ia=0;
t2=0;
pixels_per_bin=(screen_width-1)/siz;
bins_per_pixel=1;
while(pixels_per_bin == 0)
  {
  siz/=2;
  pixels_per_bin=(screen_width-1)/siz;
  bins_per_pixel*=2;
  }
ib=pixels_per_bin;
lir_sched_yield();
for(i=1; i<siz; i++)
  {
  lir_line(ia,trc[i-1],ib,trc[i],0);
  ia=ib;
  ib+=pixels_per_bin;
  }
lir_sched_yield();
ia=0;
ib=pixels_per_bin;
m=0;
mailbox[0]=0;
for(i=0; i<siz; i++)
  {
  t1=0;
  for(k=0; k<bins_per_pixel; k++)
    {
    t1=z[2*m]*z[2*m]+z[2*m+1]*z[2*m+1];
    m++;
    }
  t1/=bins_per_pixel;  
  k=-0.07*log10(txtrace_gain*(t1+0.0000000000001))*screen_height;
  if(k>txtrace_height)k=txtrace_height;
  if(k<0)k=0;
  trc[i]=k+screen_height-txtrace_height-1;
  if(i>0)
    {
    if(type==0)
      {
      if(t2 > lim)
        {
        color=15;
        }
      else
        {
        color=12;
        }
      }
    else
      {
      color=display_color[type];
      }      
    lir_line(ia,trc[i-1],ib,trc[i],color);
    ia=ib;
    ib+=pixels_per_bin;
    }
  t2=t1;
  }
lir_sched_yield();
}