morse.c

// Copyright (c) <2012> <Leif Asbrink>
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.


#include "globdef.h"
#include "uidef.h"
#include "fft1def.h"
#include "sigdef.h"
#include "screendef.h"

#define ZZ 0.0000001

// Variables and definitions for morse decoding in sigdef.h.
// typedef struct {
// unsigned char type;    // Part type (CW_DOT, CW_SPACE,....A,B,C,...)
// unsigned char unkn;    // Number of unknown states before this part
// unsigned char len;     // Length of character in states
// float midpoint;
// float sep;
// float re;
// float im;
// float tmp;
// }MORSE_DECODE_DATA;
//
// Defines for MORSE_DECODE_DATA.type (cw.type)
// Note that CW_DASH must have the lowest value.
// The data in cw_item_len[255-CW_DASH]; must agree with these definitions!
//
// #define CW_WORDSEP 255
// #define CW_SPACE 254
// #define CW_DOT 253
// #define CW_DASH 252

//   name     data    length
// CW_DASH    |---_|     4
//              ^
// CW_DOT     |-_|       2
//             ^
// CW_SPACE   |__|       2
//             ^
// CW_WORDSEP |____|     4
//              ^
// The way the midpoint is defined does not include the trailing
// key-up of each cw part.
// For characters, midpoint points to the first dash or dot
// of the decoded character.



void check_cw(int num,int type);
void show_cw(char *s);
void find_preceeding_part(void);
void find_prev_char_part(void);
void extrapolate_region_downwards(void);
int mr_dotpos_nom, mr_dashpos_nom;

void insert_char(int charbits, int charlen, int charval)
{
    char chr;
    int i, j;
    float r1;
    if(charbits > 6) {
        chr=243;
    } else {
        cw_decoded_chars++;
        chr=morsascii[charbits-1][charval];
    }
// The current character extends from cw_ptr-charbits to cw_ptr-1
// Include the trailing space at cw_ptr in the character,
// but leave trailing word separators unchanged.
// If a word separator preceeded by a character is present
// at cw_ptr-charbits-1, replace the word separator by a blank.
    i=cw_ptr-charbits;
    if(i >= 2) {
        if(cw[i-1].type == CW_WORDSEP && cw[i-2].type < CW_DASH) {
            cw[i-1].type=' ';
        }
    }
    cw[i].type=chr;
    cw[i].len=charlen;
    j=cw_ptr;
    if(cw[cw_ptr].type == CW_SPACE)j++;
    cw_ptr=i;
    i++;
    if(j < no_of_cwdat) {
        r1=cw[j].midpoint-cw[cw_ptr].midpoint;
        if(r1 < 0)r1+=baseband_size;
        cw[j].sep=r1;
    }
    while(j < no_of_cwdat) {
        cw[i]=cw[j];
        i++;
        j++;
    }
    no_of_cwdat=i-1;
}

void detect_previous_character(int char_pos)
{
    int i, j, charlen, charbits, charval;
    if(char_pos < 1) {
        lirerr(674421);
        return;
    }
    if(cw[char_pos].type != CW_SPACE && cw[char_pos].type != CW_WORDSEP) {
        show_cw("ERROR in detect_previous_character");
        lirerr(674422);
        return;
    }
// We have been called properly with the pointer on a space.
// Step backwards and see if it is preceeded by something
// we are likely to interpret correctly.
    cw_ptr=char_pos-1;
restart:
    ;
    charlen=0;
    charbits=0;
collect_parts:
    ;
    while(cw_ptr >= 0 && (cw[cw_ptr].type==CW_DASH || cw[cw_ptr].type==CW_DOT)) {
        charbits++;
        charlen+=cw[cw_ptr].len;
        cw_ptr--;
    }
    if(charbits==0)return;
    cw_ptr++;
    XZ("xx1");
    if( cw[cw_ptr].unkn > 0 &&
            cw[cw_ptr].type != CW_SPACE &&
            cw[cw_ptr].type != CW_WORDSEP) {
        XZ("xx2");
// We do not know what preceeds this sequence of dots and dashes
// and whatever it was, it was not good enough to give a morse decode.
// Try to fit a dot or a dash in the appropriate position.
        i=no_of_cwdat;
        find_preceeding_part();
        if(kill_all_flag)return;
        if(i != no_of_cwdat) {
            XZ("xx3");
            goto collect_parts;
        }
    }
//show_cw("  XXXX  ");
    if( cw[cw_ptr-1].type == CW_SPACE || cw[cw_ptr-1].type == CW_WORDSEP) {
        charlen=0;
        charval=0;
        j=charbits;
        while(j > 0) {
            j--;
            charlen+=cw[cw_ptr].len;
            charval<<=1;
            if(cw[cw_ptr].type==CW_DASH)charval++;
            cw_ptr++;
        }
        insert_char(charbits, charlen, charval);
// Our search for code parts begins by a search for dashes.
// A sequence without dashes or with very poor ones may
// preceed what we now have detected.
        cw_ptr--;
        if(cw[cw_ptr].unkn > 0) {
            i=no_of_cwdat;
            find_prev_char_part();
            if(kill_all_flag)return;
            if(i != no_of_cwdat) {
                XZ("goto restart");
                goto restart;
            }
        }
    } else {
        DEB"\nWARNING: ROUTINE NOT COMPLETED  ");
        lirerr(564397);
    }
}

void conditional_insert_dashdot(void)
{
    lirerr(8888002);
    return;
    /*
    int sizhalf;
    float dash_re, dash_im, dashpos, dashpos_err, dash_fit;
    float dot_re, dot_im, dotpos, dotpos_err, dot_fit;
    sizhalf=baseband_size>>1;
    cg_wave_start=mr_dashpos_nom-(dash_pts>>1)+baseband_size;
    cg_wave_start&=baseband_mask;
    fit_dash();
    dash_re=cg_wave_coh_re;
    dash_im=cg_wave_coh_im;
    dashpos=cg_wave_midpoint;
    dashpos_err=mr_dashpos_nom-cg_wave_midpoint;
    if(dashpos_err < -sizhalf)dashpos_err+=baseband_size;
    dash_fit=cg_wave_fit;
    cg_wave_start=mr_dotpos_nom-(dot_pts>>1)+baseband_size;
    cg_wave_start&=baseband_mask;
    fit_dot();
    dot_re=cg_wave_coh_re;
    dot_im=cg_wave_coh_im;
    dotpos=cg_wave_midpoint;
    dotpos_err=mr_dotpos_nom-cg_wave_midpoint;
    if(dotpos_err < -sizhalf)dotpos_err+=baseband_size;
    dot_fit=cg_wave_fit;
    //fprintf( dmp,"\n(fit) dot: %f  dash: %f",dot_fit,dash_fit);
    //fprintf( dmp,"\n(err) dot: %f  dash: %f",dotpos_err,dashpos_err);
    if( dash_fit >DASH_DETECT_LIMIT &&
        dash_fit - dot_fit > 0.05 &&
        fabs(dashpos_err) < 0.9 * cwbit_pts &&
        cw[cw_ptr].unkn > 4)
      {
      insert_item(CW_DASH);
    if(kill_all_flag)return;
      cw[cw_ptr].unkn-=4;
      cw[cw_ptr+1].unkn=0;
    XZ("insert dash");
      return;
      }
    if( dot_fit > DOT_DETECT_LIMIT &&
        dot_fit-dash_fit > 0.05 &&
        fabs(dotpos_err) < 0.9 * cwbit_pts)
      {
      insert_item(CW_DOT);
    if(kill_all_flag)return;
      cw[cw_ptr].unkn-=2;
      cw[cw_ptr+1].unkn=0;
    XZ("insert dot");
      return;
      }
    */
}



void find_prev_char_part(void)
{
    int i;
    float t1;
    if(cw[cw_ptr].type == CW_SPACE) {
        i=3;
    } else { // CW_WORDSEP
        i=4;
    }
    t1=baseband_size+cw[cw_ptr].midpoint-i*cwbit_pts+0.5;
    mr_dotpos_nom=((int)t1)&baseband_mask;
    t1-=cwbit_pts;
    mr_dashpos_nom=((int)t1)&baseband_mask;
    conditional_insert_dashdot();
}


void find_preceeding_part(void)
{
    lirerr(888100);
    /*
    int i;
    float dash_chk, dot_chk;
    if( cw_ptr > 0 && cw[cw_ptr].unkn < 8 &&
        (cw[cw_ptr-1].type == CW_DOT || cw[cw_ptr-1].type == CW_DASH))
      {
      set_region_envelope();
      }
    else
      {
      extrapolate_region_downwards();
      }
    if(cw[cw_ptr].type == CW_DASH)
      {
      i=4;
      }
    else  // CW_DOT
      {
      i=3;
      }
    mr_dashpos_nom=cw[cw_ptr].midpoint+baseband_size-i*cwbit_pts+0.5;
    mr_dashpos_nom&=baseband_mask;
    mr_dotpos_nom=(mr_dashpos_nom+(int)(cwbit_pts+0.5))&baseband_mask;
    dot_chk=check_dot(mr_dotpos_nom);
    if(cw[cw_ptr].unkn > 2)
      {
    // See if a dash will fit well.
      dash_chk=check_dash(mr_dashpos_nom);
      if(dash_chk < -0.25 && dot_chk < -0.25)
        {
        cg_wave_midpoint=mr_dashpos_nom;
        cg_wave_coh_re=baseb_envelope[2*mr_dashpos_nom];
        cg_wave_coh_im=baseb_envelope[2*mr_dashpos_nom+1];
        insert_item(CW_WORDSEP);
    if(kill_all_flag)return;
        cw[cw_ptr].unkn-=4;
        cw[cw_ptr+1].unkn=0;
        return;
        }
      }
    else
      {
      dash_chk=-1;
      }
    if(dash_chk < 0.25 && dot_chk < 0.25)return;
    conditional_insert_dashdot();
    */
}

void decoded_cwspeed(void)
{
    float t1, t2, r1, lsum_real, lsum_ideal;
    int i, k;
    cw_ptr=1;
    lsum_real=0;
    lsum_ideal=0;
    t1=0;
    t2=0;
    while(cw_ptr < no_of_cwdat) {
// Get the length of the gap between decoded dots and dashes.
        r1=cw[cw_ptr].sep/cwbit_pts;
        r1-=0.5*(cw[cw_ptr].len+cw[cw_ptr-1].len);
        if(r1 < 0) r1=0;
        k=(int)(r1)&0xfffffffe;
        if(r1-k > 1)k+=2;
// Accumulate regions where we see the keying reasonably well.
        if(k<=8 && fabs(r1-k) < 0.5) {
            lsum_real+=cw[cw_ptr].sep;
            lsum_ideal+=k+0.5*(cw[cw_ptr].len+cw[cw_ptr-1].len);
        } else {
            t1+=lsum_ideal*lsum_real;  //ideal*ideal*(real/ideal)
            t2+=lsum_ideal*lsum_ideal;
            lsum_real=0;
            lsum_ideal=0;
        }
        cw_ptr++;
    }
    t1+=lsum_ideal*lsum_real;  //ideal*ideal*(real/ideal)
    t2+=lsum_ideal*lsum_ideal;
// Get the average ratio of real to ideal, weighted by ideal squared.
// Store as an improved value for cw speed
    fprintf( dmp,"\ndecoded_cwspeed t1 %f t2 %f",t1,t2);
    cwbit_pts=t1/t2;
// Compute the length of un-decoded regions and store in cw[].unkn
    i=baseband_size+cw[0].midpoint-baseb_px;
    i&=baseband_mask;
    cw[0].unkn=(float)(i)/cwbit_pts-cw[0].len/2;
    cw_ptr=1;
    while(cw_ptr < no_of_cwdat) {
        r1=cw[cw_ptr].sep/cwbit_pts;
        r1-=0.5*(cw[cw_ptr].len+cw[cw_ptr-1].len);
        if(r1 < 0) r1=0;
        k=(int)(r1)&0xfffffffe;
        if(r1-k > 1)k+=2;
        cw[cw_ptr].unkn=k;
        cw_ptr++;
    }
}


void continued_morse_decode(void)
{
    int charflag,charlen,charval,charbits;
    cw_ptr=1;
    charflag=0;
    charlen=0;
    charval=0;
    charbits=0;
    while(cw_ptr < no_of_cwdat) {
        if(cw[cw_ptr].unkn != 0)charflag=0;
        if(charbits != 0 && charflag == 1 &&
                (cw[cw_ptr].type == CW_WORDSEP || cw[cw_ptr].type == CW_SPACE)) {
// This is a character surrounded by spaces.
// Get an ascii character from the table.
            insert_char(charbits, charlen, charval);
        }
        if(cw[cw_ptr].type != CW_DASH && cw[cw_ptr].type != CW_DOT) {
            charflag=1;
            charlen=0;
            charval=0;
            charbits=0;
        } else {
            charbits++;
            charlen+=cw[cw_ptr].len;
            charval<<=1;
            if(cw[cw_ptr].type==CW_DASH)charval++;
        }
        cw_ptr++;
    }
}


void first_morse_decode(void)
{
    int charflag,charlen,charval,charbits;
    int first_char_pos;
// We have stored dashes and dots that are next to a dash.
// Look through the data and see if we can find characters.
//show_cw("  AAAA  ");
    cw_decoded_chars=0;
    first_char_pos=-1;
    cw_ptr=1;
    charflag=0;
    charlen=0;
    charval=0;
    charbits=0;
    while(cw_ptr < no_of_cwdat) {
        if(cw[cw_ptr].unkn != 0)charflag=0;
        if(charbits != 0 && charflag == 1 &&
                (cw[cw_ptr].type == CW_WORDSEP || cw[cw_ptr].type == CW_SPACE)) {
// This is a character surrounded by spaces.
// Get an ascii character from the table.
            insert_char(charbits, charlen, charval);
            if(first_char_pos==-1)first_char_pos=cw_ptr;
        }
        if(cw[cw_ptr].type != CW_DASH && cw[cw_ptr].type != CW_DOT) {
            charflag=1;
            charlen=0;
            charval=0;
            charbits=0;
        } else {
            charbits++;
            charlen+=cw[cw_ptr].len;
            charval<<=1;
            if(cw[cw_ptr].type==CW_DASH)charval++;
        }
        cw_ptr++;
    }
    if(cw_decoded_chars > 0) {
        if(first_char_pos > 1)
            DEB"\nFirst char pos: %d",first_char_pos);
            detect_previous_character(first_char_pos-1);
        }
}





void remove_dash(void)
{
    float t1;
    int ia, ib;
    ia=cw[cw_ptr].midpoint-0.5*dash_pts+baseband_size;
    ia&=baseband_mask;
    ib=(ia+dash_pts+1)&baseband_mask;
    while(ia != ib) {
        baseb_fit[2*ia]=0;
        baseb_fit[2*ia+1]=0;
        ia=(ia+1)&baseband_mask;
    }
    ia=cw_ptr+1;
    while(ia < no_of_cwdat) {
        cw[ia-1]=cw[ia];
        ia++;
    }
    if(cw_ptr !=0) {
        t1=cw[cw_ptr].midpoint-cw[cw_ptr-1].midpoint;
        if(t1 < 0)t1+=baseband_size;
        cw[cw_ptr].sep=t1;
    }
    no_of_cwdat--;
}


void set_long_region_envelope(void)
{
    int i, ia, ib, len;
    float t1,t2,r1,r2;
// We have two dashes pointed to by cw_ptr and cw_ptr-1.
// We know the envelope at these points but the separation is large.
// Set envelope at both ends by extrapolation.
    ia=cw[cw_ptr-1].midpoint;
    ia+=(dash_pts>>2);
    ia&=baseband_mask;
    ib=cw[cw_ptr].midpoint;
    t1=cw[cw_ptr-1].coh_re;
    r1=cw[cw_ptr-1].coh_im;
    t2=cw[cw_ptr].coh_re;
    r2=cw[cw_ptr].coh_im;
    ib+=baseband_size-(dash_pts>>2);
    ib&=baseband_mask;
    len=10*cwbit_pts;
    i=0;
    while( i < len ) {
        baseb_envelope[2*ia]=t1;
        baseb_envelope[2*ia+1]=r1;
        baseb_envelope[2*ib]=t2;
        baseb_envelope[2*ib+1]=r2;
        ia=(ia+1)&baseband_mask;
        if(ia == ib)goto avgenv;
        ib=(ib+baseband_mask)&baseband_mask;
        if(ia == ib)goto avgenv;
        i++;
    }
    return;
avgenv:
    ;
    t1=0.5*(t1+t2);
    r1=0.5*(r1+r2);
    while( i < len ) {
        baseb_envelope[2*ia]=t1;
        baseb_envelope[2*ia+1]=r1;
        baseb_envelope[2*ib]=t1;
        baseb_envelope[2*ib+1]=r1;
        ia=(ia+1)&baseband_mask;
        ib=(ib+baseband_mask)&baseband_mask;
        i++;
    }
}

void extrapolate_region_downwards(void)
{
    lirerr(8888003);
    /*
    int ia, ib;
    float t1, r1;
    // We have a dash or dot pointed to by cw_ptr.
    // We know the envelope at this point.
    // Set envelope at points preceeding this code part by extrapolation.
    ib=cw[cw_ptr].midpoint+baseband_size;
    ia=ib-6*cwbit_pts;
    ia&=baseband_mask;
    t1=cw[cw_ptr].coh_re;
    r1=cw[cw_ptr].coh_im;
    if(cw[cw_ptr].type == CW_DASH)
      {
      ib-=dash_pts>>2;
      }
    else
      {
      ib-=dot_pts>>2;
      }
    ib&=baseband_mask;
    while( ia != ib )
      {
      baseb_envelope[2*ia]=t1;
      baseb_envelope[2*ia+1]=r1;
      ia=(ia+1)&baseband_mask;
      }
    */
}

void set_region_envelope(void)
{
    lirerr(8888005);
    /*
    int ia, ib, len;
    float t1,t2,r1,r2;
    // We have two dashes/dots pointed to by cw_ptr and cw_ptr-1.
    // We know the envelope at these points.
    // Set a reasonable envelope across the interval by linear interpolation.
    ia=cw[cw_ptr-1].midpoint;
    if(cw[cw_ptr-1].type == CW_DASH)
      {
      ia+=(dash_pts>>2);
      }
    else
      {
      ia+=(dot_pts>>2);
      }
    ia&=baseband_mask;
    ib=baseband_size+cw[cw_ptr].midpoint;
    if(cw[cw_ptr].type == CW_DASH)
      {
      ib-=(dash_pts>>2);
      }
    else
      {
      ib-=(dot_pts>>2);
      }
    ib&=baseband_mask;
    t1=cw[cw_ptr-1].coh_re;
    r1=cw[cw_ptr-1].coh_im;
    len=(ib-ia+baseband_size)&baseband_mask;
    t2=(cw[cw_ptr].coh_re-t1)/len;
    r2=(cw[cw_ptr].coh_im-r1)/len;
    while(ia != ib)
      {
      t1+=t2;
      r1+=r2;
      baseb_envelope[2*ia]=t1;
      baseb_envelope[2*ia+1]=r1;
      ia=(ia+1)&baseband_mask;
      }
    */
}

void clear_region(void)
{
    int ia, ib;
// We have two dashes pointed to by cw_ptr and cw_ptr-1.
// We know the envelope at these points.
// Clear baseb_fit across the interval.
    ia=cw[cw_ptr-1].midpoint+0.5*dash_pts+baseband_size;
    ib=cw[cw_ptr].midpoint-0.5*dash_pts+1+baseband_size;
    ia&=baseband_mask;
    ib&=baseband_mask;
    while(ia != ib) {
        baseb_fit[2*ia]=0;
        baseb_fit[2*ia+1]=0;
        ia=(ia+1)&baseband_mask;
    }
}

float check_dash(float pos)
{
    int ia, ib, ja, sw;
    float c0, t1, t2, r1, r2, f1, f2;
    float p,err1,err2;
// Place a dash at pos using the phase/amplitude information
// in baseb_envelope.
// Calculate the transformation required for optimum similarity
// between the observed waveform in baseb and the dash we have stored.
    err1=0;
    err2=0;
    p=0;
    ib=pos;
    if( pos-ib < 0.001)pos+=0.001;
    ia=(ib+1)&baseband_mask;
    if( (dash_pts&1) == 0) {
        c0=0.5*(dash_pts-1);
    } else {
        c0=(dash_pts>>1)+1;
    }
// pos is the center of where we want to place a dash.
    sw=0;
    while( sw!=2) {
        sw=0;
        t1=ia-pos;
        if(t1<0)t1+=baseband_size;
        t1=c0+t1;
        if(t1 >= dash_pts-1) {
            baseb_fit[2*ia  ]=0;
            baseb_fit[2*ia+1]=0;
            sw++;
        } else {
            ja=t1;
            t1-=ja;
            t2=1-t1;
            f1=t2*dash_waveform[2*ja  ]+t1*dash_waveform[2*ja+2];
            f2=t2*dash_waveform[2*ja+1]+t1*dash_waveform[2*ja+3];
            r1=baseb_envelope[2*ia  ];
            r2=baseb_envelope[2*ia+1];
            baseb_fit[2*ia  ]=r1*f1+r2*f2;
            baseb_fit[2*ia+1]=r1*f2-r2*f1;
        }
        err1+=baseb_totpwr[ia];
        p+=baseb_fit[2*ia  ]*baseb_fit[2*ia  ]+baseb_fit[2*ia+1]*baseb_fit[2*ia+1];
        err2+=(baseb_fit[2*ia  ]-baseb[2*ia  ])*(baseb_fit[2*ia  ]-baseb[2*ia  ])+
              (baseb_fit[2*ia+1]-baseb[2*ia+1])*(baseb_fit[2*ia+1]-baseb[2*ia+1]);
        t1=pos-ib;
        if(t1<0)t1+=baseband_size;
        t1=c0-t1;
        if(t1 < 1) {
            baseb_fit[2*ib  ]=0;
            baseb_fit[2*ib+1]=0;
            sw++;
        } else {
            ja=t1;
            t1-=ja;
            t2=1-t1;
            f1=t2*dash_waveform[2*ja  ]+t1*dash_waveform[2*ja+2];
            f2=t2*dash_waveform[2*ja+1]+t1*dash_waveform[2*ja+3];
            r1=baseb_envelope[2*ib  ];
            r2=baseb_envelope[2*ib+1];
            baseb_fit[2*ib  ]=r1*f1+r2*f2;
            baseb_fit[2*ib+1]=r1*f2-r2*f1;
        }
        err1+=baseb_totpwr[ib];
        p+=baseb_fit[2*ib  ]*baseb_fit[2*ib  ]+baseb_fit[2*ib+1]*baseb_fit[2*ib+1];
        err2+=(baseb_fit[2*ib  ]-baseb[2*ib  ])*(baseb_fit[2*ib  ]-baseb[2*ib  ])+
              (baseb_fit[2*ib+1]-baseb[2*ib+1])*(baseb_fit[2*ib+1]-baseb[2*ib+1]);
        ia=(ia+1)&baseband_mask;
        ib=(ib+baseband_mask)&baseband_mask;
    }
// In a perfect fit (noise free) we expect this result:
//
//       Case     err1     err2
//       dash      p        0
//       space     0        p
//
// Due to the presence of noise we expect this instead:
//
//       Case     err1     err2       err1-err2
//       dash     p+n        n           p
//       space     n        p+n         -p

    return (err1-err2)/p;
}


void store_dash(void)
{
    short int ir;
    int ia,ib;
    float t2,r2;
// We calculated the dot product between the current waveform and
// the average waveform for a dash when cg_wave_start was computed.
// Normalise and use to set up fitted waveforms.
    ia=cg_wave_midpoint-0.5*dash_pts+baseband_size;
    ia&=baseband_mask;
    ib=(ia+dash_pts)&baseband_mask;
    t2=cg_wave_coh_re;
    r2=cg_wave_coh_im;
// Store the average waveform at the optimum phase and amplitude giving
// the smallest residue when subtracted from baseb.
    ir=0;
    while(ia != ib) {
        baseb_fit[2*ia  ]=t2*dash_waveform[2*ir  ]+r2*dash_waveform[2*ir+1];
        baseb_fit[2*ia+1]=t2*dash_waveform[2*ir+1]-r2*dash_waveform[2*ir  ];
        ir++;
        ia=(ia+1)&baseband_mask;
    }
}