DSP.cpp

//Copyright+LGPL

//-----------------------------------------------------------------------------------------------------------------------------------------------
// Copyright 2000-2013 Makoto Mori, Nobuyuki Oba
//-----------------------------------------------------------------------------------------------------------------------------------------------
// This file is part of MMVARI.

// MMVARI is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

// MMVARI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License along with MMTTY.  If not, see 
// <http://www.gnu.org/licenses/>.
//-----------------------------------------------------------------------------------------------------------------------------------------------



//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <stdlib.h>

#include "DSP.h"
#include "ComLib.h"
#include "Main.h"
double	SAMPFREQ=11025;
int		SAMPBASE=11025;
double	SAMPTXOFFSET=0;
int		SAMPTYPE=0;
double	DEMSAMPFREQ=11025*0.5;

CVARICODE	g_VariCode;
CSinTable	g_SinTable;
int 	g_tBpfTaps[]={64, 80, 128, 256};
//---------------------------------------------------------------------------
#pragma package(smart_init)

const DWORD _tBitData[]={
   	0x00000001, 0x00000002, 0x00000004, 0x00000008,
    0x00000010, 0x00000020, 0x00000040, 0x00000080,
    0x00000100, 0x00000200, 0x00000400, 0x00000800,
    0x00001000, 0x00002000, 0x00004000, 0x00008000,
    0x00010000, 0x00020000, 0x00040000, 0x00080000,
    0x00100000, 0x00200000, 0x00400000, 0x00800000,
    0x01000000, 0x02000000, 0x04000000, 0x08000000,
    0x10000000, 0x20000000, 0x40000000, 0x80000000,
};

const BYTE tQPSK_Viterbi[32]={
	2, 1, 3, 0, 3, 0, 2, 1, 0, 3, 1, 2, 1, 2, 0, 3,
	1, 2, 0, 3, 0, 3, 1, 2, 3, 0, 2, 1, 2, 1, 3, 0,
};

//---------------------------------------------------------------------------
BOOL __fastcall IsRTTY(int m)
{
	return (m==MODE_RTTY)||(m==MODE_U_RTTY);
}
//---------------------------------------------------------------------------
BOOL __fastcall Is170(int m)
{
	return (m==MODE_FSKW)||IsRTTY(m);
}
//---------------------------------------------------------------------------
BOOL __fastcall IsBPSK(int m)
{
	return (m==MODE_BPSK)||(m==MODE_N_BPSK);
}
//---------------------------------------------------------------------------
BOOL __fastcall IsQPSK(int m)
{
	return (m==MODE_qpsk_L)||(m==MODE_qpsk_U);
}
//---------------------------------------------------------------------------
BOOL __fastcall IsPSK(int m)
{
	return IsBPSK(m)||IsQPSK(m);
}
//---------------------------------------------------------------------------
BOOL __fastcall IsFSK(int m)
{
	return (m==MODE_GMSK)||(m==MODE_FSK);
}
//---------------------------------------------------------------------------
BOOL __fastcall IsMFSK(int m)
{
	return (m==MODE_mfsk_L)||(m==MODE_mfsk_U);
}
//---------------------------------------------------------------------------
// ＦＩＲフィルタのたたき込み演算
double __fastcall DoFIR(double *hp, double *zp, double d, int tap)
{
	memcpy(zp, &zp[1], sizeof(double)*tap);
	zp[tap] = d;
	d = 0.0;
	for( int i = 0; i <= tap; i++, hp++, zp++ ){
		d += (*zp) * (*hp);
	}
	return d;
}
//---------------------------------------------------------------------------
//ベッセル関数
static double __fastcall I0(double x)
{
	double	sum, xj;
	int		j;

	sum = 1.0;
	xj = 1.0;
	j = 1;
	while(1){
		xj *= ((0.5 * x) / (double)j);
		sum += (xj*xj);
		j++;
		if( ((0.00000001 * sum) - (xj*xj)) > 0 ) break;
	}
	return(sum);
}
//---------------------------------------------------------------------------
//ＦＩＲフィルタの設計
void __fastcall MakeFilter(double *HP, FIR *fp)
{
	if( fp->n <= 1 ){
		HP[0] = 1.0;
        return;
    }
    if( fp->typ == ffGAUSSIAN ){
		MakeGaussian(HP, fp->n, fp->fcl, fp->fs, fp->gain);
		return;
    }
	int		j, m;
	double	alpha, win, fm, w0, sum;
	double	*hp;

	if( fp->typ == ffHPF ){
		fp->fc = 0.5*fp->fs - fp->fcl;
	}
	else if( fp->typ != ffLPF ){
		fp->fc = (fp->fch - fp->fcl)/2.0;
	}
	else {
		fp->fc = fp->fcl;
	}
	if( fp->att >= 50.0 ){
		alpha = 0.1102 * (fp->att - 8.7);
	}
	else if( fp->att >= 21 ){
		alpha = (0.5842 * pow(fp->att - 21.0, 0.4)) + (0.07886 * (fp->att - 21.0));
	}
	else {
		alpha = 0.0;
	}

	hp = fp->hp;
	sum = PI*2.0*fp->fc/fp->fs;
	if( fp->att >= 21 ){		// インパルス応答と窓関数を計算
		for( j = 0; j <= (fp->n/2); j++, hp++ ){
			fm = (double)(2 * j)/(double)fp->n;
			win = I0(alpha * sqrt(1.0-(fm*fm)))/I0(alpha);
			if( !j ){
				*hp = fp->fc * 2.0/fp->fs;
			}
			else {
				*hp = (1.0/(PI*(double)j))*sin((double)j*sum)*win;
			}
		}
	}
	else {						// インパルス応答のみ計算
		for( j = 0; j <= (fp->n/2); j++, hp++ ){
			if( !j ){
				*hp = fp->fc * 2.0/fp->fs;
			}
			else {
				*hp = (1.0/(PI*(double)j))*sin((double)j*sum);
			}
		}
	}
	hp = fp->hp;
	sum = *hp++;
	for( j = 1; j <= (fp->n/2); j++, hp++ ) sum += 2.0 * (*hp);
	hp = fp->hp;
	if( sum > 0.0 ){
		for( j = 0; j <= (fp->n/2); j++, hp++ ) (*hp) /= sum;
	}

	// 周波数変換

	if( fp->typ == ffHPF ){
		hp = fp->hp;
		for( j = 0; j <= (fp->n/2); j++, hp++ ) (*hp) *= cos((double)j*PI);
	}
	else if( fp->typ != ffLPF ){
		w0 = PI * (fp->fcl + fp->fch) / fp->fs;
		if( fp->typ == ffBPF ){
			hp = fp->hp;
			for( j = 0; j <= (fp->n/2); j++, hp++ ) (*hp) *= 2.0*cos((double)j*w0);
		}
		else {
			hp = fp->hp;
			*hp = 1.0 - (2.0 * (*hp));
			for( hp++, j = 1; j <= (fp->n/2); j++, hp++ ) (*hp) *= -2.0*cos((double)j*w0);
		}
	}
	for( m = fp->n/2, hp = &fp->hp[m], j = m; j >= 0; j--, hp-- ){
		*HP++ = (*hp) * fp->gain;
	}
	for( hp = &fp->hp[1], j = 1; j <= (fp->n/2); j++, hp++ ){
		*HP++ = (*hp) * fp->gain;
	}
}
//---------------------------------------------------------------------------
//ＦＩＲフィルタの設計
void __fastcall MakeFilter(double *HP, int tap, int type, double fs, double fcl, double fch, double att, double gain)
{
	FIR	fir;

	fir.typ = type;
	fir.n = tap;
	fir.fs = fs;
	fir.fcl = fcl;
	fir.fch = fch;
	fir.att = att;
	fir.gain = gain;
	MakeFilter(HP, &fir);
}
//---------------------------------------------------------------------------
//ＦＩＲフィルタ（ヒルベルト変換フィルタ）の設計
//
void __fastcall MakeHilbert(double *H, int N, double fs, double fc1, double fc2)
{
	int L = N / 2;
    double T = 1.0 / fs;

	double W1 = 2 * PI * fc1;
	double W2 = 2 * PI * fc2;

	// 2*fc2*T*SA((n-L)*W2*T) - 2*fc1*T*SA((n-L)*W1*T)

	double w;
	int n;
	double x1, x2;
	for( n = 0; n <= N; n++ ){
		if( n == L ){
			x1 = x2 = 0.0;
		}
		else if( (n - L) ){
			x1 = ((n - L) * W1 * T);
			x1 = cos(x1) / x1;
			x2 = ((n - L) * W2 * T);
			x2 = cos(x2) / x2;
		}
		else {
			x1 = x2 = 1.0;
		}
		w = 0.54 - 0.46 * cos(2*PI*n/(N));
		H[n] = -(2 * fc2 * T * x2 - 2 * fc1 * T * x1) * w;
	}

	if( N < 8 ){
		w = 0;
    	for( n = 0; n <= N; n++ ){
			w += fabs(H[n]);
    	}
		if( w ){
			w = 1.0 / w;
			for( n = 0; n <= N; n++ ){
				H[n] *= w;
			}
    	}
	}
}
//---------------------------------------------------------------------
void __fastcall MakeGaussian(double *H, int N, double fc, double fs, double B)
{
	double W = fc;
    double T = 1.0 / fs;
    double k = B * T * W;

	double	LN = 2.0/log(2.0);
	int	L = N / 2;
    int i, n;
    double sum = 0;
	for( i = 0; i <= N; i++ ){
    	n = i - L;
        if( n < 0 ) n = -n;
		double d = -sqrt(LN) * PI * k * n;
		H[i] = sqrt(LN*PI) * k * exp(d);
        sum += H[i];
    }
	if( sum ){
		sum = 1.0 / sum;
	    for( i = 0; i <= N; i++ ){
			H[i] *= sum;
    	}
    }
}
//---------------------------------------------------------------------
// 周波数特性グラフ（フィルタスレッド内でコールしてはいけない）
//
//	H(ejωT) = [Σ0]Hm cos(mωT) - j[Σ1]Hm sin(mωT)
//
void __fastcall DrawGraph(Graphics::TBitmap *pBitmap, const double *H, int Tap, int &nmax, int init, TColor col, double SampFreq)
{
	int		k, x, y;
	double	f, gdb, g, pi2t, fs;
	double	max;
	char	bf[80];

	TCanvas *tp = pBitmap->Canvas;
	TRect rc;
	rc.Left = 0;
	rc.Right = pBitmap->Width;
	rc.Top = 0;
	rc.Bottom = pBitmap->Height;
	if( init ){
		tp->Brush->Color = clWhite;
		tp->FillRect(rc);
	}
	int	LM;		// 周波数表示のあるライン数
	int DM;		// 内部線の数
	int MM;		// 実線の間隔
	max = 3000;
	fs = SampFreq;
	if( nmax ){
		max = nmax;
	}
	else {
		nmax = max;
	}
#if 0
	LM = 4;
    DM = 19;
    MM = 5;
#else
	switch(nmax){
		case 3000:
			LM = 3;
			DM = 14;
			MM = 5;
			break;
		case 100:
		case 200:
		case 2000:
			LM = 4;
			DM = 19;
			MM = 5;
			break;
		case 400:
		case 800:
		case 4000:
			LM = 4;
			DM = 19;
			MM = 5;
			break;
		default:		// 6000
			LM = 3;
			DM = 11;
			MM = 4;
			break;
	}
#endif
	int XL = 32;
	int XR = pBitmap->Width - 16;
	int YT = 16;
	int YB = pBitmap->Height - 24;

	int i;
	if( init ){
		tp->Pen->Color = clBlack;
		tp->Font->Size = 8;
		tp->MoveTo(XL, YT); tp->LineTo(XR, YT); tp->LineTo(XR, YB); tp->LineTo(XL, YB); tp->LineTo(XL, YT);
		tp->Pen->Color = clGray;
		for( i = 0; i < 7; i++ ){
			tp->Pen->Style = (i & 1) ? psSolid : psDot;
			y = (int)(double(i + 1) * double(YB - YT)/8.0 + YT);
			tp->MoveTo(XL, y); tp->LineTo(XR, y);
		}
		for( i = 1; i < 5; i++ ){
			y = (int)(double(i) * double(YB - YT)/4.0 + YT);
			sprintf( bf, "-%2u", (80 / 4)*i );
			::SetBkMode(tp->Handle, TRANSPARENT);
			tp->TextOut(XL - 6 - tp->TextWidth(bf), y - (tp->TextHeight(bf)/2), bf);
		}
		strcpy(bf, "dB");
		tp->TextOut(XL - 6 - tp->TextWidth(bf), YT-(tp->TextHeight(bf)/2), bf);
		for( i = 1; i <= DM; i++ ){
			tp->Pen->Style = (i % MM) ? psDot : psSolid;
			x = (int)(double(i) * double(XR - XL)/double(DM+1) + XL);
			tp->MoveTo(x, YT); tp->LineTo(x, YB);
		}
		for( i = 0; i <= LM; i++ ){
			x = (int)(double(i) * double(XR - XL)/double(LM) + XL);
			sprintf(bf, "%4.0lf", (max*i)/LM);
			::SetBkMode(tp->Handle, TRANSPARENT);
			tp->TextOut(x - (tp->TextWidth(bf)/2), YB + 6, bf);
		}
		tp->Pen->Color = clRed;
		tp->Pen->Style = psDot;
		x = (int)(XL + (fs/2) * (double(XR-XL)/max));
		tp->MoveTo(x, YT); tp->LineTo(x, YB);

		tp->Pen->Color = clBlue;
		tp->Pen->Style = psSolid;
	}
	int ay = 0;
    int apy = 0;
	double ra, im;
	pi2t = 2.0 * PI / fs;
	tp->Pen->Color = col;
	for( x = XL, f = 0.0; x < XR; x++, f += (max/double(XR-XL)) ){
		if( Tap ){
			ra = im = 0.0;
			for( k = 0; k <= Tap; k++ ){
				ra += H[k] * cos(pi2t*f*k);
				if( k ) im -= H[k] * sin(pi2t*f*k);
			}
			if( ra * im ){
				g = sqrt(ra * ra + im * im);
			}
			else {
				g = 0.0;
			}
		}
		else {
			g = 1.0;
		}
		if( g == 0 ) g = 1.0e-38;
		gdb = 20*0.4342944*log(fabs(g)) + 80.0;
		if( gdb < 0.0 ) gdb = 0.0;
		gdb = (gdb * double(YB-YT))/80.0;
		y = YB - (int)gdb;
		if( x == XL ){
			tp->MoveTo(x, y);
			tp->LineTo(x, y);
		}
		else {
			tp->MoveTo(x-1, ay);
			tp->LineTo(x, y);
		}
		ay = y;

		double ph = 0;
        if( ra ){
	    	ph = atan2(im, ra);
		}
        int yc = (YB + YT) / 2;
        y = yc + (ph * (YB - YT) / (4*PI));
		if( x != XL ){
			tp->Pen->Color = clRed;
			tp->MoveTo(x-1, apy);
            tp->LineTo(x, y);
			tp->Pen->Color = clBlue;
        }
        apy = y;
	}
}


//---------------------------------------------------------------------
// 周波数特性グラフ（フィルタスレッド内でコールしてはいけない）
//
//
void __fastcall DrawGraphIIR(Graphics::TBitmap *pBitmap, double a0, double a1, double a2, double b1, double b2, int &nmax, int init, TColor col, double SampFreq)
{
	int		x, y;
	double	f, gdb, g, pi2t, pi4t, fs;
	double	max;
	char	bf[80];

	TCanvas *tp = pBitmap->Canvas;
	TRect rc;
	rc.Left = 0;
	rc.Right = pBitmap->Width;
	rc.Top = 0;
	rc.Bottom = pBitmap->Height;
	if( init ){
		tp->Brush->Color = clWhite;
		tp->FillRect(rc);
	}
	int	LM;		// 周波数表示のあるライン数
	int DM;		// 内部線の数
	int MM;		// 実線の間隔
	max = 4000;
	fs = SampFreq;
	if( nmax ){
		max = nmax;
	}
	else {
		nmax = max;
	}
	switch(nmax){
		case 3000:
			LM = 3;
			DM = 14;
			MM = 5;
			break;
		case 100:
		case 200:
		case 2000:
			LM = 4;
			DM = 19;
			MM = 5;
			break;
		case 400:
		case 800:
		case 4000:
			LM = 4;
			DM = 19;
			MM = 5;
			break;
		default:		// 6000
			LM = 3;
			DM = 11;
			MM = 4;
			break;
	}
	int XL = 32;
	int XR = pBitmap->Width - 16;
	int YT = 16;
	int YB = pBitmap->Height - 24;

	int i;
	if( init ){
		tp->Pen->Color = clBlack;
		tp->Font->Size = 8;
		tp->MoveTo(XL, YT); tp->LineTo(XR, YT); tp->LineTo(XR, YB); tp->LineTo(XL, YB); tp->LineTo(XL, YT);
		tp->Pen->Color = clGray;
		for( i = 0; i < 5; i++ ){
			tp->Pen->Style = (i & 1) ? psSolid : psDot;
			y = (int)(double(i + 1) * double(YB - YT)/6.0 + YT);
			tp->MoveTo(XL, y); tp->LineTo(XR, y);
		}
		for( i = 1; i < 4; i++ ){
			y = (int)(double(i) * double(YB - YT)/3.0 + YT);
			sprintf( bf, "-%2u", (60 / 3)*i );
			::SetBkMode(tp->Handle, TRANSPARENT);
			tp->TextOut(XL - 6 - tp->TextWidth(bf), y - (tp->TextHeight(bf)/2), bf);
		}
		strcpy(bf, "dB");
		tp->TextOut(XL - 6 - tp->TextWidth(bf), YT-(tp->TextHeight(bf)/2), bf);
		for( i = 1; i <= DM; i++ ){
			tp->Pen->Style = (i % MM) ? psDot : psSolid;
			x = (int)(double(i) * double(XR - XL)/double(DM+1) + XL);
			tp->MoveTo(x, YT); tp->LineTo(x, YB);
		}
		for( i = 0; i <= LM; i++ ){
			x = (int)(double(i) * double(XR - XL)/double(LM) + XL);
			sprintf(bf, "%4.0lf", (max*i)/LM);
			::SetBkMode(tp->Handle, TRANSPARENT);
			tp->TextOut(x - (tp->TextWidth(bf)/2), YB + 6, bf);
		}
		tp->Pen->Color = clRed;
		tp->Pen->Style = psDot;
		x = (int)(XL + (fs/2) * (double(XR-XL)/max));
		tp->MoveTo(x, YT); tp->LineTo(x, YB);

		tp->Pen->Color = clBlue;
		tp->Pen->Style = psSolid;
	}
	int ay = 0;
	pi2t = 2.0 * PI / fs;
	pi4t = 2.0 * pi2t;
	tp->Pen->Color = col;
	double	A, B, C, D, P, R;
	double	cosw, sinw, cos2w, sin2w;
	for( x = XL, f = 0.0; x < XR; x++, f += (max/double(XR-XL)) ){
		cosw = cos(pi2t*f);
		sinw = sin(pi2t*f);
		cos2w = cos(pi4t*f);
		sin2w = sin(pi4t*f);
		A = a0 + a1 * cosw + a2 * cos2w;
		B = 1 + b1 * cosw + b2 * cos2w;
		C = a1 * sinw + a2 * sin2w;
		D = b1 * sinw + b2 * sin2w;
		P = A*A + C*C;
		R = B*B + D*D;
		g = sqrt(P/R);
		if( g == 0 ) g = 1.0e-38;
		gdb = 20*0.4342944*log(fabs(g)) + 60.0;
		if( gdb < 0.0 ) gdb = 0.0;
		gdb = (gdb * double(YB-YT))/60.0;
		y = YB - (int)gdb;
		if( x == XL ){
			tp->MoveTo(x, y);
			tp->LineTo(x, y);
		}
		else {
			tp->MoveTo(x-1, ay);
			tp->LineTo(x, y);
		}
		ay = y;
	}
}

//---------------------------------------------------------------------
// 周波数特性グラフ（フィルタスレッド内でコールしてはいけない）
//
//
void __fastcall DrawGraphIIR(Graphics::TBitmap *pBitmap, CIIR *ip, int &nmax, int init, TColor col, double SampFreq)
{
	int		x, y;
	double	f, gdb, g, pi2t, pi4t, fs;
	double	max;
	char	bf[80];

	TCanvas *tp = pBitmap->Canvas;
	TRect rc;
	rc.Left = 0;
	rc.Right = pBitmap->Width;
	rc.Top = 0;
	rc.Bottom = pBitmap->Height;
	if( init ){
		tp->Brush->Color = clWhite;
		tp->FillRect(rc);
	}
	int	LM;		// 周波数表示のあるライン数
	int DM;		// 内部線の数
	int MM;		// 実線の間隔
	max = 4000;
	fs = SampFreq;
	if( nmax ){
		max = nmax;
	}
	else {
		nmax = max;
	}
	switch(nmax){
		case 3000:
			LM = 3;
			DM = 14;
			MM = 5;
			break;
		case 100:
		case 200:
		case 2000:
			LM = 4;
			DM = 19;
			MM = 5;
			break;
		case 400:
		case 800:
		case 4000:
			LM = 4;
			DM = 19;
			MM = 5;
			break;
		default:		// 6000
			LM = 3;
			DM = 11;
			MM = 4;
			break;
	}
	int XL = 32;
	int XR = pBitmap->Width - 16;
	int YT = 16;
	int YB = pBitmap->Height - 24;

	int i;
	if( init ){
		tp->Pen->Color = clBlack;
		tp->Font->Size = 8;
		tp->MoveTo(XL, YT); tp->LineTo(XR, YT); tp->LineTo(XR, YB); tp->LineTo(XL, YB); tp->LineTo(XL, YT);
		tp->Pen->Color = clGray;
		for( i = 0; i < 5; i++ ){
			tp->Pen->Style = (i & 1) ? psSolid : psDot;
			y = (int)(double(i + 1) * double(YB - YT)/6.0 + YT);
			tp->MoveTo(XL, y); tp->LineTo(XR, y);
		}
		for( i = 1; i < 4; i++ ){
			y = (int)(double(i) * double(YB - YT)/3.0 + YT);
			sprintf( bf, "-%2u", (60 / 3)*i );
			::SetBkMode(tp->Handle, TRANSPARENT);
			tp->TextOut(XL - 6 - tp->TextWidth(bf), y - (tp->TextHeight(bf)/2), bf);
		}
		strcpy(bf, "dB");
		tp->TextOut(XL - 6 - tp->TextWidth(bf), YT-(tp->TextHeight(bf)/2), bf);
		for( i = 1; i <= DM; i++ ){
			tp->Pen->Style = (i % MM) ? psDot : psSolid;
			x = (int)(double(i) * double(XR - XL)/double(DM+1) + XL);
			tp->MoveTo(x, YT); tp->LineTo(x, YB);
		}
		for( i = 0; i <= LM; i++ ){
			x = (int)(double(i) * double(XR - XL)/double(LM) + XL);
			sprintf(bf, "%4.0lf", (max*i)/LM);
			::SetBkMode(tp->Handle, TRANSPARENT);
			tp->TextOut(x - (tp->TextWidth(bf)/2), YB + 6, bf);
		}
		tp->Pen->Color = clRed;
		tp->Pen->Style = psDot;
		x = (int)(XL + (fs/2) * (double(XR-XL)/max));
		tp->MoveTo(x, YT); tp->LineTo(x, YB);

		tp->Pen->Color = clBlue;
		tp->Pen->Style = psSolid;
	}
	int ay = 0;
	pi2t = 2.0 * PI / fs;
	pi4t = 2.0 * pi2t;
	tp->Pen->Color = col;
	double	A, B, C, D, P, R;
	double	cosw, sinw, cos2w, sin2w;
	for( x = XL, f = 0.0; x < XR; x++, f += (max/double(XR-XL)) ){
		cosw = cos(pi2t*f);
		sinw = sin(pi2t*f);
		cos2w = cos(pi4t*f);
		sin2w = sin(pi4t*f);
		g = 1.0;
		double *ap = ip->m_A;
		double *bp = ip->m_B;
		for( i = 0; i < ip->m_order/2; i++, ap += 2, bp += 3 ){
/*
		A = a0 + a1 * cosw + a2 * cos2w;
		B = 1 + b1 * cosw + b2 * cos2w;
		C = a1 * sinw + a2 * sin2w;
		D = b1 * sinw + b2 * sin2w;
*/
			A = bp[0] + bp[1] * cosw + bp[2] * cos2w;
			B = 1 + -ap[0] * cosw + -ap[1] * cos2w;
			C = bp[1] * sinw + bp[2] * sin2w;
			D = -ap[0] * sinw + -ap[1] * sin2w;
			P = A*A + C*C;
			R = B*B + D*D;
			g *= sqrt(P/R);
		}
		if( ip->m_order & 1 ){
			A = bp[0] + bp[1] * cosw;
			B = 1 + -ap[0] * cosw;
			C = bp[1] * sinw;
			D = -ap[0] * sinw;
			P = A*A + C*C;
			R = B*B + D*D;
			g *= sqrt(P/R);
		}
		if( g == 0 ) g = 1.0e-38;
		gdb = 20*0.4342944*log(fabs(g)) + 60.0;
		if( gdb < 0.0 ) gdb = 0.0;
		gdb = (gdb * double(YB-YT))/60.0;
		y = YB - (int)gdb;
		if( x == XL ){
			tp->MoveTo(x, y);
			tp->LineTo(x, y);
		}
		else {
			tp->MoveTo(x-1, ay);
			tp->LineTo(x, y);
		}
		ay = y;
	}
}

//---------------------------------------------------------------------------
// CSinTableクラス
__fastcall CSinTable::CSinTable()
{
	m_Size = 48000;
    m_tSin = new double[m_Size];
	double pi2t = 2 * PI / double(m_Size);
	for( int i = 0; i < m_Size; i++ ){
		m_tSin[i] = sin(double(i) * pi2t);
	}
}
//---------------------------------------------------------------------------
__fastcall CSinTable::~CSinTable()
{
	delete m_tSin;
}
//---------------------------------------------------------------------------
// VCOクラス
__fastcall CVCO::CVCO()
{
	m_SampleFreq = SAMPFREQ;
	m_FreeFreq = 2000.0;
	m_TableSize = g_SinTable.m_Size;
    m_TableCOS = m_TableSize / 4;
	m_c1 = 0.0;
	m_c2 = double(m_TableSize) * m_FreeFreq / m_SampleFreq;
	m_z = 0.0;
}

__fastcall CVCO::~CVCO()
{
}

void __fastcall CVCO::SetGain(double gain)
{
	m_c1 = double(m_TableSize) * gain / m_SampleFreq;
}

void __fastcall CVCO::SetSampleFreq(double f)
{
	m_SampleFreq = f;
	SetFreeFreq(m_FreeFreq);
}

void __fastcall CVCO::SetFreeFreq(double f)
{
	m_FreeFreq = f;
	m_c2 = double(m_TableSize) * m_FreeFreq / m_SampleFreq;
	if( f < 1.0 ) m_z = 0;
}

void __fastcall CVCO::InitPhase(void)
{
	m_z = 0.0;
}
//------------------------------------------------------------------
double __fastcall CVCO::Do(void)
{
	m_z += m_c2;
	if( m_z >= m_TableSize ){
		m_z -= m_TableSize;
	}
	if( m_z < 0 ){
		m_z += m_TableSize;
	}
	return g_SinTable.m_tSin[int(m_z)];
}
//------------------------------------------------------------------
double __fastcall CVCO::Do(double d)
{
#if DEBUG
	if( ABS(d) >= 2.0 ) Application->MainForm->Caption = "VCO over range";
#endif
	// -1 to 1
	m_z += (d * m_c1 + m_c2);
	while( m_z >= m_TableSize ){
		m_z -= m_TableSize;
	}
	while( m_z < 0 ){
		m_z += m_TableSize;
	}
	return g_SinTable.m_tSin[int(m_z)];
}
//------------------------------------------------------------------
double __fastcall CVCO::DoCos(void)
{
	double z = m_z + m_TableCOS;
    if(z >= m_TableSize ) z -= m_TableSize;
	return g_SinTable.m_tSin[int(z)];
}

//------------------------------------------------------------------
static double __fastcall asinh(double x)
{
	return log(x + sqrt(x*x+1.0));
}
//------------------------------------------------------------------
// bc : 0-バターワース, 1-チェビシフ
// rp : 通過域のリップル
void __fastcall MakeIIR(int type, double *A, double *B, double fc, double fs, int order, int bc, double rp)
{
	double	w0, wa, u, zt, x;
	int		j, n;

	if( bc ){		// チェビシフ
		u = 1.0/double(order) * asinh(1.0/sqrt(pow(10.0,0.1*rp)-1.0));
	}
	wa = tan(PI*fc/fs);
	w0 = 1.0;
	n = (order & 1) + 1;
	double *pA = A;
	double *pB = B;
	double s, d, d1, d2;
	for( j = 1; j <= order/2; j++, pA+=2, pB+=3 ){
		if( bc ){	// チェビシフ
			d1 = sinh(u)*cos(n*PI/(2*order));
			d2 = cosh(u)*sin(n*PI/(2*order));
			w0 = sqrt(d1 * d1 + d2 * d2);
			zt = sinh(u)*cos(n*PI/(2*order))/w0;
		}
		else {		// バターワース
			w0 = 1.0;
			zt = cos(n*PI/(2*order));
		}
    	switch(type){
        	case ffLPF:
				s = wa * w0;
				d = 1 + s*2*zt + s*s;
				pA[0] = -2 * (s*s - 1)/d;
        		pA[1] = -(1.0 - s*2*zt + s*s)/d;
        		pB[0] = s*s / d;
        		pB[1] = 2*pB[0];
	        	pB[2] = pB[0];
                break;
            case ffHPF:
				s = wa / w0;
				d = 1 + s*2*zt + s*s;
				pA[0] = -2 * (s*s - 1)/d;
		        pA[1] = -(1.0 - s*2*zt + s*s)/d;
		        pB[0] = 1.0 / d;
		        pB[1] = -2*pB[0];
		        pB[2] = pB[0];
                break;
        }
		n += 2;
	}
	if( bc && !(order & 1) ){
		x = pow( 1.0/pow(10.0,rp/20.0), 1.0/double(order/2) );
		pB = B;
		for( j = 1; j <= order/2; j++, pB+=3 ){
			pB[0] *= x;
			pB[1] *= x;
            pB[2] *= x;
		}
	}
	if( order & 1 ){
		if( bc ) w0 = sinh(u);
		j = (order / 2);
		pA = A + (j*2);
		pB = B + (j*3);
        switch(type){
        	case ffLPF:
				s = wa * w0;
				d = 1 + s;
				pA[0] = -(s - 1)/d;
				pB[0] = wa*w0/d;
				pB[1] = pB[0];
                break;
            case ffHPF:
				s = wa / w0;
				d = 1 + s;
				pA[0] = -(s - 1)/d;
				pB[0] = 1.0/d;
				pB[1] = -pB[0];
            	break;
        }
	}
}

//---------------------------------------------------------------------------
__fastcall CIIR::CIIR()
{
	m_order = 0;
	memset(m_A, 0, sizeof(m_A));
	memset(m_B, 0, sizeof(m_B));
	memset(m_Z, 0, sizeof(m_Z));
}

__fastcall CIIR::~CIIR()
{
}

void __fastcall CIIR::Clear(void)
{
	memset(m_Z, 0, sizeof(m_Z));
}

void __fastcall CIIR::Create(int type, double fc, double fs, int order, int bc, double rp)
{
#if DEBUG
	if( order > IIRMAX ){
		Application->MainForm->Caption = "Over tap in CIIR";
        order = IIRMAX;
    }
#endif
	m_bc = bc;
	m_rp = rp;
	m_order = order;
    m_orderH = order/2;
	::MakeIIR(type, m_A, m_B, fc, fs, order, bc, rp);
}

double __fastcall CIIR::Do(double d)
{
	double *pA = m_A;
	double *pB = m_B;
	double *pZ = m_Z;
	double o;
	for( int i = 0; i < m_orderH; i++, pA+=2, pB+=3, pZ+=2 ){
		d += pZ[0] * pA[0] + pZ[1] * pA[1];
		o = d * pB[0] + pZ[0] * pB[1] + pZ[1] * pB[2];
		pZ[1] = pZ[0];
		if( d < 0 ){
			if( d > -IIRVLIMIT ) d = 0.0;
        }
        else if( d < IIRVLIMIT ){
        	d = 0.0;
        }
		pZ[0] = d;
		d = o;
	}
	if( m_order & 1 ){
		d += pZ[0] * pA[0];
		o = d * pB[0] + pZ[0] * pB[1];
		if( d < 0 ){
			if( d > -IIRVLIMIT ) d = 0.0;
        }
        else if( d < IIRVLIMIT ){
        	d = 0.0;
        }
		pZ[0] = d;
		d = o;
	}
	return d;
}


//---------------------------------------------------------------------------
__fastcall CIIRTANK::CIIRTANK()
{
	b1 = b2 = a0 = z1 = z2 = 0;
	m_SampleFreq = SAMPFREQ;
    m_Freq = CARRIERFREQ;
    m_BW = 100;
    Create();
}
//---------------------------------------------------------------------------
void __fastcall CIIRTANK::Create(void)
{
	SetFreq(m_Freq, m_SampleFreq, m_BW);
}
//---------------------------------------------------------------------------
void __fastcall CIIRTANK::SetFreq(double f, double smp, double bw)
{
	double lb1, lb2, la0;
	lb1 = 2 * exp(-PI * bw/smp) * cos(2 * PI * f / smp);
	lb2 = -exp(-2*PI*bw/smp);
	if( bw ){
		la0 = sin(2 * PI * f/smp) / ((smp/(PI*2.0)) / bw);
	}
	else {
		la0 = sin(2 * PI * f/smp);
	}
	b1 = lb1; b2 = lb2; a0 = la0;
}
//---------------------------------------------------------------------------
double __fastcall CIIRTANK::Do(double d)
{
	d *= a0;
	d += (z1 * b1);
	d += (z2 * b2);
	z2 = z1;
	if( d < 0 ){
		if( d > -IIRVLIMIT ) d = 0.0;
    }
    else if( d < IIRVLIMIT ){
       	d = 0.0;
    }
	z1 = d;
	return d;
}

//---------------------------------------------------------------------------
__fastcall CIIRTANK2::CIIRTANK2()
{
	m_SampleFreq = SAMPFREQ;
    m_Freq = CARRIERFREQ;
    m_BW = 100;
    Create();
}
//---------------------------------------------------------------------------
void __fastcall CIIRTANK2::SetSampleFreq(double f)
{
	m_SampleFreq = f;
    Create();
}
//---------------------------------------------------------------------------
void __fastcall CIIRTANK2::Create(void)
{
	m_Tank1.m_SampleFreq = m_SampleFreq;
    m_Tank1.m_Freq = m_Freq;
    m_Tank1.m_BW = m_BW;
	m_Tank2.m_SampleFreq = m_SampleFreq;
    m_Tank2.m_Freq = m_Freq;
    m_Tank2.m_BW = m_BW;
    m_Tank1.Create();
    m_Tank2.Create();
}
//---------------------------------------------------------------------------
double __fastcall CIIRTANK2::Do(double d)
{
	return m_Tank1.Do(m_Tank2.Do(d));
}

//---------------------------------------------------------------------------
// CFIRクラス
__fastcall CFIR::CFIR()
{
	m_pZ = NULL;
    m_pH = NULL;
    m_Tap = 0;
}

//---------------------------------------------------------------------------
__fastcall CFIR::~CFIR()
{
	if( m_pZ ) delete m_pZ;
    if( m_pH ) delete m_pH;
}
//---------------------------------------------------------------------------
void __fastcall CFIR::Create(int tap, int type, double fs, double fcl, double fch, double att, double gain)
{
	m_Tap = tap;
	if( m_pZ ) delete m_pZ;
    if( m_pH ) delete m_pH;
	m_pZ = new double[tap+1];
	m_pH = new double[tap+1];
    memset(m_pZ, 0, sizeof(double)*(tap+1));
	::MakeFilter(m_pH, tap, type, fs, fcl, fch, att, gain);
}
//---------------------------------------------------------------------------
double __fastcall CFIR::Do(double d)
{
	return DoFIR(m_pH, m_pZ, d, m_Tap);
}
//---------------------------------------------------------------------------
void __fastcall CFIR::SaveCoef(LPCSTR pName)
{
	FILE *fp;
    if( (fp = fopen(pName, "wt")) != NULL ){
		int i;
		for( i = 0; i <= m_Tap; i++ ){
			fprintf(fp, "H[%u]=%lf\n", i, m_pH[i]);
        }
		fclose(fp);
    }
}

//---------------------------------------------------------------------------
// CFIR2クラス
__fastcall CFIR2::CFIR2()
{
	m_pZ = NULL;
    m_pH = NULL;
    m_pZP = NULL;
    m_W = 0;
    m_Tap = 0;
    m_fs = 0;
}

//---------------------------------------------------------------------------
__fastcall CFIR2::~CFIR2()
{
	if( m_pZ ) delete m_pZ;
    if( m_pH ) delete m_pH;
}
//---------------------------------------------------------------------------
void __fastcall CFIR2::Delete(void)
{
	if( m_pZ ) delete m_pZ;
    if( m_pH ) delete m_pH;
	m_pZ = NULL;
    m_pH = NULL;
    m_pZP = NULL;
    m_W = 0;
    m_Tap = 0;
    m_fs = 0;
}
//---------------------------------------------------------------------------
void __fastcall CFIR2::Create(int tap, int type, double fs, double fcl, double fch, double att, double gain)
{
	if( (m_Tap != tap) || !m_pZ || !m_pH ){
		if( m_pZ ) delete m_pZ;
		m_pZ = new double[(tap+1)*2];
    	memset(m_pZ, 0, sizeof(double)*(tap+1)*2);
	    if( m_pH ) delete m_pH;
		m_pH = new double[tap+1];
		m_W = 0;
    }
	m_Tap = tap;
    m_TapHalf = tap/2;
    m_fs = fs;
	::MakeFilter(m_pH, tap, type, fs, fcl, fch, att, gain);
}
//---------------------------------------------------------------------------
void __fastcall CFIR2::Create(int tap, double fs, double fcl, double fch)
{
	if( (m_Tap != tap) || !m_pZ || !m_pH ){
		if( m_pZ ) delete m_pZ;
		m_pZ = new double[(tap+1)*2];
    	memset(m_pZ, 0, sizeof(double)*(tap+1)*2);
	    if( m_pH ) delete m_pH;
		m_pH = new double[tap+1];
		m_W = 0;
    }
	m_Tap = tap;
    m_TapHalf = tap/2;
    m_fs = fs;
	::MakeHilbert(m_pH, tap, fs, fcl, fch);
}
//---------------------------------------------------------------------------
void __fastcall CFIR2::CreateSamp(int tap, double fs, const double *pSmpFQ)
{
	if( (m_Tap != tap) || !m_pZ || !m_pH ){
		if( m_pZ ) delete m_pZ;
		m_pZ = new double[(tap+1)*2];
    	memset(m_pZ, 0, sizeof(double)*(tap+1)*2);
	    if( m_pH ) delete m_pH;
		m_pH = new double[tap+1];
        m_W = 0;
    }

    int htap = tap/2;
    int i, j;
    double *pSamp = new double[tap+1];
    memcpy(pSamp, pSmpFQ, sizeof(double)*(tap/2));
    for( i = 0; i < tap/2; i++ ){
		pSamp[tap-i] = pSamp[i];
    }
    pSamp[tap/2] = pSamp[tap/2 - 1];
    double *pH = new double[tap+1];
    double re, fm;

	for( i = 0; i <= htap; i++ ){
		re = 0.0;
		for( j = 0; j < tap; j++ ){
			fm = 2.0 * PI * double((i*j)%tap)/double(tap);
			re += pSamp[j] * cos(fm);
		}
		pH[i] = re / tap;
    }
#if 0
	fm = 0;
    for( i = 0; i <= htap; i++ ){
		fm += pH[i];
    }
    fm = 0.5 / fm;
    for( i = 0; i <= htap; i++ ){
		pH[i] *= fm;
    }
#endif
	for( i = 0; i <= htap; i++ ) m_pH[htap-i] = pH[i];
	for( i = 0; i < htap; i++ ) m_pH[tap-i] = m_pH[i];
    delete pH;
    delete pSamp;

	m_Tap = tap;
    m_TapHalf = htap;
    m_fs = fs;
}
//---------------------------------------------------------------------------
void __fastcall CFIR2::Clear(void)
{
	if( m_pZ ) memset(m_pZ, 0, sizeof(double)*(m_Tap+1)*2);
    m_W = 0;
}
//---------------------------------------------------------------------------
double __fastcall CFIR2::Do(double d)
{
	double *dp1 = &m_pZ[m_W+m_Tap+1];
	m_pZP = dp1;
	*dp1 = d;
    m_pZ[m_W] = d;
    d = 0;
    double *hp = m_pH;
    for( int i = 0; i <= m_Tap; i++ ){
		d += (*dp1--) * (*hp++);
    }
    m_W++;
	if( m_W > m_Tap ) m_W = 0;
    return d;
}
//---------------------------------------------------------------------------
double __fastcall CFIR2::Do(double *hp)
{
    double d = 0;
    double *dp = m_pZP;
    for( int i = 0; i <= m_Tap; i++ ){
		d += (*dp--) * (*hp++);
    }
    return d;
}
//---------------------------------------------------------------------------
void __fastcall CFIR2::Do(CLX &z, double d)
{
	double *dp1 = &m_pZ[m_W+m_Tap+1];
	m_pZP = dp1;
	*dp1 = d;
    m_pZ[m_W] = d;
    d = 0;
    double *hp = m_pH;
    for( int i = 0; i <= m_Tap; i++ ){
		d += (*dp1--) * (*hp++);
    }
    z.j = d;
    z.r = m_pZ[m_W+m_TapHalf+1];
    m_W++;
	if( m_W > m_Tap ) m_W = 0;
}


//---------------------------------------------------------------------------
// CFIRXクラス
__fastcall CFIRX::CFIRX()
{
	m_pZ = NULL;
    m_pH = NULL;
    m_pZP = NULL;
    m_W = 0;
    m_Tap = 0;
    m_fs = 0;
}

//---------------------------------------------------------------------------
__fastcall CFIRX::~CFIRX()
{
	if( m_pZ ) delete m_pZ;
    if( m_pH ) delete m_pH;
}
//---------------------------------------------------------------------------
void __fastcall CFIRX::Create(int tap, int type, double fs, double fcl, double fch, double att, double gain)
{
	if( (m_Tap != tap) || !m_pZ || !m_pH ){
		if( m_pZ ) delete m_pZ;
		m_pZ = new CLX[(tap+1)*2];
    	memset(m_pZ, 0, sizeof(CLX)*(tap+1)*2);
	    if( m_pH ) delete m_pH;
		m_pH = new double[tap+1];
		m_W = 0;
    }
	m_Tap = tap;
    m_TapHalf = tap/2;
    m_fs = fs;
	::MakeFilter(m_pH, tap, type, fs, fcl, fch, att, gain);
}
//---------------------------------------------------------------------------
void __fastcall CFIRX::CreateSamp(int tap, double fs, const double *pSmpFQ, int wDB)
{
	if( (m_Tap != tap) || !m_pZ || !m_pH ){
		if( m_pZ ) delete m_pZ;
		m_pZ = new CLX[(tap+1)*2];
    	memset(m_pZ, 0, sizeof(CLX)*(tap+1)*2);
	    if( m_pH ) delete m_pH;
		m_pH = new double[tap+1];
        m_W = 0;
    }

    int htap = tap/2;
    int i, j;
    double *pSamp = new double[tap+1];
    memcpy(pSamp, pSmpFQ, sizeof(double)*(tap/2));
	double maxAmp = 0;
	double *dp = pSamp;
    for( i = 0; i < tap/2; i++, dp++ ){
		pSamp[tap-i] = *dp;
		if( maxAmp < *dp ) maxAmp = *dp;
    }
    pSamp[tap/2] = pSamp[tap/2 - 1];
    double *pH = new double[tap+1];
    double re, fm;

	for( i = 0; i <= htap; i++ ){
		re = 0.0;
		dp = pSamp;
		for( j = 0; j < tap; j++ ){
			fm = 2.0 * PI * double((i*j)%tap)/double(tap);
			re += (*dp++) * cos(fm);
		}
		pH[i] = re / tap;
    }
	if( wDB >= 21 ){
		double alpha, att;
		att = double(wDB);
		if( att >= 50.0 ){
			alpha = 0.1102 * (att - 8.7);
		}
		else {
			alpha = (0.5842*pow(att - 21.0, 0.4)) + (0.07886 * (att - 21.0));
		}
		dp = pH;
		for( i = 0; i <= htap; i++, dp++ ){
			double fm = double(2 * i)/double(tap);
			double win = I0(alpha * sqrt(1.0-(fm*fm)))/I0(alpha);
			*dp *= win;
		}
		fm = 0.000001;
		double f = 0.0;
		double g;
		double pi2t = 2.0 * PI / fs;
		int i, k;
		double fk = fs * 0.5 / tap;
		for( i = 0; i < tap; i++, f += fk ){
			g = pH[0];
			for( k = 1; k <= htap; k++ ){
				g += 2.0 * pH[k] * cos(pi2t*f*double(k));
			}
			if( fm < g ) fm = g;
		}
		fm = maxAmp / fm;
		dp = pH;
		for( i = 0; i <= htap; i++, dp++ ){
			*dp *= fm;
		}
	}
	for( i = 0; i <= htap; i++ ) m_pH[htap-i] = pH[i];
	for( i = 0; i < htap; i++ ) m_pH[tap-i] = m_pH[i];
    delete pH;
    delete pSamp;

	m_Tap = tap;
    m_TapHalf = htap;
    m_fs = fs;
}
//---------------------------------------------------------------------------
void __fastcall CFIRX::Clear(void)
{
	if( m_pZ ) memset(m_pZ, 0, sizeof(CLX)*(m_Tap+1)*2);
    m_W = 0;
}
//---------------------------------------------------------------------------
void __fastcall CFIRX::Do(CLX &d)
{
	CLX *dp1 = &m_pZ[m_W+m_Tap+1];
	m_pZP = dp1;
	*dp1 = d;
    m_pZ[m_W] = d;
	CLX z = 0;
    double *hp = m_pH;
    for( int i = 0; i <= m_Tap; i++, dp1-- ){
		z.r += dp1->r * (*hp);
		z.j += dp1->j * (*hp++);
    }
    m_W++;
	if( m_W > m_Tap ) m_W = 0;
    d = z;
}


/*=============================================================================
  CSlideFFTクラス  スライディング　FFT
=============================================================================*/
#define	SLIDE_WINDOW_COEFF		0.9999
__fastcall CSlideFFT::CSlideFFT(void)
{
	m_Length = 0;
	m_Base = 0;
	m_Tones = 0;
	m_kWindow = 0;
	m_pBase = NULL;
    m_pCur = m_pEnd = NULL;
}

//--------------------------------------------------------------------------
__fastcall CSlideFFT::~CSlideFFT()
{
   	if( m_pBase ) delete m_pBase;
}

//--------------------------------------------------------------------------
void __fastcall CSlideFFT::Create(int len, int base, int tones)
{
	if( !m_pBase || (len != m_Length) ){
	   	if( m_pBase ) delete m_pBase;
		m_pBase = new CLX[len];
    }

#if DEBUG
	if( tones > MFSK_MAXTONES ){
		Application->MainForm->Caption = "Tones overflow in CSlideFFT";
        tones = MFSK_MAXTONES;
    }
#endif

    memset(m_pBase, 0, sizeof(CLX)*len);
    memset(m_tWindow, 0, sizeof(m_tWindow));
    memset(m_tData, 0, sizeof(m_tData));

	m_Length = len;
	m_Base = base;
    m_Tones = tones;

	double k = 2.0 * PI / double(len);
	for(int i = 0; i < tones; i++){
		m_tWindow[i].r = cos((i+base) * k) * SLIDE_WINDOW_COEFF;
		m_tWindow[i].j = sin((i+base) * k) * SLIDE_WINDOW_COEFF;
	}
	m_kWindow = pow(SLIDE_WINDOW_COEFF, len);
    m_pCur = m_pBase;
    m_pEnd = &m_pBase[m_Length];
}

//--------------------------------------------------------------------------
CLX* __fastcall CSlideFFT::Do(const CLX &zIn)
{
	CLX z;

	if( m_pCur >= m_pEnd ) m_pCur = m_pBase;
	z = *m_pCur;
	*m_pCur = zIn;
    m_pCur++;
	z *= m_kWindow;

	CLX *pData = m_tData;
	CLX *pWindow = m_tWindow;
	for( int i = 0; i < m_Tones; i++, pData++ ){
		*pData -= z;
		*pData += zIn;
		*pData *= *pWindow++;
	}
	return m_tData;
}

#if DEBUG
//--------------------------------------------------------
// CQSBクラス
__fastcall CQSB::CQSB()
{
    m_vMin = 16384/32;
    m_vMax = 16384/4;
    m_fPhaseError = FALSE;
}

__fastcall CQSB::~CQSB()
{
}

void __fastcall CQSB::Create(int min, int max, int msec, BOOL perr)
{
	m_vMin = min;
    m_vMax = max;

	m_VCO.SetSampleFreq(SAMPFREQ);
    m_VCO.SetFreeFreq(1000.0 / double(msec));
	m_VCOP.SetSampleFreq(SAMPFREQ);
    m_VCOP.SetFreeFreq(1000.0 / 10000.0);
    m_tap = 200;
    memset(m_Z, 0, sizeof(m_Z));

    m_fPhaseError = perr;
}

int __fastcall CQSB::Do(void)
{
    int d = m_VCO.Do() * 16384.0;
	BOOL fm = d < 0;
	d = ABS(d);
	d = m_vMin + ((m_vMax - m_vMin) * d / 16384);
    if( d > 16384 ) d = 16384;
    if( fm && m_fPhaseError ) d *= -1.0;
	return d;
}

double __fastcall CQSB::Do(double d)
{
    double ds = m_VCO.Do();
	if( m_fPhaseError ){
    	double dc = m_VCO.DoCos();
		m_Z[m_tap] = d;
    	memcpy(m_Z, &m_Z[1], m_tap*sizeof(double));
        int n = m_tap * (0.6 + m_VCOP.Do(0.0)*0.4);
        if( n < 0 ) n = 0;
        if( n > m_tap ) n = m_tap;
	    d = m_Z[0] * ds + m_Z[n] * dc;
    }
	if( m_vMin != m_vMax ){
		ds = m_vMin + ((m_vMax - m_vMin) * ABS(ds));
	    if( d > 16384 ) d = 16384;
    }
    else {
		ds = m_vMax;
    }
	return d * ds;
}
//--------------------------------------------------------
// CNoiseクラス
__fastcall CNoise::CNoise()
{
	m_SampleFreq = SAMPFREQ;
//	m_reg = 0x12345;
	m_reg = 0x11111;
    Create(600, 2700);
};

void __fastcall CNoise::SetSampleFreq(double f)
{
	m_SampleFreq = f;
	Create(100, 2700);
}

void __fastcall CNoise::Create(double f1, double f2)
{
	m_HPF.Create(ffHPF, f1, m_SampleFreq, 3, 1, 0.3);
    m_LPF.Create(ffLPF, f2, m_SampleFreq, 7, 1, 0.3);
}

DWORD __fastcall CNoise::Do(void)
{
	DWORD r = m_reg >> 1;
	if( (m_reg ^ r) & 1 ){
		r |= 0xffe00000;
	}
	else {
		r &= 0x001fffff;
	}
	m_reg = r;
    return r >> 19;
}

double __fastcall CNoise::DoLPF(void)
{
	return m_LPF.Do(Do());
}

double __fastcall CNoise::DoHPF(void)
{
    return m_LPF.Do(m_HPF.Do(Do()));
}


void __fastcall AddGaussian(short *pData, int n, double gain)
{
	int i = 0;
	double rad;
	double r;
	double u1;
	double u2;
	while( i < n ){
		do {
			u1 = 1.0 - 2.0 * (double)rand()/(double)RAND_MAX ;
			u2 = 1.0 - 2.0 * (double)rand()/(double)RAND_MAX ;
			r = u1*u1 + u2*u2;
		} while(r >= 1.0 || r == 0.0);
		rad = sqrt(-2.0*log(r)/r);
		pData[i++] += (gain*u1*rad);
		pData[i++] += (gain*u2*rad);
	}
}
#endif

//*********************************************************************
// CDECM2	1/Nデシメータ処理クラス
//
/*
	Clock	復調器	FFT
	6000Hz	6000Hz	6000Hz	1024
	8000Hz	8000Hz	8000Hz	2048
	11025Hz	5513Hz	11025Hz	2048
	12000Hz	6000Hz	6000Hz	1024
	16000Hz	5333Hz	10667Hz	2048
	18000Hz	6000Hz	6000Hz	1024
	22050Hz	5513Hz	11025Hz	2048
	24000Hz	6000Hz	6000Hz	1024
	44100Hz	6300Hz	6300Hz	1024
	48000Hz	6000Hz	6000Hz	1024
	50000Hz	6250Hz	6250Hz	1024
*/
__fastcall CDECM2::CDECM2()
{
	m_Type = 1;
	m_Count = 0;
    SetSampleFreq(m_Type, SAMPFREQ);
}

void __fastcall CDECM2::SetSampleFreq(int type, double f)
{
	m_Type = type;
	m_SampleFreq = f;
#if DECFIR
	switch(m_Type){
		case 2:			// 16000, 18000
		case 3:         // 22050, 24000
		case 4:
		case 5:
			m_FIR.Create(40, ffLPF, m_SampleFreq, 2900, 2900, 40, 1.0);
        	break;
		case 6:			// 44100,
		case 7:			// 48000, 50000
			m_FIR.Create(44, ffLPF, m_SampleFreq, 3000, 3000, 40, 1.0);
        	break;
		default:		// 11025, 12000
			m_FIR.Create(36, ffLPF, m_SampleFreq, 2700, 2700, 40, 1.0);
        	break;
    }
#else
	m_IIR.Create(ffLPF, sys.m_DecCutOff, m_SampleFreq, 10, 1, 0.1);
#endif
}

BOOL __fastcall CDECM2::Do(double d)
{
#if DECFIR
	m_O = m_FIR.Do(d);
#else
	m_O = m_IIR.Do(d);
#endif
	if( !m_Count ){
		m_Count = m_Type;
        return TRUE;
    }
    else {
		m_Count--;
        return FALSE;
    }
}

//--------------------------------------------------------
// CAGCクラス
__fastcall CAGC::CAGC()
{
	m_fc = 1000.0;
	m_MonitorFreq = SAMPFREQ/2048;
    m_SampleFreq = SAMPFREQ;
	m_CarrierFreq = CARRIERFREQ;
    m_LimitGain = 0.005;
    m_AvgOver.Create(4);
	Create();
}
//--------------------------------------------------------
void __fastcall CAGC::Create(void)
{
	m_Count = 0;
	m_Max = -1.0;
	m_Min = 1.0;
	m_d = 0;
	m_agc = 1.0;
//    m_Level.Create(ffLPF, 0.3, m_MonitorFreq, 3, 0, 0);
	SetCarrierFreq(m_CarrierFreq);
}
//--------------------------------------------------------
void __fastcall CAGC::SetCarrierFreq(double f)
{
	m_CarrierFreq = f;
	if( m_CarrierFreq >= 1000.0 ){
	    m_Gain = (m_CarrierFreq / 1000.0);

/*
500		0.003		333
1000	0.0035		285		1.0		1.0
1500	0.005		200		1.4		1.5
1800	0.006		166		1.71
2000	0.008		125     2.3		2.0
2100	0.01		100		2.85	2.1
2200	0.012       83      3.4		2.2
2300	0.015		66      4.3     2.3
2400	0.025       40      7.1		2.4
2500	0.028		36      7.9		2.5
2600	0.030       33      8.6		2.6
*/
        if( m_Gain >= 2.35 ){
			m_Gain *= 7.1 / 2.4;
        }
		else if( m_Gain >= 2.25 ){
			m_Gain *= 4.3 / 2.3;
        }
        else if( m_Gain >= 2.15 ){
        	m_Gain *= 3.4 / 2.2;
        }
		else if( m_Gain >= 2.05 ){
			m_Gain *= 2.9 / 2.1;
        }
        else if( m_Gain >= 1.8 ){
			m_Gain *= 2.3 / 2.2;
        }
    }
    else {
		m_Gain = 1.0;
    }
    SetFC(m_fc);
}
//--------------------------------------------------------
void __fastcall CAGC::SetFC(double fc)
{
	m_fc = fc;
    if( fc > m_CarrierFreq*0.45 ) fc = m_CarrierFreq*0.45;
    m_LPF.Create(ffLPF, fc, m_CarrierFreq, 1, 0, 0);
    m_d = 0;
    m_TLimit = m_SampleFreq*0.8/m_CarrierFreq;
    m_AvgOver.Reset(1.0);
}
//--------------------------------------------------------
void __fastcall CAGC::Reset(void)
{
	m_Max = -1.0;
	m_Min = 1.0;
	m_agc = 1.0;
    m_d = 0;
    m_Count = 0;
    for( int i = 0; i < 12; i++ ){
		m_LPF.Do(1.0);
//    	m_Level.Do(0);
    }
    m_AvgOver.Reset(1.0);
}
//--------------------------------------------------------
double __fastcall CAGC::Do(double d)
{
	if( m_Max < d ) m_Max = d;
	if( m_Min > d ) m_Min = d;
	if( (d >= 0) && (m_d < 0) && (m_Count >= m_TLimit) ){
		double amp = m_Max - m_Min;
        if( amp > 0.1 ){
		    m_agc = m_LPF.Do(5.0/amp);
    	    if( m_agc >= 1.0 ) m_agc = 1.0;
			m_Max = -32768.0;
			m_Min = 32768.0;
        }
        m_Count = 0;
	}
    m_Count++;
	m_d = d;
	d *= m_agc;
    if( d > 2.5 ){ d = 2.5; } else if( d < -2.5 ){ d = -2.5; }
    return d;
}
//--------------------------------------------------------
BOOL __fastcall CAGC::GetOver(void)
{
// 5.0 / (65536 * 0.666)
	return (m_AvgOver.Do(m_agc) < 0.0001146);
//	return (m_agc < 0.0001146);
}

//--------------------------------------------------------
__fastcall CAFC::CAFC()
{
	m_Speed = SPEED;
	m_SampleFreq = SAMPFREQ;
    m_A = m_SampleFreq / (2 * PI);
    m_B = 0.0;
    SetTap(32);
	SetTone(CARRIERFREQ);
    m_LPF.Create(ffLPF, SPEED, m_SampleFreq, 1, 0, 0);
    m_d = 0;
    m_min = 65536.0;
    m_max = -65536.0;
	m_Max = m_Min = 0.0;
	m_Count = 0;
	m_LCount1 = m_SampleFreq * 1.8 / m_Speed;
    m_LCount2 = m_SampleFreq * 31.8 / m_Speed;
}

void __fastcall CAFC::SetPara(double a, double b)
{
	m_A = a;
    m_B = b;
}

void __fastcall CAFC::SetTap(int tap)
{
	m_Avg.Create(tap);
}

void __fastcall CAFC::SetTone(double fq)
{
	m_fq = fq;
	m_Avg.Reset(fq);
    m_fChange = FALSE;
}

BOOL __fastcall CAFC::Do(double d)
{
	BOOL f = FALSE;
	d = m_LPF.Do(d);
    if( m_min > d ) m_min = d;
    if( m_max < d ) m_max = d;
    if( ((m_d < 0.0) && (d >= 0.0) && (m_Count > m_LCount1)) ||
		(m_Count > m_LCount2)
    ){
    	m_Max = m_max; m_Min = m_min;
		double dd = (m_max + m_min) * 0.5;
	    m_min = m_max = d;
        dd = dd * m_A + m_B;

		dd = m_Avg.Do(dd);
		if( (dd >= m_B-100) && (dd <= m_B+100) ){
	        m_fq = dd;
			f = TRUE;
        }
		m_Count = 0;
    }
    m_d = d;
    m_Count++;
	return f;
}


//---------------------------------------------------------------------------
// CLMSクラス
__fastcall CLMS::CLMS()
{
	m_Tap = 48;
    m_lmsDelay = 32;

	memset(Z, 0, sizeof(Z));
	memset(H, 0, sizeof(H));
	memset(D, 0, sizeof(D));

	m_lmsADJSC = 1.0 / double(32768 * 32768);	// スケール調整値

	m_lmsMU2 = 0.003;			// LMS 2μ
	m_lmsGM = 0.9999;			// LMS γ
}

//-------------------------------------------------
// 適応フィルタの演算
double __fastcall CLMS::Do(double d)
{
	double a = 0.0;
	int i;
	double *zp = Z;
	double *hp = H;

	// トランスバーサルフィルタ
	memcpy(Z, &Z[1], sizeof(double)*m_Tap);
	Z[m_Tap] = D[0];
	for( i = 0; i <= m_Tap; i++, zp++, hp++ ){
		a += (*zp) * (*hp);
	}
	// 誤差計算
	double err = d - a;
	double merr = err * m_lmsMU2 * m_lmsADJSC;	// lmsADJSC = 1/(32768 * 32768) スケーリング調整値

	// 遅延器の移動
	if( m_lmsDelay ) memcpy(D, &D[1], sizeof(double)*m_lmsDelay);
	D[m_lmsDelay] = d;
	// 係数更新
	zp = Z;
	hp = H;
	double sum = 0;
	for( i = 0; i <= m_Tap; i++, zp++, hp++ ){
		*hp = (merr * (*zp)) + (*hp * m_lmsGM);
        sum += ABS(*hp);
	}
    if( sum ){
		sum = 1.0 / sum;
        hp = H;
	    for( i = 0; i <= m_Tap; i++, hp++ ){
			*hp *= sum;
    	}
    }
	return a;
}

//---------------------------------------------------------------------------
// CDEMFSKクラス
__fastcall CDEMFSK::CDEMFSK()
{
#if MEASIMD
	m_imd = 0.0;
	m_max = 0.0;
	m_min = 0.0;
	m_amax = 0.0;
	m_amin = 0.0;
#endif

	m_MFSK_TYPE = typMFSK16;
    m_MFSK_TONES = 16;
	m_MFSK_SPEED = 15.625;
	m_MFSK_BW = (m_MFSK_SPEED * (m_MFSK_TONES-1));
	m_MFSK_BITS = 4;

	m_Type = MODE_GMSK;
	m_pBPF = NULL;
	m_Speed = SPEED;
	m_SampleFreq = DEMSAMPFREQ;
//    m_LoopFc = SPEED*6;
//    m_Gain = 1.0;
    m_Gain = 0.8;
	m_CarrierFreq = CARRIERFREQ;
    m_PreBPFTaps = 64;
    m_fAFC = TRUE;
	m_fEnableAFC = FALSE;
    m_out = m_err = 0.0;
	m_RTTYShift = 170.0;
    m_fRTTYTANK = TRUE;
	m_fRTTYFFT = FALSE;
    m_DemLevel = 1.0;
    m_SW = m_Speed * 0.5;
    m_pMFSK = NULL;
    m_fMFSK = FALSE;
    m_fQPSK = FALSE;
    m_BPFLimit = 4.0;
    Create();
}
//---------------------------------------------------------------------------
__fastcall CDEMFSK::~CDEMFSK()
{
	if( m_pMFSK ) delete m_pMFSK;
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::SetMFSKType(int type)
{
    MFSK_SetPara(type, &m_MFSK_TONES, &m_MFSK_SPEED, &m_MFSK_BITS);
	m_MFSK_BW = (m_MFSK_SPEED * (m_MFSK_TONES-1));
    if( type == m_MFSK_TYPE ) return;
	m_MFSK_TYPE = type;
	if( m_pMFSK ) Create();
}

//---------------------------------------------------------------------------
#define	AFC_LPFORDER	3
#define	OUT_LPFORDER	3
void __fastcall CDEMFSK::Create(void)
{
	m_fMFSK = IsMFSK(m_Type);
    m_fQPSK = IsQPSK(m_Type);
	m_fRTTYTANK = (m_Speed < m_RTTYShift);
	m_LPF1.Create(ffLPF, m_Speed, m_SampleFreq, AFC_LPFORDER, 0, 0);
//	m_LPF2.Create(ffLPF, m_Speed, m_SampleFreq, AFC_LPFORDER, 0, 0);
    m_LPF1.Clear();
//    m_LPF2.Clear();
	double fc = m_Speed * 6.0;
    if( fc > m_SampleFreq * 0.45 ) fc = m_SampleFreq * 0.45;
	m_LoopLPF.Create(ffLPF, fc, m_SampleFreq, 1, 0, 0);
	if( Is170(m_Type) ){
		m_FAVG.Create(128*45.45/m_Speed);
    }
	else if( IsFSK(m_Type) ){
		m_FAVG.Create(16);
    }
    else {
		m_FAVG.Create(8192*31.25/m_Speed);
    }

	int nSmooz = int((m_SampleFreq * 45.45 / (m_Speed * 70.0)) + 0.5);
	m_SmoozM.SetCount(nSmooz);
	m_SmoozS.SetCount(nSmooz);

//	m_CIC.Create(4, m_SampleFreq*0.5/m_Speed);
    m_OutLPF.Create(ffLPF, m_Speed*0.5, m_SampleFreq, OUT_LPFORDER, 0, 0);
    m_VCO.SetSampleFreq(m_SampleFreq);

	m_AFC.m_Speed = m_Speed;
	m_AFC.SetTap(16*m_SampleFreq/11025);

    m_Decode.SetSampleFreq(m_SampleFreq);
	m_Decode.SetType(m_Type);
    m_Decode.SetSpeed(m_Speed);
	m_Decode.Reset();

	m_AGC.SetSampleFreq(m_SampleFreq);
    m_TankL.m_BW = m_TankH.m_BW = 60.0;
    m_TankL.SetSampleFreq(m_SampleFreq);
    m_TankH.SetSampleFreq(m_SampleFreq);
	m_PhaseX.SetSampleFreq(m_SampleFreq);

    SetCarrierFreq(m_CarrierFreq);

	m_fEnableAFC = FALSE;
    m_DemLevel = 1.0;
/*
	31.25	88
    45.45	66
    62.5	53
    93.75	37
    125		30
*/
    if( m_fMFSK ){
		if( !m_pMFSK ) m_pMFSK = new CDecMFSK;
	    m_pMFSK->SetMFSKType(m_MFSK_TYPE);
		m_pMFSK->SetSampleFreq(m_SampleFreq);
    }
    else {
		delete m_pMFSK;
        m_pMFSK = NULL;
    }
	m_DecPSK.m_fLSB = (m_Type == MODE_qpsk_L);
	m_DecPSK.SetSampleFreq(m_SampleFreq);
    m_DecPSK.SetCarrierFreq(m_CarrierFreq);
    m_DecPSK.SetSpeed(m_Speed);
	double spd = m_Speed;
    if( spd < 30 ) spd = 30.0;
	switch(m_Type){
		case MODE_N_BPSK:
		case MODE_BPSK:
		case MODE_qpsk_L:
		case MODE_qpsk_U:
			m_LockTh = (2750*2/3)/spd;
			m_AGC.SetFC(500);
            break;
		case MODE_GMSK:
			m_LockTh = (2750*1/2)/spd;
			m_AGC.SetFC(500);
            break;
        case MODE_FSKW:
        case MODE_FSK:
			m_LockTh = (2750*1/3)/spd;
			m_AGC.SetFC(500);
        	break;
        case MODE_RTTY:
        case MODE_U_RTTY:
			m_LockTh = (2750*1/3)/spd;
			m_AGC.SetFC(500);
        	break;
        case MODE_mfsk_L:
			m_pMFSK->m_fLSB = TRUE;
	        m_pMFSK->SetCarrierFreq(m_CarrierFreq);
            m_Lock = TRUE;
        	break;
        case MODE_mfsk_U:
        	m_pMFSK->m_fLSB = FALSE;
	        m_pMFSK->SetCarrierFreq(m_CarrierFreq);
            m_Lock = TRUE;
            break;
	}
    m_out = m_err = 0.0;
}

//---------------------------------------------------------------------------
double __fastcall GetRTTYBW(int taps)
{
	int bw = 180.0;
	if( taps == g_tBpfTaps[1] ){
		bw = 120.0;
    }
	else if( taps == g_tBpfTaps[2] ){
		bw = 70.0;
	}
	else if( taps == g_tBpfTaps[3] ){
		bw = 30.0;
	}
	return bw;
}

//---------------------------------------------------------------------------
double __fastcall GetMFSKBW(int taps)
{
	int bw = 200.0;
	if( taps == g_tBpfTaps[1] ){
		bw = 150.0;
    }
	else if( taps == g_tBpfTaps[2] ){
		bw = 100.0;
	}
	else if( taps == g_tBpfTaps[3] ){
		bw = 50.0;
	}
	return bw;
}

//---------------------------------------------------------------------------
void __fastcall CDEMFSK::MakeBPF(int taps)
{
	int bw;
	m_PreBPFTaps = taps;
	m_PreBPFFC = m_CarrierFreq;
	switch(m_Type){
		case MODE_N_BPSK:
		case MODE_BPSK:
		case MODE_qpsk_L:
		case MODE_qpsk_U:
		case MODE_GMSK:
		    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - m_Speed, m_PreBPFFC + m_Speed, 60, 1.0);
		    m_BPFLimit = m_Speed * 0.125;
            break;
        case MODE_FSK:
		    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - m_Speed*2, m_PreBPFFC + m_Speed*2, 60, 1.0);
		    m_BPFLimit = m_Speed * 0.125;
            break;
        case MODE_FSKW:
        case MODE_RTTY:
        case MODE_U_RTTY:
			bw = GetRTTYBW(taps);
		    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - m_RTTYShift*0.5 - bw, m_PreBPFFC + m_RTTYShift*0.5 + bw, 60, 1.0);
			m_BPFLimit = 5.0;
            break;
        case MODE_mfsk_L:
			bw = GetMFSKBW(taps);
			if( sys.m_MFSK_Center ){
			    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - m_MFSK_BW*0.5 - bw, m_PreBPFFC + m_MFSK_BW*0.5 + bw, 60, 1.0);
            }
            else {
			    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - m_MFSK_BW - bw, m_PreBPFFC + bw, 60, 1.0);
            }
            m_BPFLimit = 2.0;
            break;
        case MODE_mfsk_U:
			bw = GetMFSKBW(taps);
			if( sys.m_MFSK_Center ){
			    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - m_MFSK_BW*0.5 - bw, m_PreBPFFC + m_MFSK_BW*0.5 + bw, 60, 1.0);
            }
            else {
			    m_inBPF.Create(m_PreBPFTaps, ffBPF, m_SampleFreq, m_PreBPFFC - bw, m_PreBPFFC + m_MFSK_BW + bw, 60, 1.0);
            }
            m_BPFLimit = 2.0;
            break;
	}
}

//---------------------------------------------------------------------------
void __fastcall CDEMFSK::SetCarrierFreq(double f)
{
	m_CarrierFreq = f;
	m_RxFreq = f;
	m_CarrierQPSK = f;
    m_RxFreqQPSK = f;

	MakeBPF(m_PreBPFTaps);
    m_VCO.SetFreeFreq(m_CarrierFreq);
	switch(m_Type){
		case MODE_N_BPSK:
		case MODE_BPSK:
		case MODE_GMSK:
		case MODE_qpsk_L:
		case MODE_qpsk_U:
		    m_VCO.SetGain(m_Speed * 0.5 * m_Gain);
			m_AFC.SetPara(m_Speed * 0.5 * m_Gain, m_CarrierFreq);
            m_SW = m_Speed*0.5;
			m_DecPSK.SetCarrierFreq(m_CarrierFreq);
            break;
        case MODE_FSK:
		    m_VCO.SetGain(m_Speed * 1.0 * m_Gain);
			m_AFC.SetPara(m_Speed * 1.0 * m_Gain, m_CarrierFreq);
            m_SW = m_Speed;
        	break;
        case MODE_FSKW:
        case MODE_RTTY:
        case MODE_U_RTTY:
			m_TankL.SetFreq(m_CarrierFreq - (m_RTTYShift * 0.5));
            m_TankH.SetFreq(m_CarrierFreq + (m_RTTYShift * 0.5));
    		m_VCO.SetGain(m_RTTYShift * 1.0 * m_Gain);
			m_AFC.SetPara(m_RTTYShift * 1.0 * m_Gain, m_CarrierFreq);
            m_PhaseX.SetCarrierFreq(m_CarrierFreq - (m_RTTYShift * 0.5));
            m_PhaseX.SetShift(m_RTTYShift);
			m_SW = m_RTTYShift;
        	break;
        case MODE_mfsk_L:
        case MODE_mfsk_U:
			if( m_pMFSK ){
				m_pMFSK->SetCarrierFreq(m_CarrierFreq);
            }
        	break;
    }
    m_AFC.SetTone(m_CarrierFreq);
	m_AGC.SetCarrierFreq(m_CarrierFreq);
	if( IsFSK(m_Type) ) m_FAVG.Reset(m_CarrierFreq);
	m_fEnableAFC = FALSE;
    m_AFCCount = 0;
}
//---------------------------------------------------------------------------
#define	countBPFUPDATE	(3*11025/2048)
void __fastcall CDEMFSK::UpdateBPF(void)
{
	double a = fabs(m_PreBPFFC - m_CarrierFreq);
    if( a >= m_BPFLimit ){
		m_AGC.SetCarrierFreq(m_CarrierFreq);
		MakeBPF(m_PreBPFTaps);
    }
    m_AFCCount++;
//    Application->MainForm->Caption = m_AFCCount;
}
//---------------------------------------------------------------------------
double __fastcall CDEMFSK::GetFreqErr(void)
{
	if( IsBPSK(m_Type) ){
		return m_FAVG.GetAvg();
    }
	else if( m_fMFSK ){
		return (m_RxFreq - m_CarrierFreq) / m_MFSK_SPEED;
    }
    else {
		return (m_RxFreq - m_CarrierFreq) / m_SW;
    }
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::DoAFC(double d)
{
	if( m_AFC.Do(d) ){
		if( !m_fEnableAFC ) return;
		if( m_AFCCount < DEMAFCLIMIT ){
			m_RxFreq = m_AFC.GetFreq();
        }
        else {
			m_RxFreq = m_FAVG.Do(m_AFC.GetFreq());
    	}
        if( !m_fAFC ) return;

        double a = fabs(m_CarrierFreq - m_RxFreq);
        if( (a >= 0.1) && ( a <= (m_Speed*1.5)) ){
        	m_CarrierFreq = m_RxFreq;
			if( m_AFCCount < DEMAFCLIMIT ) m_FAVG.Reset(m_RxFreq);
		    m_VCO.SetFreeFreq(m_CarrierFreq);
			switch(m_Type){
				case MODE_GMSK:
		    		m_VCO.SetGain(m_Speed * 0.5 * m_Gain);
					m_AFC.SetPara(m_Speed * 0.5 * m_Gain, m_CarrierFreq);
		            break;
		        case MODE_FSK:
		    		m_VCO.SetGain(m_Speed * 1.0 * m_Gain);
					m_AFC.SetPara(m_Speed * 1.0 * m_Gain, m_CarrierFreq);
		        	break;
                case MODE_FSKW:
                case MODE_RTTY:
                case MODE_U_RTTY:
//					m_TankL.SetFreq(m_CarrierFreq - (m_RTTYShift * 0.5));
//        		    m_TankH.SetFreq(m_CarrierFreq + (m_RTTYShift * 0.5));
		    		m_VCO.SetGain(m_RTTYShift * 1.0 * m_Gain);
					m_AFC.SetPara(m_RTTYShift * 1.0 * m_Gain, m_CarrierFreq);
                	break;
		    }
            m_AFC.SetTone(m_CarrierFreq);
        }
	}
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::DoAFCPSK(double d)
{
	d = m_FAVG.DoZ(d);
	if( !m_fEnableAFC ) return;
	m_RxFreq = m_CarrierFreq + d * m_Speed * 0.5;
    if( !m_fAFC ) return;

    double a = fabs(m_CarrierFreq - m_RxFreq);
    if( (a >= 0.1) && ( a <= (m_Speed*1.5)) ){
       	m_CarrierFreq = m_RxFreq;
	    m_VCO.SetFreeFreq(m_CarrierFreq);
		switch(m_Type){
			case MODE_N_BPSK:
			case MODE_BPSK:
			case MODE_GMSK:
	    		m_VCO.SetGain(m_Speed * 0.5 * m_Gain);
				m_AFC.SetPara(m_Speed * 0.5 * m_Gain, m_CarrierFreq);
	            break;
	        case MODE_FSK:
	    		m_VCO.SetGain(m_Speed * 1.0 * m_Gain);
				m_AFC.SetPara(m_Speed * 1.0 * m_Gain, m_CarrierFreq);
	        	break;
	    }
        m_AFC.SetTone(m_CarrierFreq);
	    m_out = 0;
    	m_FAVG.Reset();
	}
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::DoAFCQPSK(double d)
{
	d = m_FAVG.DoZ(d);
	if( !m_fEnableAFC ) return;
	m_RxFreqQPSK = m_CarrierQPSK + d * m_Speed * 0.5;
    if( !m_fAFC ) return;

    double a = fabs(m_CarrierQPSK - m_RxFreqQPSK);
    if( (a >= 0.1) && ( a <= (m_Speed*1.5)) ){
       	m_CarrierQPSK = m_RxFreqQPSK;
	    m_VCO.SetFreeFreq(m_CarrierQPSK);
   		m_VCO.SetGain(m_Speed * 0.5 * m_Gain);
		m_AFC.SetPara(m_Speed * 0.5 * m_Gain, m_CarrierQPSK);
        m_AFC.SetTone(m_CarrierFreq);
	    m_out = 0;
    	m_FAVG.Reset();
	}
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::DoAFCRTTY(double d)
{
	if( m_AFC.Do(d) ){
		if( !m_fEnableAFC ) return;
		m_RxFreq = m_AFC.GetFreq();
        if( !m_fAFC ) return;

        double a = fabs(m_CarrierFreq - m_RxFreq);
        if( (a >= 1.0) && ( a <= (150.0)) ){
			a *= 0.5;
			if( m_CarrierFreq < m_RxFreq ){
				m_CarrierFreq += a;
            }
            else {
				m_CarrierFreq -= a;
            }
		    m_VCO.SetFreeFreq(m_CarrierFreq);
			m_TankL.SetFreq(m_CarrierFreq - (m_RTTYShift * 0.5));
   	        m_TankH.SetFreq(m_CarrierFreq + (m_RTTYShift * 0.5));
   			m_VCO.SetGain(m_RTTYShift * 1.0 * m_Gain);
			m_AFC.SetPara(m_RTTYShift * 1.0 * m_Gain, m_CarrierFreq);
            m_AFC.SetTone(m_CarrierFreq);
			m_PhaseX.SetCarrierFreq(m_CarrierFreq - (m_RTTYShift * 0.5));
        }
	}
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::Do(double d)
{
	EPHASE(P_DEMBPF);
	if( m_pBPF ){
		d = m_pBPF->Do(m_inBPF.GetHP());
    }
    else {
		d = m_inBPF.Do(d);
    }
	m_d = d;
	EPHASE(P_DEMAGC);
	d = m_AGC.Do(d);
    switch(m_Type){
    	case MODE_GMSK:				// 同期検波
        case MODE_FSK:
			EPHASE(P_DEMLPF);
			// Loop Filter
			m_out = m_LoopLPF.Do(m_err);
			EPHASE(P_DEMAFC);
		    DoAFC(m_out);
			if( m_out > 1.5 ){ m_out = 1.5; } else if( m_out < -1.5 ){ m_out = -1.5;}
			EPHASE(P_DEMLOCK);
			m_Lock = (m_AFC.m_Max - m_AFC.m_Min) * 100;
		    m_Lock = (m_Lock > m_LockTh);
//		    m_FreqErr = (m_AFC.m_Max + m_AFC.m_Min) * 0.5;
			// VCO
			// 位相比較
			EPHASE(P_DEMVCO);
			m_err = m_VCO.Do(m_out) * d;
			EPHASE(P_DEMOUT);
		    d = m_OutLPF.Do(m_out);
			EPHASE(P_NULL);
			return d * 32768.0;
		case MODE_BPSK:
        case MODE_N_BPSK:			// 同期検波
			{
				EPHASE(P_NULL);
				m_Lock = TRUE;
    	    	double ds = d * m_VCO.Do(m_out);
        	    double dc = d * m_VCO.DoCos();
//				double dc = -ds;
#if 0
				m_out = m_LPF1.Do(ABS(ds)) - m_LPF2.Do(ABS(dc));
#else
				m_out = m_LPF1.Do(ABS(ds)-ABS(dc));
#endif
	   	        DoAFCPSK(m_out);
#if MEASIMD
				double amp = ds * ds + dc * dc;
				if( m_min > amp ) m_min = amp;
                if( m_max < amp ) m_max = amp;
#endif
        	    return m_OutLPF.Do(ds - dc) * 32768.0;
            }
		case MODE_qpsk_L:
        case MODE_qpsk_U:			// 同期検波
			{
				EPHASE(P_NULL);
				m_Lock = TRUE;
    	    	double ds = d * m_VCO.Do(m_out);
        	    double dc = d * m_VCO.DoCos();
				m_out = m_LPF1.Do(ABS(ds)-ABS(dc));
	   	        DoAFCQPSK(m_out);
                return 0;
            }
		case MODE_FSKW:
    	case MODE_RTTY:
        case MODE_U_RTTY:
			if( m_fRTTYTANK ){		// クオドラチャ検波
				EPHASE(P_DEMLPF);
				// Loop Filter
				m_out = m_LoopLPF.Do(m_err);
				EPHASE(P_DEMAFC);
			    DoAFCRTTY(m_out);
				if( m_out > 1.5 ){ m_out = 1.5; } else if( m_out < -1.5 ){ m_out = -1.5;}
				EPHASE(P_DEMLOCK);
				m_Lock = (m_AFC.m_Max - m_AFC.m_Min) * 100;
			    m_Lock = (m_Lock > m_LockTh) && (m_DemLevel >= 0.5);
//		    	m_FreqErr = (m_AFC.m_Max + m_AFC.m_Min) * 0.5;
  				// VCO
  				// 位相比較
				EPHASE(P_DEMVCO);
				m_err = m_VCO.Do(m_out) * d;
				EPHASE(P_NULL);

				if( m_fRTTYFFT ){
					m_PhaseX.DoFSK(d);
					double ds = m_PhaseX.m_ds;
	    	        double dm = m_PhaseX.m_dm;
#if 1
					ds = m_SmoozM.Avg(ds);
                    dm = m_SmoozS.Avg(dm);
					d = ds - dm;
#else
					d = m_OutLPF.Do(m_LPF1.Do(ds-dm));
#endif
	                m_DemLevel = m_FAVG.Do(ABS(d)) * 4.0;
		            if( m_DemLevel >= 1.0 ) m_DemLevel = 1.0;
					if( m_Type == MODE_RTTY ) d = -d;
	        	    return d * 32768.0;
                }
                else {
					d *= 32.0;
	                if( d > 1.0 ) d = 1.0;
	                if( d < -1.0 ) d = -1.0;
					double ds = m_TankH.Do(d);
	    	        double dm = m_TankL.Do(d);
					d = m_OutLPF.Do(m_LPF1.Do(ABS(ds)-ABS(dm)));
	                m_DemLevel = m_FAVG.Do(ABS(d)) * 4.0;
		            if( m_DemLevel >= 1.0 ) m_DemLevel = 1.0;
					if( m_Type == MODE_RTTY ) d = -d;
	        	    return d * 32768.0;
				}
			}
            else {					// 同期検波
				EPHASE(P_DEMLPF);
				// Loop Filter
				m_out = m_LoopLPF.Do(m_err);
				EPHASE(P_DEMAFC);
			    DoAFC(m_out);
				if( m_out > 1.5 ){ m_out = 1.5; } else if( m_out < -1.5 ){ m_out = -1.5;}
				EPHASE(P_DEMLOCK);
				m_Lock = (m_AFC.m_Max - m_AFC.m_Min) * 100;
			    m_Lock = (m_Lock > m_LockTh);
				// VCO
				// 位相比較
				EPHASE(P_DEMVCO);
				m_err = m_VCO.Do(m_out) * d;
				EPHASE(P_DEMOUT);
			    d = m_OutLPF.Do(m_out);
				EPHASE(P_NULL);
				if( m_Type == MODE_RTTY ) d = -d;
				return d * 32768.0;
            }
    }
   	return 0;
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::Do(double d, BOOL fSQ, BOOL fATC)
{
	if( m_fMFSK ){
		if( m_pBPF ){
			d = m_pBPF->Do(m_inBPF.GetHP());
	    }
    	else {
			d = m_inBPF.Do(d);
	    }
		m_d = d;
		m_AGC.Do(d);
		return m_pMFSK->Do(m_pMFSK->m_Phase.Do(d), fSQ);
    }
	else if( m_fQPSK ){
		Do(d);
		int r = m_DecPSK.Do(m_d, fSQ, fATC);
		if( r ){
			m_Decode.m_dTmg2 = m_DecPSK.GetClockError();
			if( m_fEnableAFC ){
				d = m_CarrierQPSK - m_DecPSK.m_NextCarrierFreq;
                if( fabs(d) >= (m_Speed / (3.0 * PI)) ){
					m_RxFreq = m_CarrierQPSK;
                }
                else {
					m_RxFreq = m_DecPSK.m_NextCarrierFreq;
                }
				if( m_fAFC ){
    	        	m_CarrierFreq = m_RxFreq;
					m_DecPSK.SetCarrierFreq(m_CarrierFreq);
	        	    m_AFC.SetTone(m_CarrierFreq);
                }
            }
        }
        return r;
    }
    else {
		return m_Decode.Do(Do(d), fSQ && m_Lock, fATC );
    }
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::GetData(void)
{
	if( m_fMFSK ){
		if( !m_pMFSK ) return 0;
		return m_pMFSK->GetData();
    }
	else if( m_fQPSK ){
		return m_DecPSK.GetData();
    }
    else {
		return m_Decode.GetData();
    }
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::GetTmg(void)
{
	if( m_fMFSK ){
		return m_pMFSK->GetTmg() ? 1 : -1;
    }
	else if( m_fQPSK ){
		return m_DecPSK.GetTmg() ? 1 : -1;
	}
    else {
		return m_Decode.GetTmg();
    }
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::GetTmgLock(void)
{
	if( m_fMFSK ){
		return m_pMFSK->GetTmgLock();
    }
	else if( m_fQPSK ){
		return m_DecPSK.GetTmgLock();
	}
    else {
		return m_Decode.m_Lock;
    }
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::GetS(void)
{
	if( m_fMFSK ){
		return (m_pMFSK->GetS() - (m_MFSK_TONES/2)) * 32768/m_MFSK_TONES;
    }
	else if( m_fQPSK ){
		return m_DecPSK.GetS();
	}
    else {
		return m_Decode.m_s ? 16384.0 : -16384.0;
    }
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::ResetMFSK(void)
{
	if( m_pMFSK ){
		m_pMFSK->Reset();
    }
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::ResetMeasMFSK(void)
{
	if( m_pMFSK ){
		m_pMFSK->ResetMeas();
    }
}
//---------------------------------------------------------------------------
BOOL __fastcall CDEMFSK::GetSyncState(void)
{
	if( m_fMFSK ){
		if( !m_pMFSK ) return FALSE;
		return m_pMFSK->GetSyncState();
    }
	else if( m_fQPSK ){
		return m_DecPSK.GetSyncState();
    }
    else {
		return m_Decode.GetSyncState();
    }
}
//---------------------------------------------------------------------------
int __fastcall CDEMFSK::GetClockError(void)
{
	if( m_fMFSK ){
		if( !m_pMFSK ) return 0;
		return m_pMFSK->GetClockError();
    }
	else if( m_fQPSK ){
		return m_DecPSK.GetClockError();
    }
    else {
		double d = m_Decode.m_dTmg2;
        if( d >= 0 ){d += 0.5;} else { d -= 0.5; }
		return d;
    }
}
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::SetTmg(int ppm)
{
	if( m_fMFSK ){
		m_pMFSK->SetTmg(ppm);
    }
	else if( m_fQPSK ){
		m_DecPSK.SetTmg(ppm);
	}
    else if( !IsRTTY(m_Type) ){
		m_Decode.SetTmg(ppm);
    }
}
#if MEASIMD
//---------------------------------------------------------------------------
void __fastcall CDEMFSK::CalcIMD(void)
{
	if( m_max > m_min ){
		m_amax = m_max > 0.0 ? sqrt(m_max) : 0.1;
        m_amin = m_min > 0.0 ? sqrt(m_min) : 0.1;
        DoAvg(m_imd, 20.0*log10(m_amax / m_amin), 0.25);
		Application->MainForm->Caption = m_imd;
    }
	m_max = 0.0;
    m_min = 65536.0;
}
#endif

//---------------------------------------------------------------------------
__fastcall CMODFSK::CMODFSK()
{
	m_MFSK_TYPE = typMFSK16;
    m_MFSK_TONES = 16;
	m_MFSK_SPEED = 15.625;
	m_MFSK_BW = (m_MFSK_SPEED * (m_MFSK_TONES-1));

	m_MFSK_K = 1.0 / double(m_MFSK_TONES);
	m_fMFSK = FALSE;

    m_fQPSK = FALSE;
    m_fLSB = FALSE;
	m_Type = 0;
	m_Speed = SPEED;
    m_CWSpeed = 20;
	m_SampleFreq = SAMPFREQ;
	m_CarrierFreq = CARRIERFREQ;
    m_Encode.SetVCO(&m_Carrier);
    m_OutVol = 1;
    m_RTTYShift = 170.0;
	Create();
}
//---------------------------------------------------------------------------
__fastcall CMODFSK::~CMODFSK()
{
}
//---------------------------------------------------------------------------
void __fastcall CMODFSK::SetMFSKType(int type)
{
	m_MFSK_TYPE = type;
	MFSK_SetPara(type, &m_MFSK_TONES, &m_MFSK_SPEED, NULL);
	m_MFSK_BW = (m_MFSK_SPEED * (m_MFSK_TONES-1));
	m_MFSK_K = 1.0 / double(m_MFSK_TONES);
    m_Encode.SetMFSKType(type);
    SetCarrierFreq(m_CarrierFreq);
}
//---------------------------------------------------------------------------
void __fastcall CMODFSK::Reset(void)
{
	SetCWSpeed(m_CWSpeed);
    m_OutVol = 1;
    m_AMPCW.Reset();
    m_AMPSIG.Reset();
    m_BPF.Clear();

	m_Sym.r = 1;
    m_Sym.j = 0;
	m_PrevSym = m_Sym;
    m_SHDATA = 0;
}

//---------------------------------------------------------------------------
void __fastcall CMODFSK::CreateGMSK(void)
{
	// Gaussian特性のテーブルを作成する (1.0 to -1.0)
	int i;
    double w = m_SampleFreq/m_Speed;
	double BT = 1.0;
    double LN2 = sqrt(2.0/log(2.0));
    double LN2P = sqrt(2.0*PI/log(2.0));
    double cd = 0;
    for( i = 0; i < MODTABLEMAX; i++ ){
//		double d = LN2 * PI * BT * double(i)/w;
//		d = BT * exp(-(d * d));
//        d = 1.0 - d;
		double d = LN2 * PI * BT * double(i-w*0.5)/w;
		d = LN2P * BT * exp(-(d * d));
        cd += (d / w);
		// d = 0 to 1
		m_Tbl[MOD_Z2P][i] = cd;					// 0 to 1
		m_Tbl[MOD_Z2M][i] = -cd;					// 0 to -1
        m_Tbl[MOD_P2M][i] = 1.0 - cd * 2;		// 1 to -1
        m_Tbl[MOD_M2P][i] = cd * 2 - 1.0;		// -1 to 1
    }
}

//---------------------------------------------------------------------------
void __fastcall CMODFSK::CreatePSK(void)
{
	// Cos特性のテーブルを作成する (1.0 to -1.0)
	int i;
	if( m_fQPSK ){
	    double k = PI * m_Speed / m_SampleFreq;
	    for( i = 0; i < MODTABLEMAX; i++ ){
			double cd = cos(double(i)*k) * 0.5 + 0.5;
			m_Tbl[MOD_Z2P][i] = -cd;			  	// 0 to 1
			m_Tbl[MOD_Z2M][i] = cd;					// 0 to -1
	        m_Tbl[MOD_P2M][i] = cd;					// 1 to -1
	        m_Tbl[MOD_M2P][i] = -cd;				// -1 to 1
	    }
    }
    else {
	    double k = PI * m_Speed / m_SampleFreq;
	    for( i = 0; i < MODTABLEMAX; i++ ){
			double cd = cos(double(i)*k);
			if( i >= (m_SampleFreq / m_Speed) ) cd = -1.0;
			m_Tbl[MOD_Z2P][i] = -cd;			  	// 0 to 1
			m_Tbl[MOD_Z2M][i] = cd;					// 0 to -1
	        m_Tbl[MOD_P2M][i] = cd;					// 1 to -1
	        m_Tbl[MOD_M2P][i] = -cd;				// -1 to 1
	    }
    }
}

//---------------------------------------------------------------------------
void __fastcall CMODFSK::CreateRTTY(void)
{
#if 0
	// Gaussian特性のテーブルを作成する (1.0 to -1.0)
	int i;
    double w = m_SampleFreq/m_Speed;
	double BT = 0.5;
    double LN2 = sqrt(2.0/log(2.0));
    double LN2P = sqrt(2.0*PI/log(2.0));
    double cd = 0;
    for( i = 0; i < MODTABLEMAX; i++ ){
//		double d = LN2 * PI * BT * double(i)/w;
//		d = BT * exp(-(d * d));
//        d = 1.0 - d;
		double d = LN2 * PI * BT * double(i-w*0.5)/w;
		d = LN2P * BT * exp(-(d * d));
        cd += (d / w);
		// d = 0 to 1
		m_Tbl[MOD_Z2P][i] = cd;					// 0 to 1
		m_Tbl[MOD_Z2M][i] = -cd;					// 0 to -1
        m_Tbl[MOD_P2M][i] = 1.0 - cd * 2;		// 1 to -1
        m_Tbl[MOD_M2P][i] = cd * 2 - 1.0;		// -1 to 1
    }
#else
	int i;
    for( i = 0; i < MODTABLEMAX; i++ ){
		m_Tbl[MOD_Z2P][i] = 1;		// 0 to 1
		m_Tbl[MOD_Z2M][i] = -1;		// 0 to -1
        m_Tbl[MOD_P2M][i] = -1;		// 1 to -1
        m_Tbl[MOD_M2P][i] = 1;		// -1 to 1
    }
#endif
}

//---------------------------------------------------------------------------
void __fastcall CMODFSK::Create(void)
{
	m_fMFSK = IsMFSK(m_Type);
    m_fQPSK = IsQPSK(m_Type);
	m_Encode.SetType(m_Type);
	if( m_fMFSK ){
	    m_Encode.SetMFSKType(m_MFSK_TYPE);
    }
	m_Sym.r = 1;
    m_Sym.j = 0;
	m_PrevSym = m_Sym;
	m_s = 0;
	m_Carrier.SetSampleFreq(m_SampleFreq);

    SetCarrierFreq(m_CarrierFreq);
	m_Encode.SetSampleFreq(m_SampleFreq);
	m_Encode.SetSpeed(m_Speed);
	SetCWSpeed(m_CWSpeed);
	m_AMPSIG.SetMax(m_SampleFreq/m_Speed);

    switch(m_Type){
		case MODE_GMSK:
        case MODE_FSK:
        case MODE_FSKW:
			m_Encode.m_fTWO = FALSE;
		    CreateGMSK();
        	break;
		case MODE_BPSK:
			m_Encode.m_fTWO = FALSE;
			CreatePSK();
			break;
        case MODE_N_BPSK:
		case MODE_qpsk_L:
        case MODE_qpsk_U:
			m_Encode.m_fTWO = TRUE;
			CreatePSK();
			m_fLSB = (m_Type == MODE_qpsk_L);
        	break;
        case MODE_RTTY:
        case MODE_U_RTTY:
			m_Encode.m_fTWO = FALSE;
			if( m_Speed >= m_RTTYShift ){
			    CreateGMSK();
            }
            else {
			    CreateRTTY();
            }
        	break;
        case MODE_mfsk_L:
        case MODE_mfsk_U:
			m_Encode.m_fTWO = TRUE;
			CreateRTTY();	// dummy
        	break;
	}
    m_pTbl = NULL;
    m_d = 0.0;
}

//---------------------------------------------------------------------------
void __fastcall CMODFSK::SetCWSpeed(int d)
{
	m_CWSpeed = d;
    int dCW = m_SampleFreq/m_CWSpeed;
	if( dCW < 2 ) dCW = 2;
	m_AMPCW.SetMax(dCW*0.25);
	m_Encode.SetCW(d);
}

//---------------------------------------------------------------------------
void __fastcall CMODFSK::SetCarrierFreq(double f)
{
	m_CarrierFreq = f;
	m_Carrier.SetFreeFreq(m_CarrierFreq);
	switch(m_Type){
		case MODE_qpsk_L:
        case MODE_qpsk_U:
		case MODE_BPSK:
        case MODE_N_BPSK:
		case MODE_GMSK:
		    m_Carrier.SetGain((m_Speed * 0.5) * 0.5);	// fm = 0.5
            break;
        case MODE_FSK:
		    m_Carrier.SetGain((m_Speed * 0.5) * 1.0);	// fm = 1.0
			break;
		case MODE_FSKW:
        case MODE_RTTY:
        case MODE_U_RTTY:
		    m_Carrier.SetGain(m_RTTYShift * 0.5);
			break;
        case MODE_mfsk_L:
//		    m_Carrier.SetGain(-250);
		    m_Carrier.SetGain(-m_MFSK_SPEED * m_MFSK_TONES);
			if( sys.m_MFSK_Center ){
				m_Carrier.SetFreeFreq(m_CarrierFreq+m_MFSK_BW*0.5);
            }
			break;
        case MODE_mfsk_U:
//		    m_Carrier.SetGain(250);
		    m_Carrier.SetGain(m_MFSK_SPEED * m_MFSK_TONES);
			if( sys.m_MFSK_Center ){
				m_Carrier.SetFreeFreq(m_CarrierFreq-m_MFSK_BW*0.5);
            }
			break;
    }
	double fl, fh;
    int fHigh = (m_SampleFreq >= 15000.0);
    int type = ffBPF;
    double dATT = 60;
    if( fHigh ) dATT -= ((m_SampleFreq - 15000.0)/1750);
	if( Is170(m_Type) ){
		double hw = m_RTTYShift * 0.5;
	    fl = m_CarrierFreq - hw - (fHigh ? (m_SampleFreq*0.1) : 200);
    	fh = m_CarrierFreq + hw + (fHigh ? (m_SampleFreq*0.1) : 200);
    }
	else if( m_fMFSK ){
		double hw = m_MFSK_SPEED;
		if( m_Type == MODE_mfsk_U ){
		    fl = m_CarrierFreq - hw - (fHigh ? (m_SampleFreq*0.1) : 200);
    		fh = m_CarrierFreq + m_MFSK_BW + hw + (fHigh ? (m_SampleFreq*0.1) : 200);
        }
        else {
		    fl = m_CarrierFreq - m_MFSK_BW - hw - (fHigh ? (m_SampleFreq*0.1) : 200);
    		fh = m_CarrierFreq + hw + (fHigh ? (m_SampleFreq*0.1) : 200);
        }
    }
    else {
	    fl = m_CarrierFreq-m_Speed - (fHigh ? (m_SampleFreq*0.1) : 200);
    	fh = m_CarrierFreq+m_Speed + (fHigh ? (m_SampleFreq*0.1) : 200);
    }
    if( fl < (fHigh ? 800 : 200) ){
		type = ffLPF;
        fl = fh;
    }
	m_BPF.Create(24, type, m_SampleFreq, fl, fh, dATT, 1.0);
}

//--------------------------------------------------------
double __fastcall CMODFSK::Do(void)
{
	int s = m_Encode.Do();
	if( (s == 128)||(s == 129) ){
		s -= 128;			// s = 0 or 1
		return m_BPF.Do(m_Carrier.Do() * m_AMPCW.Do(s));
    }
	else if( m_fMFSK ){
		return m_BPF.Do(m_Carrier.Do(double(s)*m_MFSK_K)*m_AMPSIG.Do(m_OutVol));
    }
	else if( m_fQPSK ){
		if( !m_Encode.m_Cnt ){
			s = m_Encode.m_outbit;
			m_PrevSym = m_Sym;
			if( s == -1 ){
				s = 0;
            }
            else {
				m_SHDATA = m_SHDATA << 1;
	            if( s > 0 ) m_SHDATA |= 1;

	            s = tQPSK_Viterbi[m_SHDATA & 0x1f];
				if(m_fLSB){
					switch(s){				// 回転方向を逆転
						case 1:
	                    	s = 3;
	                        break;
	                    case 3:
	                    	s = 1;
	                        break;
	                }
	            }
            }
			switch(s){					// 左回転
				case 0:					// 0
					m_Sym.r =  1.0;
					m_Sym.j =  0.0;
					break;
				case 1:					// 270
					m_Sym.r =  0.0;
					m_Sym.j = -1.0;
					break;
				case 2:					// 180
					m_Sym.r = -1.0;
					m_Sym.j =  0.0;
					break;
				case 3:					// 90
					m_Sym.r =  0.0;
					m_Sym.j =  1.0;
					break;
			}
			m_Sym *= m_PrevSym;
		}
		double sh = m_Tbl[MOD_Z2M][m_Encode.m_Cnt];
		double iv = sh * m_PrevSym.r + (1.0 - sh) * m_Sym.r;
		double qv = sh * m_PrevSym.j + (1.0 - sh) * m_Sym.j;

		double d = (m_Carrier.Do() * qv + m_Carrier.DoCos() * iv);
		return m_BPF.Do(d*m_AMPSIG.Do(m_OutVol));
    }
    int cnt = m_Encode.m_Cnt;
	if( !cnt ){
		if( s > 0 ){
			if( m_s > 0 ){					// 1 to 1
               	m_d = 1.0; m_pTbl = NULL;
            }
            else if( m_s < 0 ){            	// -1 to 1
				m_pTbl = m_Tbl[MOD_M2P];
            }
            else {		                	// 0 to 1
				m_pTbl = m_Tbl[MOD_Z2P];
            }
        }
        else if( s < 0 ){
			if( m_s > 0 ){                	// 1 to -1
				m_pTbl = m_Tbl[MOD_P2M];
            }
            else if( m_s < 0 ){            	// -1 to -1
				m_d = -1; m_pTbl = NULL;
            }
            else {		                	// 0 to -1
				m_pTbl = m_Tbl[MOD_Z2M];
            }
        }
        else {		            			// 0
			m_d = 0; m_pTbl = NULL;
        }
        m_s = s;
    }
	if( cnt > MODTABLEMAX ) cnt = MODTABLEMAX - 1;
	if( m_pTbl ){
		m_d = m_pTbl[cnt];
    }
	double d;
	switch(m_Type){
		case MODE_GMSK:			// 周波数変調
        case MODE_FSK:
        case MODE_FSKW:
		case MODE_RTTY:
			d = m_Carrier.Do(m_d);
            break;
        case MODE_BPSK:
        case MODE_N_BPSK:		// 直交変調
			d = -m_d;
   	        d = (m_Carrier.Do() * m_d + m_Carrier.DoCos() * d) * PSK_OUTFAC;
			break;
        case MODE_U_RTTY:
			d = m_Carrier.Do(-m_d);
            break;
        default:
        	d = 0.0;
            break;
    }
	return m_BPF.Do(d*m_AMPSIG.Do(m_OutVol));
}

double __fastcall CMODFSK::DoCarrier(void)
{
	return m_BPF.Do(m_Carrier.Do()*m_AMPSIG.Do(m_OutVol));
}

//--------------------------------------------------------
__fastcall CDECFSK::CDECFSK()
{
	m_Tmg = 0;
    m_cMode = 0;
    m_SampleFreq = SAMPFREQ;
//	m_SampleFreq = 11100;
    m_Speed = SPEED;
    m_Lock = 0;
    m_dAdj = 0;
	m_dTmg3 = 0;
	m_dTmg2 = 0;
	m_dTmg = 0;
    m_fATC = TRUE;
    Create();
    m_T = 0;
    m_T2 = 0;
    m_T3 = 0;
	m_cBWave = 15;
    m_ATCSpeed = 0;
    m_ATCLimit = 25000;

    m_ATCCounter = 0;
    m_Type = MODE_GMSK;
    m_AvgRTTY.Create(48);
}

#define	INI_T2	64
#define	LPFA	20
#define	LPFB	16
void __fastcall CDECFSK::Create(void)
{
	m_dBTW = m_dTW = m_SampleFreq / m_Speed;
	SetATCLimit(m_ATCLimit);
	SetTmg(m_dAdj);
    m_LPF.Create(LPFA*m_SampleFreq/11025);
    m_LPFI.Create(LPFB*m_SampleFreq/11025);
    m_cMode = 0;
	for( int i = 0; i < 16; i++ ){
    	m_LPF.Do(0);
    	m_LPFI.Do(0);
    }
    m_GainA = 60.0 / m_Speed;
	SetATCSpeed(m_ATCSpeed);
	m_dNow = 0;
    m_dNext = m_dTW;
    m_dFree = m_dTW;
    m_T = 0;
    m_T2 = INI_T2;
    m_T3 = 0;
    m_Threshold = 128.0;
    m_A = 0;
    if( m_Speed >= 70.0 ) m_Threshold *= 0.7;
    m_a = 0;

    m_ATCCounter = 0;
    m_ATCLimitH = 32 * m_SampleFreq / m_Speed;
    m_ATCLimitL = 0.5 * m_SampleFreq / m_Speed;
}

void __fastcall CDECFSK::SetATCSpeed(int atcspeed)
{
	m_ATCSpeed = atcspeed;
//    m_GainB = 0.002 * 60.0 / m_Speed;
    m_GainB = 0.002 * 60.0 / 31.25;
	if( m_ATCSpeed ){
		m_GainB *= ((m_ATCSpeed * 0.5) + 1.0);
    }
}

void __fastcall CDECFSK::SetATCLimit(int atclimit)
{
	m_ATCLimit = atclimit;
	double d = double(atclimit) * 1.0e-6;
    m_dBTWL = m_dBTW * (1.0-d);
    m_dBTWH = m_dBTW * (1.0+d);
}

void __fastcall CDECFSK::ClearLPF(void)
{
	for( int i = 0; i < 16; i++ ){
    	m_LPF.Do(0);
    	m_LPFI.Do(0);
    }
}

void __fastcall CDECFSK::Reset(void)
{
	m_dTW = m_SampleFreq / m_Speed;
    m_dTWH = m_dTW * 0.5;
	m_dNow = 0;
    m_dNext = m_dTW;
    m_dFree = m_dTW;
    m_T = 0;
    ClearLPF();
    m_T2 = INI_T2;
    m_T3 = 0;

	m_dTmg3 = 0;
	m_dTmg2 = 0;
	m_dTmg = 0;

    m_ATCCounter = 0;
    m_ATCLimitH = 32 * m_SampleFreq / m_Speed;
    m_ATCLimitL = 0.5 * m_SampleFreq / m_Speed;

	m_fSync = FALSE;
    m_BAUDOT.ClearRX();

	m_fMeasClock = FALSE;
	m_MeasError = m_MeasClock = m_MeasCounter = 0;
    m_Meas1st = TRUE;
    m_AvgRTTY.Reset();
}

void __fastcall CDECFSK::SetTmg(int ppm)
{
	if( (ppm < -50000) || (ppm > 50000) ) return;

	m_dAdj = ppm;
	m_dTW = m_SampleFreq / m_Speed;
	m_dTW += m_dTW * m_dAdj * 1.0e-6;
//    m_dBTW = m_dTW;
    m_dTWH = m_dTW * 0.5;
    m_T2 = INI_T2;
}

void __fastcall CDECFSK::SetMeasClock(BOOL f)
{
	if( IsRTTY(m_Type) ) return;

	m_fMeasClock = f;
	if( !f ) m_MeasClock = m_MeasCounter = 0;
}

BOOL __fastcall CDECFSK::GetSyncState(void)
{
	if( IsRTTY(m_Type) ){
		return m_fSync;
    }
	else if( m_T && (m_T3 > 16) ){
		return (fabs(m_dTmg) >= (0.2*60.0/m_Speed)) ? FALSE : TRUE;
    }
    else {
		return FALSE;
    }
}

BOOL __fastcall CDECFSK::Do(double d, BOOL sq, BOOL fATC)
{
	BOOL r = FALSE;
    int s = m_s;
	if( ABS(d) > m_Threshold ){
		s = (d > 0) ? 1 : 0;
    }
	if( IsRTTY(m_Type) ){
		return DoBAUDOT(s, sq);
    }
	int u;
	m_ATCCounter++;
	m_dNow += 1.0;
	if( m_dNow >= m_dFree ) m_dFree += m_dTW;
	if( s != m_s ){
		m_s = s;
		if( (m_ATCCounter >= m_ATCLimitL) && (m_ATCCounter < m_ATCLimitH) ){
			BOOL f1st = sq && !m_T;
			d = m_dFree - m_dNow;
	        if( d >= m_dTWH ) d -= m_dTW;
    	    d /= m_dBTW;
        	if( (m_dTmg >= 0.3) && (d < -0.1) ) d += 1.0;
	        if( (m_dTmg < -0.3) && (d > 0.1) ) d -= 1.0;
			if( !sq ) d *= 0.1;
			if( sq && !m_T ){				// 最初の1回目
				m_dFree -= d * m_dBTW;
    	    }
   			d = m_LPF.Do(d * m_GainA);
	        m_dTmg3 = d - m_A;
    	    m_A = d;
        	m_dTmg = d;
			if( m_T ){
				if( m_T3 < 256 ){
					d *= 2.0;
            	}
	            else if( !fATC ){
					d *= 0.5;
        	    }
//			if( !fATC ) d *= (m_T3 > 256) ? 0.25 : 2.0;
				m_dFree -= d;
    	    }

			if( sq ){
				m_T = m_Speed;
				m_T3++;
	        }
    	    else if( !m_T ){
				d = (m_dTW - m_dBTW) * 20.0;
		    	m_T2 = INI_T2;
	            m_T3 = 0;
                m_MeasClock = m_MeasCounter = 0;
    	   	}
       		else {
				m_T--;
                m_MeasClock = m_MeasCounter = 0;
	       	}
    	    d = m_LPFI.Do(d);
			if( (!m_T2 && fATC) || !m_T  ){
				if( m_fATC ){
			   	    m_dTW -= d * m_GainB;
					if( m_dTW < m_dBTWL ){ m_dTW = m_dBTWL; }
        	        if( m_dTW > m_dBTWH ){ m_dTW = m_dBTWH; }
				   	m_dTWH = m_dTW * 0.5;
	            }
    	    }
        	else if( m_T2 ){
				m_T2--;
    	    }
            m_dTmg2 = ((m_dTW / m_dBTW) - 1.0) * 1e6;
            if( GetSyncState() ){
				m_dNext = m_dFree - m_dTW*0.5;
				if( m_dNext > (m_dNow + m_dTW) ){
					m_dNext -= m_dTW;
	        	}
	    	    if( m_dNext < m_dNow ) m_dNext += m_dTW;
            }
			else if( f1st ){
				m_dNext = m_dNow + m_dTWH;
                m_MeasClock = m_MeasCounter = 0;
            }
            else {
                d = m_dNext - m_dNow;
                m_dNext = m_dNow + (d + m_dTWH) * 0.5;
//                m_dNext = m_dNow + (d * 0.25 + m_dTWH * 0.75);
			}
		}
        m_ATCCounter = 0;
    }
	if( m_MeasClock ) m_MeasCounter++;
    switch(m_cMode){
		case 0:
			if( m_dNext <= m_dNow ){
				m_MeasClock++;
				if( m_MeasClock >= 256 ){
					if( sq && fATC && !GetSyncState() && m_fMeasClock ){
						d = double(m_MeasCounter) / double(m_MeasClock-1);
                        m_dTW += (d - m_dTW) * 0.5;
						if( m_dTW < m_dBTWL ){ m_dTW = m_dBTWL; }
    	    	        if( m_dTW > m_dBTWH ){ m_dTW = m_dBTWH; }
					   	m_dTWH = m_dTW * 0.5;
                    }
	                m_MeasClock = 1;
                    m_MeasCounter = 0;
                }
				m_Tmg = !m_Tmg;
				m_dNext += m_dTW;
				u = (s != m_a) ? 0 : 1;
                m_a = s;
                m_cData = m_cData << 1;
				if( u && sq ){
					if( !m_Lock ) m_Tmg = 1;
                	m_cData = 1;
					m_cBCount = 1;
                    m_cMode++;
                    m_Lock = TRUE;
                }
                else {
					if( !m_cBCount ){
						m_Lock = TRUE;
                    }
                    else if( m_cBCount >= m_cBWave ){
						m_cBCount = -1;
						m_Lock = FALSE;
                    }
                    m_cBCount++;
                }
			}
        	break;
		case 1:
			if( m_dNext <= m_dNow ){
				m_MeasClock++;
				m_Tmg = !m_Tmg;
				m_dNext += m_dTW;
				u = (s != m_a) ? 0 : 1;
                m_a = s;
                m_cData = m_cData << 1;
				m_cBCount++;
				if( u ){
                	m_cData |= 1;
                }
                else if( m_cBCount >= 3){
					if( !(m_cData & 3) ){
                        m_Data = g_VariCode.Decode(m_cData >> 2);
   	                    r = TRUE;
                        m_cMode--;
	                    m_Lock = FALSE;
                    }
                }
			}
        	break;
        default:
        	m_cMode = 0;
            break;
    }
	if( m_dNow >= 1000.0 ){
		m_dNow -= 1000.0;
        m_dNext -= 1000.0;
        m_dFree -= 1000.0;
    }
	return r;
}

//---------------------------------------------------------------------------
BOOL __fastcall CDECFSK::DoBAUDOT(int s, BOOL sq)
{
	if( s != m_s ){
		m_s = s;
        if( sq ){
			if( !m_cMode && !s ){
				if( m_MeasClock ){
					int tw = m_MeasCounter - m_MeasClock;
                    int stw = m_SampleFreq * 6.5 / m_Speed;
					if( tw < stw ){
						m_MeasError++;
						if( m_MeasError >= 3 ){
							m_MeasError = m_MeasCounter = m_MeasClock = 0;
       	                    m_AvgRTTY.Reset();
   	        	        }
                    }
					else if( m_AvgRTTY.IsHalf() ){
						int atw = m_AvgRTTY.GetAvg();
       	        	    if( ABS(atw-tw) >= (m_dTW*0.2) ){
							m_MeasError++;
							if( m_MeasError >= 3 ){
								m_MeasError = m_MeasCounter = m_MeasClock = 0;
        	                    m_AvgRTTY.Reset();
       	        	        }
           		        }
	               	    else {
							m_AvgRTTY.Do(tw);
	   	                    m_MeasError = 0;
        	            }
       	    	    }
           	    	else {
						m_AvgRTTY.Do(tw);
                    }
                }
				if( m_Meas1st ){
                	m_AvgRTTY.Reset();
                }
                else {
		            m_MeasClock = m_MeasCounter = 1;
                }
            }
        }
        else {
			m_MeasError = m_MeasCounter = m_MeasClock = 0;
		    m_Meas1st = TRUE;
        }
    }
	BOOL r = FALSE;
	m_MeasCounter++;
	m_dNow += 1.0;
	switch(m_cMode){
        case 0:				// Start bits?
			if( !s && sq ){
                m_Lock = TRUE;
				m_Tmg = 0;
				m_dNext = m_dNow + m_dTW*0.5;
                m_cData = 0;
                m_cBCount = 0;
                m_cMode++;
            }
        	break;
		case 1:
			if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
				m_Tmg = !m_Tmg;
                m_cMode++;
			}
            break;
        case 2:
			if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
				m_Tmg = !m_Tmg;
				m_cData = m_cData << 1;
                if( s ) m_cData |= 0x01;
                m_cBCount++;
                if( m_cBCount >= 5 ){
					m_cMode++;
                }
			}
            break;
        case 3:							// Stop bits
        	if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
				m_Tmg = !m_Tmg;
                m_fSync = s;
				if( s ){
					m_Meas1st = FALSE;
					r = TRUE;
					m_cMode = 0;
                    m_Data = m_BAUDOT.ConvAscii(m_cData);
                }
                else {					// フレーミングエラー
					m_cMode++;
					m_MeasClock = 0;
                    m_Data = m_BAUDOT.ConvAscii(m_cData);	// added by JE3HHT on Sep.2010
                }
                m_Lock = FALSE;
            }
            break;
        case 4:
        	if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
            }
			if( s ){
				m_cMode = 0;
            }
            break;
        default:
			m_cMode = 0;
        	break;
    }
	if( m_dNow >= 1000.0 ){
		m_dNow -= 1000.0;
        m_dNext -= 1000.0;
    }
    return r;
}
//--------------------------------------------------------------------------
void __fastcall DoAvg(float &av, float in, float factor)
{
	av = av * (1.0 - factor) + (in * factor);
}
//--------------------------------------------------------------------------
void __fastcall DoAvg(double &av, double in, double factor)
{
	av = av * (1.0 - factor) + (in * factor);
}
//---------------------------------------------------------------------------
__fastcall CFAVG::CFAVG()
{
	Create(16);
}
//---------------------------------------------------------------------------
void __fastcall CFAVG::Reset(void)
{
	m_Cnt = 0;
    m_Sum = 0;
    m_Avg = 0;
}
//---------------------------------------------------------------------------
void __fastcall CFAVG::Reset(double d)
{
	m_Cnt = m_Max;
    m_Sum = d * m_Max;
    m_Avg = d;
}
//---------------------------------------------------------------------------
void __fastcall CFAVG::Create(int max)
{
	m_Max = max;
    m_Mul = 1.0 / m_Max;
    Reset();
}
//---------------------------------------------------------------------------
double __fastcall CFAVG::DoZ(double d)
{
	m_Sum += d;
    if( m_Cnt < m_Max ){
		m_Cnt++;
    }
    else {
		m_Sum -= m_Avg;
    }
    m_Avg = m_Sum * m_Mul;
    return m_Avg;
}
//---------------------------------------------------------------------------
double __fastcall CFAVG::Do(double d)
{
	m_Sum += d;
    if( m_Cnt < m_Max ){
		m_Cnt++;
	    m_Avg = m_Sum / m_Cnt;
    }
    else {
		m_Sum -= m_Avg;
	    m_Avg = m_Sum * m_Mul;
    }
    return m_Avg;
}
//---------------------------------------------------------------------------
__fastcall CAVG::CAVG()
{
	m_Max = 0;
    m_pZ = NULL;
    m_Sum = 0.0;
    m_Avg = 0;
    m_Cnt = m_W = 0;
}

__fastcall CAVG::~CAVG()
{
	if( m_pZ ) delete m_pZ;
}

void __fastcall CAVG::Create(int max)
{
	if( max == m_Max ) return;

	m_Max = max;
	if( m_pZ ) delete m_pZ;
    m_pZ = new double[max];
    Reset();
}

void __fastcall CAVG::Reset(void)
{
	m_Cnt = m_W = 0;
    m_Sum = 0.0;
    m_Avg = 0.0;
}

void __fastcall CAVG::Reset(double d)
{
	if( !m_pZ ) return;

    double *dp = m_pZ;
    for( int i = 0; i < m_Max; i++ ){
		*dp++ = d;
    }
	m_Avg = d;
    m_Sum = d * m_Max;
    m_W = 0;
    m_Cnt = m_Max;
}

double __fastcall CAVG::Do(double d)
{
	if( !m_Max ) return d;

	double *dp = &m_pZ[m_W];
	if( m_Cnt >= m_Max ){
		m_Sum -= *dp;
    }
    else {
		m_Cnt++;
    }
    m_W++;
	if( m_W >= m_Max ) m_W = 0;
    *dp = d;
    m_Sum += d;
    m_Avg = m_Sum / m_Cnt;
    return m_Avg;
}

//--------------------------------------------------------
__fastcall CENCODE::CENCODE()
{
	m_MFSK_TYPE = typMFSK16;
	m_MFSK_TONES = 16;
	m_MFSK_SPEED = 15.625;
	m_MFSK_BITS = 4;
    m_MFSK_MASK = m_MFSK_TONES - 1;

    m_pFunc = NULL;
	m_Speed = SPEED;
    m_SampleFreq = SAMPFREQ;
    m_Code = 0;
    Create();
    m_RP = m_WP = m_CC = 0;
    m_Idle = FALSE;
    m_pVCO = NULL;
    m_fJA = TRUE;
    m_fTWO = FALSE;
    m_fCW = FALSE;
    m_Type = MODE_GMSK;
    m_BAUDOT.Reset();
    m_rttyDiddle = diddleLTR;
    m_rttyCWait = m_rttyDWait = 0;
    m_Mark = FALSE;

	m_Viterbi.Init(MFSK_VITERBI_K, MFSK_VITERBI_POLY1, MFSK_VITERBI_POLY2);
	m_MFSK_SHDATA = 0;
	m_MFSK_SHCount = 0;
}
//--------------------------------------------------------
void __fastcall CENCODE::SetMFSKType(int type)
{
	m_MFSK_TYPE = type;
	MFSK_SetPara(type, &m_MFSK_TONES, &m_MFSK_SPEED, &m_MFSK_BITS);
    m_MFSK_MASK = m_MFSK_TONES - 1;
    Create();
}
//--------------------------------------------------------
void __fastcall CENCODE::Create(void)
{
	m_Mode = 0;
	m_dCW = m_SampleFreq / 20.0;
	if( IsMFSK(m_Type) ){
	    m_dTW = m_SampleFreq / m_MFSK_SPEED;
    }
    else {
	    m_dTW = m_SampleFreq / m_Speed;
    }
    m_out = 0;
    m_sync = 0;
    m_Idle = FALSE;
    m_fCW = FALSE;
    memset(m_Z, 0, sizeof(m_Z));
}
void __fastcall CENCODE::SetTmg(double d)
{
	if( IsMFSK(m_Type) ){
		m_dTW = m_SampleFreq / m_MFSK_SPEED;
    }
    else {
		m_dTW = m_SampleFreq / m_Speed;
    }
	m_dTW += m_dTW * d / 1e6;
}
void __fastcall CENCODE::Reset(BOOL fCW)
{
	m_fCW = fCW;
	m_Code = 0;
    m_Mode = 0;
    m_RP = m_WP = m_CC = 0;
    m_Idle = FALSE;
    m_Mark = FALSE;
}
void __fastcall CENCODE::SetCW(int f)
{
	m_dCW = m_SampleFreq / f;
}
//--------------------------------------------------------
static int __fastcall GetCWCode(int &count, int code)
{
	const USHORT _tbl[]={
		// 0       1       2       3        4       5       6       7
		0x0005, 0x8005, 0xc005, 0xe005, 0xf005, 0xf805, 0x7805, 0x3805, // 0-7
		// 8       9       :        ;       <       =       >       ?
		0x1805, 0x0805, 0xe806, 0xA805, 0x0000, 0x7005, 0x0000, 0xcc06, // 8
		// @        A       B       C       D       E       F       G
		0xb805, 0x8002, 0x7004, 0x5004, 0x6003, 0x8001, 0xd004, 0x2003, // @-G
		// H        I       J       K       L       M       N       O
		0xf004, 0xc002, 0x8004, 0x4003, 0xb004, 0x0002, 0x4002, 0x0003, // H-O
		// P        Q       R       S       T       U       V       W
		0x9004, 0x2004, 0xa003, 0xe003, 0x0001, 0xc003, 0xe004, 0x8003, // P-W
		// X        Y       Z       [	    \	    ]
		0x6004, 0x4004, 0x3004, 0x0000, 0x0000, 0x4805, 0x0000, 0x0000, // X-Z
	};
	if( code == '/' ){
		code = 0x6805;
        count = 5;
	}
	else if( (code >= 0x30) && (code <= 0x7f) ){
		if( code >= 0x60 ) code -= 0x20;
        code -= 0x30;
        code = _tbl[code];
		count = code & 0x000f;
    }
    else {
		code = 0;
        count = 0;
    }
    return code;
}
//--------------------------------------------------------------------------
void __fastcall CENCODE::MFSKSendBit(BOOL bit)
{
	MFSKSendPair(m_Viterbi.Do(bit));
}
//--------------------------------------------------------------------------
void __fastcall CENCODE::MFSKSendPair(BYTE pair)
{
	MFSKSendSymBit(pair & 2);
	MFSKSendSymBit(pair & 1);
}
//--------------------------------------------------------------------------
//
void __fastcall CENCODE::MFSKSendSymBit(BOOL bit)
{
	const BYTE _tGray2Bin[]={	//Encode
		0x00,0x01,0x03,0x02,0x07,0x06,0x04,0x05,
		0x0F,0x0E,0x0C,0x0D,0x08,0x09,0x0B,0x0A,
		0x1F,0x1E,0x1C,0x1D,0x18,0x19,0x1B,0x1A,
		0x10,0x11,0x13,0x12,0x17,0x16,0x14,0x15,
	};

	m_MFSK_SHDATA = m_MFSK_SHDATA << 1;
    if( bit ) m_MFSK_SHDATA |= 1;

	m_MFSK_SHCount++;
	if( m_MFSK_SHCount >= m_MFSK_BITS ){
		m_Fifo.PutData(_tGray2Bin[m_InterLeaver.EncodeBits(m_MFSK_SHDATA) & m_MFSK_MASK]);
		m_MFSK_SHDATA = 0;
        m_MFSK_SHCount = 0;
	}
}
//--------------------------------------------------------------------------
void __fastcall CENCODE::MFSKSendChar(int c)
{
	int code = g_VariCode.EncodeMFSK(BYTE(c));
    int n = (code & 0x0f000) >> 12;
    for( n--; n >= 0; n-- ){
		MFSKSendBit(_tBitData[n] & code);
    }
}
//--------------------------------------------------------------------------
void __fastcall CENCODE::MFSKSendIdle(void)
{
	MFSKSendIdle(m_MFSK_TONES);
}
//--------------------------------------------------------------------------
void __fastcall CENCODE::MFSKSendIdle(int n)
{
	for(int i = 0; i < n; i++){
		MFSKSendBit(0);
	}
}
//--------------------------------------------------------------------------
void __fastcall CENCODE::MFSKSendIdleChar(void)
{
	MFSKSendChar(0);
    MFSKSendIdle();
	m_fChar = FALSE;
}
//--------------------------------------------------------------------------
int __fastcall MFSK_GetIdleCount(int type)
{
	switch(type){
		case typMFSK4:
			return (rand() % 2) + 2;
		case typMFSK8:
			return (rand() % 2) + 3;
		case typMFSK31:
		case typMFSK32:
			return (rand() % 4) + 16;
		case typMFSK64:
			return (rand() % 8) + 24;
		default:
			return (rand() % 4) + 8;
	}
}
//--------------------------------------------------------
int __fastcall CENCODE::Do(void)
{
	m_Cnt++;
	m_dNow += 1.0;
	switch(m_Mode){
		case 0:				// エンコードの開始
			m_fReqRX = FALSE;
			m_fChar = FALSE;
		    if( m_pVCO ) m_pVCO->InitPhase();
			if( IsMFSK(m_Type) ){
				m_Fifo.Clear();
                m_InterLeaver.Init(m_MFSK_BITS);
				m_Viterbi.Reset();
				m_MFSK_SHDATA = 0;
				m_MFSK_SHCount = 0;
            }

			if( m_fCW ){
				m_out = 128;
				m_Mode = IsMFSK(m_Type) ? 130 : 2;
            }
			else if( IsRTTY(m_Type) ){
			    m_Mark = FALSE;
			    m_BAUDOT.Reset();
				m_out = -1;
   	    	    m_Mode = 64;
            }
			else if( IsMFSK(m_Type) ){
				m_out = 0;
                m_Mode = 128;
            }
            else {
				m_out = IsPSK(m_Type) ? 1 : 0;
     	        m_Mode++;
            }
			m_outbit = m_out;
   	        m_Cnt = 0;
			m_dNext = m_dTW * 2;
       	    m_dNow = 0.0;
   	        m_cBCount = 0;
   	        m_Idle = FALSE;
            break;
        case 1:
            if( m_dNext <= m_dNow ){
				m_outbit = 0;
				m_out = (m_out >= 0) ? -1 : 1;
				m_dNext += m_dTW;
                m_cBCount++;
				if( IsQPSK(m_Type) ){
	                if( m_cBCount >= (1.0 * m_Speed) ){
						m_cBCount = 0;
		                m_Mode++;
	                }
                }
                else {
	                if( m_cBCount >= (0.64 * m_Speed) ){
						m_cBCount = 0;
		                m_Mode++;
	                }
                }
                m_Cnt = 0;
            }
            break;
        case 2:
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
				if( !m_cBCount ){
					if( m_CC ){
						m_cData = GetChar();
                    }
                	else if( m_pFunc ){
						m_cData = m_pFunc();
                    }
                    else {
						m_cData = GetChar();
                    }
					if( (m_cData >= 0x100) && (m_cData < 0x0200) ){
                        m_Idle = FALSE;
						m_cData -= 0x0100;
                        m_cData = GetCWCode(m_cBCount, m_cData);
						m_dNext -= m_dTW;
                        m_dNext += m_fCW ? m_dCW : m_dCW*3;
						m_out = 128;
                        m_Mode = 16;
                        m_fCW = TRUE;
                        break;
                    }
                    else if( m_cData == 0x200 ){	// Idle
						m_fCW = FALSE;
                        m_Idle = FALSE;
						m_cData = 0;
                        m_cBCount = 20;
                    }
                    else if( m_cData >= 0 ){
						m_fCW = FALSE;
                        m_Idle = FALSE;
						if( m_fTWO && (m_cData >= 0x8140) && (m_cData <= 0xfeff) ){
							int c1 = (m_cData >> 8) & 0x00ff;
                            int c2 = m_cData & 0x00ff;
							c1 = g_VariCode.Mbcs2Index(c1, FALSE);
							c2 = g_VariCode.Mbcs2Index(c2, FALSE);
                            int b1, b2;
							int d1 = g_VariCode.Encode(b1, c1) << 2;
							int d2 = g_VariCode.Encode(b2, c2) << 2;
							m_cData = (d1 << (b2+2)) | d2;
                            m_cBCount = b1 + b2 + 4;
                        }
                        else {
							m_cData = g_VariCode.Mbcs2Index(m_cData, m_fTWO ? FALSE : m_fJA);
	                        if( m_cData >= 0 ){
								m_cData = g_VariCode.Encode(m_cBCount, m_cData) << 2;
								m_cBCount += 2;
            	            }
                	        else {
								m_cData = 0;
    	                	    m_cBCount = 1;
                        	}
                        }
                    }
					else if( m_fCW ){
						m_out = 128;
                        m_Idle = TRUE;
                        break;
                    }
					else if( (m_Mark || m_fReqRX) && sys.m_fSendSingleTone && IsPSK(m_Type) ){
			            m_outbit = -1;
						m_cBCount = 32;
						m_Idle = FALSE;
						m_Mode++;
						m_Cnt = 0;
                        break;
					}
                    else {
						m_Idle = TRUE;
						m_cData = 0;
                        m_cBCount = 1;
                    }
                }
                m_cBCount--;
				m_outbit = (m_cData & _tBitData[m_cBCount]);
				if( !(m_cData & _tBitData[m_cBCount]) ){
					m_out = (m_out > 0) ? -1 : 1;
                }
                m_Cnt = 0;
            }
            break;
        case 3:							// output single tone for the ending transmission
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
				m_cBCount--;
                if( m_cBCount <= 0 ){
					m_Idle = TRUE;
					m_cData = 0;
                    m_cBCount = 1;
                }
	            m_outbit = -1;
				m_Cnt = 0;
			}
        	break;
		// CW output
        case 16:
            if( m_dNext <= m_dNow ){
				if( m_cBCount ){
	                m_dNext += m_cData & 0x8000 ? m_dCW : m_dCW*3;
    	            m_out = 129;
        	        m_Mode++;
                }
                else {
					m_out = 128;
                    m_dNext += m_dCW*6;
                    m_Mode = IsMFSK(m_Type) ? 130 : 2;
                }
			}
            break;
        case 17:			// スペース
        	if( m_dNext <= m_dNow ){
				m_dNext += m_dCW;
                m_out = 128;
                m_cData = m_cData << 1;
                m_cBCount--;
				if( !m_cBCount ){
					m_dNext += m_dCW;
					m_Mode = IsMFSK(m_Type) ? 130 : 2;
                }
                else {
					m_Mode--;
                }
            }
            break;
        case 64:						// BAUDOT
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
                m_cBCount++;
                if( m_cBCount >= (0.25 * m_Speed) ){
					m_cBCount = 0;
	                m_Mode++;
                }
                m_Cnt = 0;
            }
            break;
        case 65:						// BAUDOT
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW*0.5;
				if( !m_cBCount ){
					if( m_CC ){
						m_cData = GetChar();
                    }
                	else if( m_pFunc ){
						m_cData = m_pFunc();
                    }
                    else {
						m_cData = GetChar();
                    }
					if( (m_cData >= 0x100) && (m_cData < 0x0200) ){
                        m_Idle = FALSE;
						m_cData -= 0x0100;
                        m_cData = GetCWCode(m_cBCount, m_cData);
						m_dNext -= m_dTW*0.5;
                        m_dNext += m_fCW ? m_dCW : m_dCW*3;
						m_out = 128;
                        m_Mode = 16;
                        m_fCW = TRUE;
                        break;
                    }
                    else if( m_cData == 0x200 ){	// Idle
						m_BAUDOT.Reset();
						m_fCW = FALSE;
						m_Idle = FALSE;
                        if( m_fChar ){
	                        m_cData = (m_rttyDiddle == diddleLTR) ? 0x7ffc : 0x7000;
                        }
                        else {
	                        m_cData = 0xffff;
                        }
                        m_cBCount = 15;
                    }
                    else if( m_cData >= 0 ){
						m_fChar = TRUE;
						m_fCW = FALSE;
                        m_Idle = FALSE;
						m_cData = m_BAUDOT.GetCode(m_cBCount, m_cData);
                        if( m_cData < 0 ){
	                        m_cData = 0x7000;	// BLK
                            m_cBCount = 15;
                        }
                    }
					else if( m_fCW ){
						m_BAUDOT.Reset();
						m_out = 128;
                        m_Idle = TRUE;
                        break;
                    }
					else if( m_Mark || m_fReqRX ){
						m_fChar = FALSE;
						m_out = -1;
                        m_Idle = TRUE;
                        break;
                    }
                    else {						// Diddle
						m_BAUDOT.Reset();
						m_Idle = TRUE;
                        m_cData = (m_rttyDiddle == diddleLTR) ? 0x7ffc : 0x7000;
                        m_cBCount = 15;
                    }
                }
                m_cBCount--;
				if( !(m_cData & 0x0001) ){
					m_out = 1;
                }
                else {
					m_out = -1;
                }
                m_cData = m_cData >> 1;
				m_Cnt = 0;
				if( !m_cBCount || (m_cBCount == 15) ){
					if( m_Idle ){
						if( m_rttyDWait ) m_Mode++;
                    }
                    else {
						if( m_rttyCWait ) m_Mode++;
                    }
                }
            }
            break;
        case 66:						// BAUDOT-wait
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW * 0.1 * (m_Idle ? m_rttyDWait : m_rttyCWait);
                m_Mode = 65;
			}
            m_Cnt = 0;
			break;

		// MFSK
		case 128:
			switch(m_MFSK_TYPE){
				case typMFSK4:
					m_cBCount = 8;
                    break;
				case typMFSK31:
                case typMFSK32:
					m_cBCount = 32;
					break;
                case typMFSK64:
					m_cBCount = 64;
					break;
				case typMFSK22:
                	m_cBCount = 22;
                    break;
                default:
					m_cBCount = 16;
                	break;
            }
            m_dNext = m_dNow + m_dTW;
            m_Mode++;
        case 129:
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
            	m_cBCount--;
                if( !m_cBCount ){
					if( (m_MFSK_TONES == 8)||(m_MFSK_TONES == 32) ){	// ２ビタビのメトリックス初期化のため
						MFSKSendChar(0);
						MFSKSendChar(0);
                    }
					m_Mode++;
                }
            }
        	break;
        case 130:
        case 131:
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
                if( !m_Fifo.GetCount() ){
_try:;
					if( m_CC ){
						m_cData = GetChar();
                    }
                	else if( m_pFunc ){
						m_cData = m_pFunc();
                    }
                    else {
						m_cData = GetChar();
                    }
					if( (m_cData >= 0x100) && (m_cData < 0x0200) ){
                        m_Idle = FALSE;
						m_cData -= 0x0100;
                        m_cData = GetCWCode(m_cBCount, m_cData);
						if( m_fCW ){
							m_dNext -= m_dTW;
	                        m_dNext += m_fCW ? m_dCW : m_dCW*3;
							m_out = 128;
        	                m_Mode = 16;
            	            m_fCW = TRUE;
                        }
                        else {
	                        MFSKSendIdleChar();
    	                    MFSKSendIdleChar();
    	                    MFSKSendIdleChar();
							m_Mode = 132;
							if( m_Fifo.GetCount() ) m_out = m_Fifo.GetData();
                        }
                        break;
                    }
                    else if( m_cData == 0x200 ){	// Idle
                        m_Mode = 130;
						m_fCW = FALSE;
                        m_Idle = FALSE;
//                        MFSKSendIdleChar();
						if( m_fChar ){
	                        MFSKSendIdleChar();
                        }
                        else {
	                        MFSKSendIdle();
                        }
                        MFSKSendIdle();
                    }
                    else if( m_cData >= 0 ){
						m_fChar = TRUE;
                        m_Mode = 130;
						m_fCW = FALSE;
                        m_Idle = FALSE;
						if( m_fTWO && (m_cData >= 0x8140) && (m_cData <= 0xfeff) ){
                            MFSKSendChar((m_cData >> 8) & 0x00ff);
                            MFSKSendChar(m_cData & 0x00ff);
                        }
                        else {
                            MFSKSendChar(m_cData & 0x00ff);
                        }
                    }
					else if( m_fCW ){
						m_out = 128;
                        m_Idle = TRUE;
                        break;
                    }
					else if( m_Mode == 130 ){
						m_Idle = FALSE;
						MFSKSendIdleChar();
                        m_cBCount = 3;
                        m_Mode++;
                    }
					else if( m_Idle ){
						m_cBCount--;
                        if( m_cBCount <= 0 ){
							m_cBCount = MFSK_GetIdleCount(m_MFSK_TYPE);
	                      	MFSKSendIdleChar();
                        }
                        else {
							MFSKSendIdle();
                        }
                    }
                    else if( m_fReqRX ){
						if( m_MFSK_TONES == 32 ){
							MFSKSendIdle(26);
                        }
						else if( m_MFSK_TONES == 16 ){
							MFSKSendIdle(32);
                        }
                        else {
							MFSKSendIdle(20);
                        }
						m_cBCount--;
                        if( m_cBCount <= 0 ){
							m_Idle = TRUE;
							m_cBCount = MFSK_GetIdleCount(m_MFSK_TYPE);
                        }
                    }
                    else {
						m_cBCount--;
                        if( m_cBCount <= 0 ){
							m_Idle = TRUE;
							m_cBCount = MFSK_GetIdleCount(m_MFSK_TYPE);
							if( m_MFSK_TONES == 32 ){
								MFSKSendIdleChar();
                            }
                            else {
								MFSKSendIdle();
                            }
                        }
                        else {
							MFSKSendIdle();
                        }
                    }
                }
				if( m_Fifo.GetCount() ){
					m_out = m_Fifo.GetData();
                }
                else {
					goto _try;
                }
            }
            break;
        case 132:
            if( m_dNext <= m_dNow ){
				m_dNext += m_dTW;
				if( m_Fifo.GetCount() ){
					m_out = m_Fifo.GetData();
                }
                else {
                    m_dNext += m_fCW ? m_dCW : m_dCW*3;
					m_out = 128;
                    m_Mode = 16;
                    m_fCW = TRUE;
                }
            }
        	break;
    }
	if( m_dNow >= 8192.0 ){
		m_dNow -= 8192.0;
        m_dNext -= 8192.0;
    }
    return m_out;
}

//--------------------------------------------------------
BOOL __fastcall CENCODE::IsBuffFull(void)
{
	return m_CC >= AN(m_Buff);
}

//--------------------------------------------------------
void __fastcall CENCODE::PutChar(int c)
{
	if( !IsBuffFull() ){
		m_Buff[m_WP] = c;
    	m_WP++;
    	if( m_WP >= AN(m_Buff) ){
			m_WP = 0;
    	}
	    m_CC++;
    }
}

//--------------------------------------------------------
int __fastcall CENCODE::GetChar(void)
{
	if( !m_CC ) return -1;
	int c = m_Buff[m_RP];
    m_RP++;
    if( m_RP >= AN(m_Buff) ){
		m_RP = 0;
    }
    m_CC--;
    return c;
}

//--------------------------------------------------------
__fastcall CCOLLECT::CCOLLECT()
{
	m_Max = 0;
    m_Cnt = 0;
    m_pZ = NULL;
}

__fastcall CCOLLECT::~CCOLLECT()
{
	if( m_pZ ) delete m_pZ;
}

void __fastcall CCOLLECT::Create(int max)
{
	if( m_Max == max ) return;

    m_Max = max;
    m_Cnt = 0;
	if( m_pZ ) delete m_pZ;
    m_pZ = new double[m_Max];
    memset(m_pZ, 0, sizeof(m_pZ));
}

void __fastcall CCOLLECT::Do(double d)
{
	if( m_Cnt >= m_Max ) return;

    m_pZ[m_Cnt] = d;
    m_Cnt++;
}


//---------------------------------------------------------------------------
const BYTE _tMbcs2Index[]={			// PSK31 index converter
	0x58,0x62,0x66,0x76,0x65,0x71,0x67,0x6B,	/*00*/
	0x6C,0x30,0x0A,0x74,0x63,0x0B,0x75,0x7A,	/*08*/
	0x69,0x68,0x7B,0x7C,0x6F,0x72,0x73,0x6E,	/*10*/
	0x77,0x78,0x7E,0x6D,0x70,0x7F,0x6A,0x79,	/*18*/
	0x00,0x57,0x3A,0x53,0x4D,0x60,0x5D,0x42,	/*20*/
	0x33,0x32,0x3D,0x4F,0x1C,0x0F,0x15,0x45,	/*28*/
	0x25,0x27,0x2F,0x35,0x3F,0x38,0x3B,0x44,	/*30*/
	0x43,0x47,0x31,0x49,0x51,0x14,0x4C,0x5A,	/*38*/
	0x5E,0x1F,0x2E,0x22,0x24,0x1D,0x2B,0x34,	/*40*/
	0x36,0x20,0x56,0x41,0x2A,0x26,0x2C,0x21,	/*48*/
	0x29,0x4E,0x23,0x1B,0x1A,0x37,0x46,0x39,	/*50*/
	0x3E,0x40,0x59,0x54,0x52,0x55,0x5F,0x3C,	/*58*/
	0x64,0x04,0x18,0x0E,0x0D,0x01,0x12,0x16,	/*60*/
	0x0C,0x05,0x50,0x28,0x09,0x11,0x06,0x03,	/*68*/
	0x13,0x4A,0x07,0x08,0x02,0x10,0x1E,0x19,	/*70*/
	0x2D,0x17,0x4B,0x5C,0x48,0x5B,0x61,0x7D,
};

//---------------------------------------------------------------------------
__fastcall CVARICODE::CVARICODE()
{
    m_tEncode = NULL;
    m_Max = m_TMax = 0;
}

__fastcall CVARICODE::~CVARICODE()
{
	if( m_tEncode ) delete m_tEncode;
}

void __fastcall CVARICODE::Init(void)
{
    if( !LoadBin("VariCode.tbl") ){
	    Create(256+(192*126));
    }
	for( int i = 0; i < 128; i++ ){
		m_tIndex2Mbcs[_tMbcs2Index[i]] = BYTE(i);
    }
}

void __fastcall CVARICODE::Create(int max)
{
	if( m_tEncode ) delete m_tEncode;
	m_TMax = max;
	DWORD *tEncode = new DWORD[m_TMax];
	m_Max = 0;
    int i;
    int b, db;
	tEncode[m_Max++] = 0x01000001;
    tEncode[m_Max++] = 0x02000003;
    int bmax = 3;
    int bm = 2;
    int bl = 0;
	while(m_Max < m_TMax){
		for( b = bl; b < bm; b++ ){
            BOOL f = TRUE;
			db = b;
			for( i = 3; i < bmax; i++ ){
				if( !(db & 1) && !(db & 2) ){
                	f = FALSE;
                    break;
                }
                db = db >> 1;
            }
			if( f ){
				db = b << 1;
    	        db |= (1 | (bm<<1));
	            db = db | (bmax << 24);
				tEncode[m_Max++] = db;
                if( m_Max >= m_TMax ) break;
            }
        }
		bl = bl << 1;
        if( !(bl & 2) ) bl |= 1;
        bm = bm << 1;
        bmax++;
        if( bmax >= 24 ) break;
    }
    m_tEncode = tEncode;
    SaveBin("VariCode.tbl");
}

static int __fastcall SwapIndex(int index)
{
    if( index <= 0x00d3 ){								// $80-$D3
		index += 0x21f - 0x0080;	// $80-$D3 to Hiragana
    }
	else if( index <= 0x12a ){							// $D4-$12A
		index += 0x280 - 0x00d4;	// $D4-$12A to Katakana
    }
    else if( (index >= 0x021f) && (index <= 0x0272) ){	// Hiragana
		index -= 0x21f - 0x0080;	// Hiragana to $80-$D3
    }
    else if( (index >= 0x0280) && (index <= 0x02d6) ){	// Katakana
		index -= 0x280 - 0x00d4;	// Katakana to $D4-$12A
    }
   	else if( (index >= 0x1840) && (index <= 0x2f7f) ){
		index += 0x4840 - 0x1840;
    }
	else if( (index >= 0x4840) && (index <= 0x5f7f) ){
		index -= 0x4840 - 0x1840;
    }

    return index;
}

UINT __fastcall CVARICODE::Index2Mbcs(int index, BOOL fJA)
{
    if( fJA && (index >= 0x4840) ){	// 古いバージョンとの互換性用
		index -= 0x4840 - 0x1840;
    }
    if( index <= 0x007f ){
		index = m_tIndex2Mbcs[index];
    }
	else if( index >= m_Max ){
		return 0;
    }
    else if( fJA ){
		index = SwapIndex(index);
    }

	UINT mbcs;
    int m, b;
	if( index >= 0x0100 ){
		index -= 0x0100;
		m = index % 192;
		b = index / 192;
		mbcs = 0x8140 + m + b * 256;
	}
    else {
		mbcs = index;
    }
    return mbcs;
}

int __fastcall CVARICODE::Mbcs2Index(UINT mbcs, BOOL fJA)
{
	int index, m, b;
	if( mbcs >= 0x8100 ){
		if( (mbcs & 0x00ff) >= 0x0040 ){
			mbcs -= 0x8100;
			m = mbcs % 256;
			b = mbcs / 256;
			index = 0x100 - 0x40 + m + b * 192;
		}
		else {
			return -1;
		}
	}
    else {
		index = mbcs;
    }
	if( index >= m_Max ){
		index = 0;
    }
    else if( index <= 0x007f ){
		index = _tMbcs2Index[index];
    }
    else if( fJA ){
		index = SwapIndex(index);
    }
    return index;
}

void __fastcall CVARICODE::SaveTable(LPCSTR pName)
{
	CWaitCursor w;
	FILE *fp;
    if( (fp = fopen(pName, "wt")) != NULL ){
    	OnWave();
		fprintf(fp, "Index ANSI  JA    HL/BV/BY Bits\tVaricode\n");
    	int i, j;
		for( i = 0; i < m_Max; i++ ){
        	DWORD b = m_tEncode[i];
            int n = b >> 24;
            b &= 0x00ffffff;
			int m = Index2Mbcs(i, FALSE);
            j = Index2Mbcs(i, TRUE);
            if( i >= 0x2f80 ){
				fprintf(fp, "%04X              %04X     %-4u\t", i, m, n);
            }
			else if( i < 0x100 ){
				fprintf(fp, "%04X  %04X  %04X  %04X     %-4u\t", i, m, j, m, n);
            }
            else {
				fprintf(fp, "%04X        %04X  %04X     %-4u\t", i, j, m, n);
            }
            DWORD bm = _tBitData[n-1];
			for( j = 0; j < n; j++, bm = bm >> 1){
				fprintf(fp, "%c", (b & bm) ? '1' : '0');
            }
            fprintf(fp, "\n");
            if( !(i & 0xff) ) OnWave();
        }
		fclose(fp);
        OnWave();
    }
}

void __fastcall CVARICODE::SaveSource(LPCSTR pName)
{
	FILE *fp;
    if( (fp = fopen(pName, "wt")) != NULL ){
		fprintf(fp, "const DWORD g_tVariCode[%u]={\n", m_TMax);
    	int i;
		for( i = 0; i < m_Max; i++ ){
        	DWORD b = m_tEncode[i];
			if( !(i % 8) ) fprintf(fp, "\n\t");
			fprintf(fp, "0x%X,", b);
        }
        fprintf(fp, "};\n");
		fclose(fp);
    }
}

void __fastcall CVARICODE::SaveBin(LPCSTR pName)
{
	CWaitCursor w;
	char name[256];
    sprintf(name, "%s%s", sys.m_BgnDir, pName);
	FILE *fp;
    if( (fp = fopen(name, "wb")) != NULL ){
		fwrite(m_tEncode, sizeof(DWORD), m_Max, fp);
        fclose(fp);
    }
}

BOOL __fastcall CVARICODE::LoadBin(LPCSTR pName)
{
	BOOL r = FALSE;
	char name[256];
    sprintf(name, "%s%s", sys.m_BgnDir, pName);
	FILE *fp;
    if( (fp = fopen(name, "rb")) != NULL ){
    	int len = 256 + (126*192);
		if( m_tEncode ) delete m_tEncode;
		m_tEncode = new DWORD[len];
		fread(m_tEncode, sizeof(DWORD), len, fp);
        fclose(fp);
        m_TMax = m_Max = len;
        r = TRUE;
    }
    return r;
}

DWORD __fastcall CVARICODE::Encode(int &n, DWORD d)
{
	if( d < DWORD(m_Max) ){
		d = m_tEncode[d];
		n = d >> 24;
    }
    else {
		d = 0;
        n = 1;
    }
    return d;
}

int __fastcall CVARICODE::Decode(DWORD d)
{
	// VARICODEを二分探査サーチでインデックスに変換
	int l, h, m;
    l = 0;
    h = m_Max - 1;
    while(l <= h){
		m = (l + h)/2;
		DWORD b = m_tEncode[m] & 0x00ffffff;
        if( d < b ){
			h = m - 1;
        }
        else if( d > b ){
			l = m + 1;
        }
        else {
			return m;
        }
    }
	return -1;
}
//---------------------------------------------------------------------------
const WORD g_tMFSKVariCode[]={			// MFSK VARICODE インデックス順
	0x3004,0x4008,0x400C,0x5010,0x5014,0x5018,0x501C,0x6020,0x6028,0x602C,0x6030,0x6034,0x6038,0x603C,0x7040,0x7050,	//00
	0x7054,0x7058,0x705C,0x7060,0x7068,0x706C,0x7070,0x7074,0x7078,0x707C,0x8080,0x80A0,0x80A8,0x80AC,0x80B0,0x80B4,	//10
	0x80B8,0x80BC,0x80C0,0x80D0,0x80D4,0x80D8,0x80DC,0x80E0,0x80E8,0x80EC,0x80F0,0x80F4,0x80F8,0x80FC,0x9100,0x9140,	//20
	0x9150,0x9154,0x9158,0x915C,0x9160,0x9168,0x916C,0x9170,0x9174,0x9178,0x917C,0x9180,0x91A0,0x91A8,0x91AC,0x91B0,	//30
	0x91B4,0x91B8,0x91BC,0x91C0,0x91D0,0x91D4,0x91D8,0x91DC,0x91E0,0x91E8,0x91EC,0x91F0,0x91F4,0x91F8,0x91FC,0xA200,	//40
	0xA280,0xA2A0,0xA2A8,0xA2AC,0xA2B0,0xA2B4,0xA2B8,0xA2BC,0xA2C0,0xA2D0,0xA2D4,0xA2D8,0xA2DC,0xA2E0,0xA2E8,0xA2EC,	//50
	0xA2F0,0xA2F4,0xA2F8,0xA2FC,0xA300,0xA340,0xA350,0xA354,0xA358,0xA35C,0xA360,0xA368,0xA36C,0xA370,0xA374,0xA378,	//60
	0xA37C,0xA380,0xA3A0,0xA3A8,0xA3AC,0xA3B0,0xA3B4,0xA3B8,0xA3BC,0xA3C0,0xA3D0,0xA3D4,0xA3D8,0xA3DC,0xA3E0,0xA3E8,	//70
	0xA3EC,0xA3F0,0xA3F4,0xA3F8,0xA3FC,0xB400,0xB500,0xB540,0xB550,0xB554,0xB558,0xB55C,0xB560,0xB568,0xB56C,0xB570,	//80
	0xB574,0xB578,0xB57C,0xB580,0xB5A0,0xB5A8,0xB5AC,0xB5B0,0xB5B4,0xB5B8,0xB5BC,0xB5C0,0xB5D0,0xB5D4,0xB5D8,0xB5DC,	//90
	0xB5E0,0xB5E8,0xB5EC,0xB5F0,0xB5F4,0xB5F8,0xB5FC,0xB600,0xB680,0xB6A0,0xB6A8,0xB6AC,0xB6B0,0xB6B4,0xB6B8,0xB6BC,	//A0
	0xB6C0,0xB6D0,0xB6D4,0xB6D8,0xB6DC,0xB6E0,0xB6E8,0xB6EC,0xB6F0,0xB6F4,0xB6F8,0xB6FC,0xB700,0xB740,0xB750,0xB754,	//B0
	0xB758,0xB75C,0xB760,0xB768,0xB76C,0xB770,0xB774,0xB778,0xB77C,0xB780,0xB7A0,0xB7A8,0xB7AC,0xB7B0,0xB7B4,0xB7B8,	//C0
	0xB7BC,0xB7C0,0xB7D0,0xB7D4,0xB7D8,0xB7DC,0xB7E0,0xB7E8,0xB7EC,0xB7F0,0xB7F4,0xB7F8,0xB7FC,0xC800,0xCA00,0xCA80,	//D0
	0xCAA0,0xCAA8,0xCAAC,0xCAB0,0xCAB4,0xCAB8,0xCABC,0xCAC0,0xCAD0,0xCAD4,0xCAD8,0xCADC,0xCAE0,0xCAE8,0xCAEC,0xCAF0,	//E0
	0xCAF4,0xCAF8,0xCAFC,0xCB00,0xCB40,0xCB50,0xCB54,0xCB58,0xCB5C,0xCB60,0xCB68,0xCB6C,0xCB70,0xCB74,0xCB78,0xCB7C,
};
const BYTE g_tMFSKIndex2Ascii[]={		// MFSK Index -> Ascii
	0x20,0x65,0x74,0x6F,0x61,0x69,0x6E,0x72,0x73,0x6C,0x68,0x64,0x63,0x75,0x6D,0x66,	//00
	0x70,0x67,0x79,0x62,0x77,0x76,0x6B,0x78,0x71,0x7A,0x6A,0x2C,0x08,0x0D,0x54,0x53,	//10
	0x45,0x41,0x49,0x4F,0x43,0x52,0x44,0x30,0x4D,0x50,0x31,0x4C,0x46,0x4E,0x42,0x32,	//20
	0x47,0x33,0x48,0x55,0x35,0x57,0x36,0x58,0x34,0x59,0x4B,0x38,0x37,0x56,0x39,0x51,	//30
	0x4A,0x5A,0x27,0x21,0x3F,0x2E,0x2D,0x3D,0x2B,0x2F,0x3A,0x29,0x28,0x3B,0x22,0x26,	//40
	0x40,0x25,0x24,0x60,0x5F,0x2A,0x7C,0x3E,0x3C,0x5C,0x5E,0x23,0x7B,0x7D,0x5B,0x5D,	//50
	0x7E,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,	//60
	0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,	//70
	0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,	//80
	0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,	//90
	0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,	//A0
	0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,	//B0
	0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,0x0E,0x0F,0x10,	//C0
	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x7F,	//D0
	0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,	//E0
	0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
};
const BYTE g_tMFSKAscii2Index[]={		// MFSK Ascii -> Index
	0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0x1C,0xC9,0xCA,0xCB,0xCC,0x1D,0xCD,0xCE,	//00
	0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,	//10
	0x00,0x43,0x4E,0x5B,0x52,0x51,0x4F,0x42,0x4C,0x4B,0x55,0x48,0x1B,0x46,0x45,0x49,	//20
	0x27,0x2A,0x2F,0x31,0x38,0x34,0x36,0x3C,0x3B,0x3E,0x4A,0x4D,0x58,0x47,0x57,0x44,	//30
	0x50,0x21,0x2E,0x24,0x26,0x20,0x2C,0x30,0x32,0x22,0x40,0x3A,0x2B,0x28,0x2D,0x23,	//40
	0x29,0x3F,0x25,0x1F,0x1E,0x33,0x3D,0x35,0x37,0x39,0x41,0x5E,0x59,0x5F,0x5A,0x54,	//50
	0x53,0x04,0x13,0x0C,0x0B,0x01,0x0F,0x11,0x0A,0x05,0x1A,0x16,0x09,0x0E,0x06,0x03,	//60
	0x10,0x18,0x07,0x08,0x02,0x0D,0x15,0x14,0x17,0x12,0x19,0x5C,0x56,0x5D,0x60,0xDF,	//70
	0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,	//80
	0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,	//90
	0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,	//A0
	0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,	//B0
	0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,	//C0
	0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,	//D0
	0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,	//E0
	0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,
};
//---------------------------------------------------------------------------
int __fastcall CVARICODE::DecodeMFSK(DWORD d)
{
	// VARICODEを二分探査サーチでインデックスに変換
	int l, h, m;
    l = 0;
    h = 256 - 1;
    while(l <= h){
		m = (l + h)/2;
		DWORD b = g_tMFSKVariCode[m] & 0x00fff;
        if( d < b ){
			h = m - 1;
        }
        else if( d > b ){
			l = m + 1;
        }
        else {
			return g_tMFSKIndex2Ascii[m];
        }
    }
	return -1;
}

//---------------------------------------------------------------------------
int __fastcall CVARICODE::EncodeMFSK(BYTE c)
{
	return g_tMFSKVariCode[g_tMFSKAscii2Index[c]];
}

//---------------------------------------------------------------------------
BCODETBL _TTY[]={			// S-BELL
		// 0x20 - 0x7f
		{0x04, 2}, {0x16, 1}, {0x11, 1}, {0x00, 2}, //  !"#
		{0x12, 1}, {0x00, 2}, {0x0b, 1}, {0x1a, 1}, // $%&'
		{0x1e, 1}, {0x09, 1}, {0x00, 2}, {0x00, 2}, // ()*+
		{0x06, 1}, {0x18, 1}, {0x07, 1}, {0x17, 1}, // ,-./
		{0x0d, 1}, {0x1d, 1}, {0x19, 1}, {0x10, 1},	// 0123	30-33
		{0x0a, 1}, {0x01, 1}, {0x15, 1}, {0x1c, 1},	// 4567	34-37
		{0x0c, 1}, {0x03, 1}, {0x0e, 1}, {0x0f, 1},	// 89	38-3b
		{0x00, 2}, {0x00, 2}, {0x00, 2}, {0x13, 1},	// <=>?	3c-3f
		{0x00, 2}, {0x18, 0}, {0x13, 0}, {0x0e, 0},	// @ABC	40-43
		{0x12, 0}, {0x10, 0}, {0x16, 0}, {0x0b, 0},	// DEFG
		{0x05, 0}, {0x0c, 0}, {0x1a, 0}, {0x1e, 0},	// HIJK
		{0x09, 0}, {0x07, 0}, {0x06, 0}, {0x03, 0},	// LMNO
		{0x0d, 0}, {0x1d, 0}, {0x0a, 0}, {0x14, 0},	// PQRS
		{0x01, 0}, {0x1c, 0}, {0x0f, 0}, {0x19, 0},	// TUVW
		{0x17, 0}, {0x15, 0}, {0x11, 0}, {0x00, 2},	// XYZ[ 58-5b
		{0x00, 2}, {0x00, 2}, {0x00, 2}, {0x00, 2}, // \]^_
		{0x00, 2}, {0x18, 0}, {0x13, 0}, {0x0e, 0},	// @ABC	60-63
		{0x12, 0}, {0x10, 0}, {0x16, 0}, {0x0b, 0},	// DEFG
		{0x05, 0}, {0x0c, 0}, {0x1a, 0}, {0x1e, 0},	// HIJK
		{0x09, 0}, {0x07, 0}, {0x06, 0}, {0x03, 0},	// LMNO
		{0x0d, 0}, {0x1d, 0}, {0x0a, 0}, {0x14, 0},	// PQRS
		{0x01, 0}, {0x1c, 0}, {0x0f, 0}, {0x19, 0},	// TUVW
		{0x17, 0}, {0x15, 0}, {0x11, 0}, {0x00, 2},	// XYZ[ 78-7b
		{0x00, 2}, {0x00, 2}, {0x00, 2}, {0x00, 2},	// |{~
};

//---------------------------------------------------------------------------
__fastcall CBAUDOT::CBAUDOT()
{
	Reset();
}
//---------------------------------------------------------------------------
__fastcall CBAUDOT::~CBAUDOT()
{
}
//---------------------------------------------------------------------------
int __fastcall CBAUDOT::GetOneCode(int &fig, int code)
{
	int r;
	switch(code){
		case '\n':
			r = 0x08;
            fig = 2;
			break;
		case '\r':
			r = 0x02;
            fig = 2;
			break;
        default:
			if( (code >= 0x20) && (code <= 0x7f) ){
				code -= 0x20;
				r = _TTY[code].Code;
                fig = _TTY[code].Fig;
            }
            else {
				r = -1;
            }
        	break;
    }
    return r;
}
//---------------------------------------------------------------------------
// 15bitsデータを作成する
int __fastcall CBAUDOT::DblCode(int code)
{
	int d = 7;		// Stop bits
	int i;
    for( i = 0; i < 5; i++, code = code >> 1 ){
		d = d << 1;
		if( code & 0x0001 ) d |= 1;
        d = d << 1;
        if( code & 0x0001 ) d |= 1;
    }
    d = d << 2;		// Start bits
    return d;
}
//---------------------------------------------------------------------------
int __fastcall CBAUDOT::GetCode(int &count, int code)
{
	int fig;
	int r = GetOneCode(fig, code);
    if( r < 0 ) return r;
//Added by JA7UDE (April 17, 2010)
	int ext_r = r;
	int ext_f = 0;
//Till here
    r = DblCode(r);
    if( (m_OutFig < 0) || ((fig != 2)&&(m_OutFig != fig)) || ((m_CodeB4 == ' ')&&(fig==1)) ){
        switch(fig){
            case 1:		// FIG
				m_OutFig = 1;
                r = r << 15;
				r |= DblCode(0x1b);
//Added by JA7UDE (April 17, 2010)
				ext_f = 0x1b;
//Till here
            	break;
            default:	// LTR
				m_OutFig = 0;
                r = r << 15;
				r |= DblCode(0x1f);
//Added by JA7UDE (April 17, 2010)
				ext_f = 0x1f;
//Till here
            	break;
        }
        count = 30;
    }
    else {
		count = 15;
    }
	m_CodeB4 = code;
//Added by JA7UDE on April 5, 2010
	if( ext_f ) MainVARI->ExtFskIt(ext_f);
	MainVARI->ExtFskIt(ext_r);
//Till here
    return r;
}
//---------------------------------------------------------------------------
const char _LTR[32]={
	0x00, 'T', 0x0d, 'O', ' ', 'H', 'N', 'M',
	0x0a, 'L', 'R', 'G', 'I', 'P', 'C', 'V',
	'E', 'Z', 'D', 'B', 'S', 'Y', 'F', 'X',
	'A', 'W', 'J', 0x00, 'U', 'Q', 'K', 0x00,
};
const char _FIG[32]={
	0x00, '5', 0x0d, '9', ' ', 'h', ',', '.',
	0x0a, ')', '4', '&', '8', '0', ':', ';',
	'3', '"', '$', '?', 's', '6', '!', '/',
	'-', '2', 0x27, 0x00, '7', '1', '(', 0x00,
};

CRTTY::CRTTY()
{
	m_outfig = 3;

	m_fig = 0;
	m_uos = TRUE;

	m_txuos = 1;
    m_CodeSet = 0;		// 0:S-BELL, 1:J-BELL
	SetCodeSet();
}

void CRTTY::SetCodeSet(void)
{
	memcpy(m_TBL, _TTY, sizeof(m_TBL));
	if( m_CodeSet ){		// J-BELL
		m_TBL[7].Code = 0x14;
	}
}

// 11011 FIG
// 11111 LTR
char CRTTY::ConvAscii(int d)
{
	char c = 0;
	d &= 0x1f;
	if( d == 0x1b ){		// FIG
		m_fig = 1;
	}
	else if( d == 0x1f ){	// LTR
		m_fig = 0;
	}
	else if( m_fig ){
		c = _FIG[d];
		if( m_CodeSet ){
			switch(c){
				case 's':
					c = 0x27;
					break;
				case 0x27:
					c = 'j';
					break;
			}
		}
		if( m_uos ){
			switch(c){
				case ' ':
//                case 0x0d:
//                case 0x0a:
					m_fig = 0;
					break;
				default:
					break;
			}
		}
	}
	else {
		c = _LTR[d];
	}
	return c;
}

int CRTTY::ConvRTTY(char d)
{
	int fig = 2;
	int r = 0;
	switch(d){
		case '_':
			r = 0x00ff;
			break;
		case '~':
			r = 0x00fe;
			break;
		case '[':
			r = 0x00fd;
			break;
		case ']':
			r = 0x00fc;
			break;
		case 0x0a:
			r = 0x08;
			break;
		case 0x0d:
			r = 0x02;
			break;
		case 0x1b:
			r = 0x1b;
			fig = 1;
			break;
		case 0x1f:
			r = 0x1f;
			fig = 0;
			break;
		default:
			if( d >= 0x20 ){
				d -= char(0x20);
				r = m_TBL[d].Code;
				fig = m_TBL[d].Fig;
			}
			break;
	}
	if( fig != 2 ){
		if( fig != m_outfig ){
			r |= (fig ? 0x1b00 : 0x1f00);
			m_outfig = fig;
		}
	}
	else if( r == 0x04 ){	// スペースの時
		if( m_outfig == 1 ) m_outfig = 2;
	}
	return r;
}

int CRTTY::ConvRTTY(BYTE *t, LPCSTR p)
{
	int n;
	int d;
	for( n = 0;*p; p++ ){
		d = ConvRTTY(*p);
		if( d & 0x0000ff00 ){
			*t++ = BYTE(d >> 8);
			n++;
		}
		*t++ = BYTE(d);
		n++;
	}
	return n;
}

int CRTTY::GetShift(char d)
{
	int fig = 2;
	switch(d){
		default:
			if( d >= 0x20 ){
				d -= char(0x20);
				fig = m_TBL[d].Fig;
				if( !m_TBL[d].Code ){
					fig = 2;
				}
			}
			break;
	}
	return fig;
}

char CRTTY::InvShift(char c)
{
	int fs = GetShift(c);
	if( (c == 'h') || (c == 's') || (c == 'j') ) fs = 1;
	int d = ConvRTTY(c) & 0x001f;
	switch(fs){
		case 0:
			if( _FIG[d] ){
				c = _FIG[d];
				if( m_CodeSet ){
					switch(c){
						case 's':
							c = 0x27;
							break;
						case 0x27:
							c = 'j';
							break;
					}
				}
			}
			return c;
		case 1:
			return _LTR[d] ? _LTR[d] : c;
		default:
			return c;
	}
}

//---------------------------------------------------------------------------
__fastcall CClock::CClock()
{
	m_pData = NULL;
	m_SampleFreq = SAMPFREQ;
    m_ToneFreq = 1000.0;
}

//---------------------------------------------------------------------------
__fastcall CClock::~CClock()
{
	if( m_pData ) delete m_pData;
}

//---------------------------------------------------------------------------
void __fastcall CClock::Create(int max)
{
	m_Width = max;
    if( m_pData ) delete m_pData;
    m_pData = new int[m_Width];
    memset(m_pData, 0, sizeof(int)*m_Width);
    m_dNow = 0;
	m_BPF.m_Freq = m_ToneFreq;
    m_BPF.m_BW = 100.0;
    SetSampleFreq(m_SampleFreq);
    m_LPF.Create(ffLPF, 100, m_SampleFreq, 3, 0, 0);

}

//---------------------------------------------------------------------------
void __fastcall CClock::SetSampleFreq(double f)
{
	m_SampleFreq = f;
    m_dAdd = m_Width / m_SampleFreq;
    m_BPF.SetSampleFreq(m_SampleFreq);
}

//---------------------------------------------------------------------------
void __fastcall CClock::SetToneFreq(double f)
{
	m_ToneFreq = f;
	m_BPF.m_Freq = m_ToneFreq;
    m_BPF.SetSampleFreq(m_SampleFreq);
}
//---------------------------------------------------------------------------
BOOL __fastcall CClock::Do(short ds)
{
	BOOL f = FALSE;
	double d = m_BPF.Do(ds);
    d = m_LPF.Do(ABS(d));
	int i = m_dNow;
    if( i < 0 ) i = 0;
    if( i > m_Width ) i = m_Width;
    m_pData[i] = d;
    m_dNow += m_dAdd;
    if( m_dNow >= m_Width ){
		f = TRUE;
    	m_dNow -= m_Width;
    }
    if( m_dNow < 0 ) m_dNow += m_Width;
    return f;
}
//---------------------------------------------------------------------------
__fastcall CAMPCONT::CAMPCONT()
{
    m_Max = g_SinTable.m_Size / 4;
    m_iMax = g_SinTable.m_Size / 4;
    m_Cnt = m_Max;
    m_S = 0;
    SetMax(16);
}
//---------------------------------------------------------------------------
void __fastcall CAMPCONT::SetMax(int max)
{
    m_ADD = m_Max / double(max);
}
//---------------------------------------------------------------------------
void __fastcall CAMPCONT::Reset(void)
{
	m_Cnt = m_Max;
    m_S = 0;
}
//---------------------------------------------------------------------------
double __fastcall CAMPCONT::Do(int s)
{
	if( s != m_S ){
		m_Cnt = 0.0;
	    m_S = s;
    }
	int r = m_Cnt;
    if( r >= m_Max ) return s;
    m_Cnt += m_ADD;
    if( s ){
		return g_SinTable.m_tSin[r];
    }
    else {
		return g_SinTable.m_tSin[r+m_iMax];
    }
}


//---------------------------------------------------------------------------
__fastcall CBFifo::CBFifo()
{
	m_WP = m_RP = m_CNT = m_MAX = 0;
	m_pBase = NULL;
	m_D = FALSE;
}
//---------------------------------------------------------------------------
__fastcall CBFifo::~CBFifo()
{
	if( m_pBase ){
		delete m_pBase;
        m_pBase = NULL;
    }
}
//---------------------------------------------------------------------------
void __fastcall CBFifo::Create(int max)
{
	if( m_pBase ) delete m_pBase;
    m_pBase = new BOOL[max];
	m_WP = m_RP = m_CNT = 0;
    m_MAX = max;
}
//---------------------------------------------------------------------------
void __fastcall CBFifo::PutFlag(BOOL f)
{
	if( m_CNT < m_MAX ){
		m_pBase[m_WP] = f;
        m_WP++;
        if( m_WP >= m_MAX ) m_WP = 0;
        m_CNT++;
        if( m_CNT >= m_MAX ) m_CNT = m_MAX;
    }
}
//---------------------------------------------------------------------------
BOOL __fastcall CBFifo::GetFlag(void)
{
	if( m_CNT ){
		m_D = m_pBase[m_RP];
        m_RP++;
        if( m_RP >= m_MAX ) m_RP = 0;
        m_CNT--;
    }
	return m_D;
}
/*=============================================================================
  CPHASEクラス
=============================================================================*/
__fastcall CPHASE::CPHASE()
{
	m_MFSK_TONES = 16;
	m_MFSK_SPEED = 15.625;
	m_MFSK_BASEPOINT = int(MFSK_BASEFREQ/15.625);

	m_SampleFreq = 11025.0*0.5;
    m_CarrierFreq = 1750;
    m_MixerFreq = 0;
    SetSampleFreq(m_SampleFreq);
}
//--------------------------------------------------------------------------
void __fastcall CPHASE::SetMFSKType(int type)
{
	MFSK_SetPara(type, &m_MFSK_TONES, &m_MFSK_SPEED, NULL);
    m_MFSK_BASEPOINT = int(MFSK_BASEFREQ/m_MFSK_SPEED);
}
//--------------------------------------------------------------------------
void __fastcall CPHASE::SetSampleFreq(double f)
{
	m_SampleFreq = f;
    Create();
}
//--------------------------------------------------------------------------
void __fastcall CPHASE::Create(void)
{
    m_SymbolLen = m_SampleFreq/m_MFSK_SPEED;
	m_MixerFreq = double(m_MFSK_BASEPOINT) * m_SampleFreq / m_SymbolLen;
	m_VCO.SetSampleFreq(m_SampleFreq);
	m_Hilbert.Create(20, m_SampleFreq, 25.0, m_SampleFreq*0.5 - 25.0);
    m_Hilbert.Clear();
    SetCarrierFreq(m_CarrierFreq);
    m_SlideFFT.Create(int(m_SymbolLen + 0.5), m_MFSK_BASEPOINT, m_MFSK_TONES);
}
//--------------------------------------------------------------------------
void __fastcall CPHASE::SetCarrierFreq(double f)
{
	m_CarrierFreq = f;
    m_VCO.SetFreeFreq(m_CarrierFreq - m_MixerFreq);
}
//--------------------------------------------------------------------------
CLX* __fastcall CPHASE::Do(double d)
{
	m_Hilbert.Do(m_sig, d);					// 複素数化

    CLX z;
	z.r = m_VCO.Do();
    z.j = m_VCO.DoCos();
	z *= m_sig;								// 周波数変換

	return m_SlideFFT.Do(z);
}
/*=============================================================================
  CDecMFSKクラス
=============================================================================*/
__fastcall CDecMFSK::CDecMFSK()
{
	m_MFSK_TYPE = typMFSK16;
	m_MFSK_TONES = 16;
	m_MFSK_SPEED = 15.625;
	m_MFSK_BITS = 4;
	m_MFSK_BW = m_MFSK_SPEED * (m_MFSK_TONES - 1);

	m_InterLeaver.Init(m_MFSK_BITS);
	m_AmpStgPtr = 0;
	m_SHDATA = 0;

	m_Metric1 = m_Metric2 = 0;
	m_ViterbiPair[0] = m_ViterbiPair[1] = 0;
	m_ViterbiPhase = 0;
	m_Viterbi1.Init(MFSK_VITERBI_K, MFSK_VITERBI_POLY1, MFSK_VITERBI_POLY2);
	m_Viterbi2.Init(MFSK_VITERBI_K, MFSK_VITERBI_POLY1, MFSK_VITERBI_POLY2);

	memset(m_SymStg, 0, sizeof(m_SymStg));

	m_AvgMetric = 0;

	m_dNow = 0;

	m_Tmg = m_SyncState = 0;

    m_fLSB = FALSE;
    m_RxData.Clear();

	m_fSQ = FALSE;
	m_fDelaySQ = FALSE;
	m_SQDelayCount = 0;

	m_AvgClock.Create(8);
    m_AvgAFC.Create(8);
    m_PrevZ = 0;
    m_kAFC = 0;
    m_AFCWidth = 0;
    SetSampleFreq(11025*0.5);
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::SetMFSKType(int type)
{
	m_MFSK_TYPE = type;
	MFSK_SetPara(type, &m_MFSK_TONES, &m_MFSK_SPEED, &m_MFSK_BITS);
	m_MFSK_BW = m_MFSK_SPEED * (m_MFSK_TONES - 1);
	m_InterLeaver.Init(m_MFSK_BITS);
	SetSampleFreq(m_SampleFreq);
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::SetCarrierFreq(double f)
{
	if( sys.m_MFSK_Center ){
		f -= m_MFSK_BW*0.5;
    }
    else {
		if( m_fLSB ) f -= m_MFSK_BW;
    }
	m_Phase.SetCarrierFreq(f);
    m_AvgAFC.Reset();
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::Reset(void)
{
	m_SHDATA = 0;

    m_dNow = 0;
	m_dTW = m_dBTW = m_SampleFreq / m_MFSK_SPEED;
    m_dBTWL = m_dBTW * (1.0-(15000.0 * 1.0e-6));
    m_dBTWH = m_dBTW * (1.0+(15000.0 * 1.0e-6));

	m_AvgMetric = 0;
	memset(m_SymStg, 0, sizeof(m_SymStg));

	m_AmpStgPtr = 0;
	memset(m_AmpStg, 0, sizeof(m_AmpStg));

	m_Metric1 = m_Metric2 = 0;
	m_ViterbiPair[0] = m_ViterbiPair[1] = 0;
	m_ViterbiPhase = 0;

    m_Viterbi1.Reset();
    m_Viterbi2.Reset();

    m_RxData.Clear();
	m_InterLeaver.Reset();

	m_SyncState = FALSE;

	m_fSQ = FALSE;
	m_fDelaySQ = FALSE;
	m_SQDelayCount = 0;
    ResetMeas();
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::SetSampleFreq(double f)
{
	m_SampleFreq = f;
	m_dTW = m_dBTW = m_SampleFreq / m_MFSK_SPEED;
    m_kAFC = m_MFSK_SPEED / (2.0*PI);
    m_AFCWidth = m_MFSK_SPEED * 0.48;
    m_AmpStgMax = int(m_dBTW * 2);
#if DEBUG
	if( m_AmpStgMax > AMPSTGMAX ) Application->MainForm->Caption = "Over AmpStgSize of MFSK";
#endif
	memset(m_AmpStg, 0, sizeof(m_AmpStg));
//	Application->MainForm->Caption = m_MFSK_TONES;
    m_Phase.SetMFSKType(m_MFSK_TYPE);
    m_Phase.SetSampleFreq(m_SampleFreq);
	Reset();
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::ResetMeas(void)
{
    m_AvgClock.Reset();
    m_MeasClock = m_MeasCounter = m_MeasStage = 0;
    m_dTW = m_dBTW;
};
//--------------------------------------------------------------------------
double __fastcall CDecMFSK::GetFactor(void)
{
//    Application->MainForm->Caption = m_ViterbiPhase;
	if( m_ViterbiPhase < 256 ){
		return 0.001;
    }
    else if( m_MFSK_TONES == 8 ){
		return 0.01625;
    }
    else {
		return 0.03125;
    }
}
//--------------------------------------------------------------------------
// - MFSK8,MFSK31の場合は奇数フェーズと偶数フェーズがあるため、
//   2つのViterbiのええほうを取る
// - MFSK16は2回に1回Viterbi2を実行する
void __fastcall CDecMFSK::StreamSym(BYTE sym)
{
	int c, metric;

	m_ViterbiPair[0] = m_ViterbiPair[1]; m_ViterbiPair[1] = sym;
	m_ViterbiPhase++;
	if( m_ViterbiPhase & 1 ){	// MFSK8, MFSK31
		if( m_MFSK_TONES == 16 ) return;
		if( (c = m_Viterbi1.Decode(&metric, m_ViterbiPair)) == -1 ) return;
		DoAvg(m_Metric1, metric, GetFactor());
		if( m_Metric1 < m_Metric2 ) return;
		m_AvgMetric = m_Metric1;
//		Application->MainForm->Caption = "Phase odd";
	}
    else {						// MFSK8, MFSK16, MFSK31
		if( (c = m_Viterbi2.Decode(&metric, m_ViterbiPair)) == -1 ) return;
		DoAvg(m_Metric2, metric, GetFactor());
		if( (m_MFSK_TONES != 16) && (m_Metric2 < m_Metric1) ) return;
		m_AvgMetric = m_Metric2;
//		Application->MainForm->Caption = "Phase even";
	}
//	char bf[256];
//    sprintf(bf, "%d", m_ViterbiPhase);
//    Application->MainForm->Caption = bf;
//
//	S/N			Metric
//	30dB		240
//	20dB		220
//	10dB		110
//	Application->MainForm->Caption = int(m_AvgMetric);
//
	m_SHDATA = m_SHDATA << 1;
    if( c ) m_SHDATA |= 1;

	if( (m_SHDATA & 7) == 1 ){		// 001を探す
		c = g_VariCode.DecodeMFSK(m_SHDATA >> 1);
		if( (c != -1) && (m_fSQ || m_fDelaySQ) ) m_RxData.PutData(c);
		m_SHDATA = 1;				// 次の文字(1xxx)の先頭
	}
}
//--------------------------------------------------------------------------
BYTE __fastcall Limit256(double x)
{
	if( x < 0 ) return 0;
    if( x > 255 ) return 255;
    return BYTE(x);
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::RecSym(const double *pAmp)
{
	int		i, n;
	BYTE	tSym[MFSK_MAXBITS];
	double	tVal[MFSK_MAXBITS];
	double	*dp;

	memset(tVal, 0, sizeof(tVal));
	double sum = 1e-10;
	for(i = 0; i < m_MFSK_TONES; i++){
		if( m_fLSB ){
			n = m_MFSK_TONES - i - 1;
        }
		else {
			n = i;
        }

		double v = pAmp[n];				// 二乗振幅
		int gray = (i >> 1) ^ i;		// グレーコードに変換
        int mask = m_MFSK_TONES >> 1;
		dp = tVal;
		for( n = 0; n < m_MFSK_BITS; n++, mask = mask >> 1, dp++ ){
			if( gray & mask ){
				*dp += v;
			}
			else {
				*dp -= v;
			}
		}
		sum += v;
	}
	sum = 128.0 / sum;
	dp = tVal;
    BYTE *bp = tSym;
	for(i = 0; i < m_MFSK_BITS; i++){
		*bp++ = Limit256(128.0 + (sum * *dp++));
	}
	m_InterLeaver.DecodeSyms(tSym);
	bp = tSym;
	for(i = 0; i < m_MFSK_BITS; i++) StreamSym(*bp++);
}

//--------------------------------------------------------------------------
BYTE __fastcall CDecMFSK::DecodeSym(CLX *pFFT, double *pAmp)
{
	int sym = 0;
	double d;
    double max = 0.0;

	for( int i = 0; i < m_MFSK_TONES; i++ ){
		*pAmp++ = d = pFFT[i].vAbs();
		if( d > max ){
			max = d;
			sym = i;
		}
	}
	return BYTE(sym);
}

//--------------------------------------------------------------------------
void __fastcall CDecMFSK::DoSync(void)
{
/*
	１つ前のシンボルの最大振幅位置を得る

	m_dBTW = 7, m_AmpStgMax = 14
	   v				= m_AmpStgPtr
	22220001111111		= m_AmpStg[]
	<--i<---------		i = 0 to 13
    3210dcba987654
	          N
*/
    int N = 0;
	double max = 0.0;
	double *pAmp = &m_AmpStg[m_AmpStgPtr][m_SymStg[1]];
	for(int i = 0; i < m_AmpStgMax; i++){
		if( pAmp < m_AmpStg[0] ){
			pAmp = &m_AmpStg[m_AmpStgMax-1][m_SymStg[1]];
        }
		if( *pAmp > max){
			N = i;
			max = *pAmp;
		}
        pAmp -= MFSK_MAXTONES;
	}
	// カウンタを補正する
	m_dNow += (N - m_dTW) * 0.125;

    // タイミング計測の開始
	if( m_MeasStage < 16 ){
    	m_MeasStage++;
	   	m_MeasClock = m_MeasCounter = 0;
        m_SyncState = FALSE;
    }
    else {
		m_SyncState = (fabs(m_dNow) < (m_dTW * 0.05));
    }
//	char bf[256];
//    sprintf(bf, "%.1lf", m_dNow);
//	Application->MainForm->Caption = bf;
}

//--------------------------------------------------------------------------
void __fastcall CDecMFSK::DoMeas(void)
{
	if( m_MeasStage ){
		m_MeasClock++;
		if( m_MeasClock >= 128 ){
			m_AvgClock.Do(double(m_MeasCounter)/double(m_MeasClock));
		   	m_MeasClock = m_MeasCounter = 0;

       		// ATC処理
			if( IsMetSQ() ){
				DoAvg(m_dTW, m_AvgClock.GetAvg(), (m_AvgMetric >= 200) ? 0.8 : 0.4);
				if( m_dTW < m_dBTWL ){ m_dTW = m_dBTWL; }
       	        if( m_dTW > m_dBTWH ){ m_dTW = m_dBTWH; }
            }
			else {
				DoAvg(m_dTW, m_dBTW, 0.25);
			}
        }
	}
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::DoAFC(CLX *pFFT)
{
	// ３シンボル連続で同じ周波数
	if( (m_SymStg[2] != m_SymStg[1]) || (m_SymStg[2] != m_SymStg[0]) ) return;
	// ベーストーンのみを検出する
	if( m_fLSB ){
		if( m_SymStg[2] != (m_MFSK_TONES - 1) ) return;
    }
    else {
		if( m_SymStg[2] != 0 ) return;
    }

	int err = GetClockError();
	if( ABS(err) >= 2000 ) return;	// ATC補正が大きい時は誤差も大きい

	CLX		z;
	pFFT += m_SymStg[2];
	pFFT->PhDiff(z, m_PrevZ);			// 位相差のみ必要なので分母の計算は不要
	double ferr = z.Phase() * m_kAFC;	// 位相差を周波数偏差に変換
	if( (ferr > -m_AFCWidth) && (ferr < m_AFCWidth) ){
		m_AvgAFC.DoZ(ferr);
    }

#if 0
	double d = pFFT->Phase() - m_PrevZ.Phase();
    d += fmod(2*PI*(m_dBTW-m_dTW), 2*PI);
	if( d >= PI ){d = d - PI*2;} else if( d <= -PI ){d = d + PI*2;}
    d *= m_kAFC;
	char bf[256];
	sprintf(bf, "%.2lf %.2lf %.2lf", d, ferr, m_dBTW-m_dTW);
    Application->MainForm->Caption = bf;
#endif
}
//--------------------------------------------------------------------------
BOOL __fastcall CDecMFSK::GetAFCShift(double &fq)
{
	if( m_AvgAFC.IsFull() ){
		fq = m_AvgAFC.GetAvg();
        m_AvgAFC.Reset();
        return TRUE;
    }
    else {
		return FALSE;
    }
}
//--------------------------------------------------------------------------
#define DEBUG_MFSK	FALSE
#if DEBUG_MFSK
FILE *pMFSKFP = fopen("test.txt", "wt");
#endif
//--------------------------------------------------------------------------
int __fastcall CDecMFSK::Do(CLX *pFFT, BOOL fSQ)
{
    BOOL f = FALSE;

	if( m_AmpStgPtr >= m_AmpStgMax ) m_AmpStgPtr = 0;
	m_SymStg[2] = DecodeSym(pFFT, m_AmpStg[m_AmpStgPtr]);

	m_MeasCounter++;
	m_dNow += 1.0;
	if( m_dNow >= m_dTW ){
		m_dNow -= m_dTW;
		m_Tmg = !m_Tmg;
		if( fSQ ) DoMeas();

#if DEBUG_MFSK
		if( fSQ ) fprintf(pMFSKFP, "%02X\n", m_SymStg[2]);
#endif

		// 遅延スケルチ処理
        if( m_fSQ != fSQ ){
			m_fSQ = fSQ;
			if( !sys.m_MFSK_SQ_Metric ){
	            m_SQDelayCount = 32;
            }
		    ResetMeas();
        }
        else if( m_SQDelayCount ){
			m_SQDelayCount--;
            if( !m_SQDelayCount ){
				m_fDelaySQ = m_fSQ;
            }
        }
		RecSym(m_AmpStg[m_AmpStgPtr]);
		// シンボルが2回連続で変化した場合のみ同期位置を計算
		if( (m_SymStg[2] != m_SymStg[1]) && (m_SymStg[0] != m_SymStg[1]) ){
			DoSync();
        }
		if( fSQ ) DoAFC(pFFT);
		m_PrevZ = pFFT[m_SymStg[2]];
		memcpy(m_SymStg, &m_SymStg[1], 2 * sizeof(m_SymStg[0]));
        f = TRUE;
	}
	m_AmpStgPtr++;
	return f;
}

//--------------------------------------------------------------------------
int __fastcall CDecMFSK::GetData(void)
{
	if( m_RxData.GetCount() ){
		return m_RxData.GetData();
    }
    else {
		return -1;
    }
}
//--------------------------------------------------------------------------
int __fastcall CDecMFSK::GetClockError(void)
{
	if( m_AvgClock.GetCount() ){
//		double tw = (m_MeasStage >= 2) ? m_dTW : m_AvgClock.GetAvg();
		return ((m_dTW / m_dBTW) - 1.0) * 1e6;
    }
    else {
		return 0;
    }
}
//--------------------------------------------------------------------------
void __fastcall CDecMFSK::SetTmg(int ppm)
{
	if( ppm < -15000 ) ppm = -15000;
    if( ppm > 15000 ) ppm = 15000;

	m_dBTW = m_SampleFreq / m_MFSK_SPEED;
	m_dTW = m_dBTW = m_dBTW + (m_dBTW * ppm * 1.0e-6);
}
//--------------------------------------------------------------------------
// 0 to 2048
int __fastcall CDecMFSK::GetMetric(int sw)
{
	double d;
	switch(sw){
		case 1:
        	d = m_Metric2;
            break;
		case 2:
        	d = m_Metric1;
            break;
        default:
        	d = m_AvgMetric;
            break;
    }
	if( d < 80.0 ){
		d = (d - 80.0) * 2.0 + 80.0;
        if( d < 0.0 ) d = 0.0;
    }
    else if( d >= 200.0 ){
		d = 200.0 + (d - 200.0) * ((512.0-200.0) / (256.0-200.0));
    }
    return int(d*4.0);
}
/*=============================================================================
  CPlayBackクラス
=============================================================================*/
__fastcall CPlayBack::CPlayBack()
{
	m_StgWidth = 0;
    m_StgMax = 0;
    m_pStg = NULL;
    Clear();
}
//--------------------------------------------------------------------------
__fastcall CPlayBack::~CPlayBack()
{
	if( m_pStg ) delete m_pStg;
}
//--------------------------------------------------------------------------
void __fastcall CPlayBack::Delete(void)
{
	m_StgMax = 0;
    m_StgWidth = 0;
    if( m_pStg ){
		delete m_pStg;
        m_pStg = NULL;
    }
}
//--------------------------------------------------------------------------
void __fastcall CPlayBack::Init(int wSize, int SampBase)
{
	m_StgWidth = wSize;
    m_StgMax = (SampBase * 60.0 / wSize) + 0.5;
	int wmax = m_StgMax * wSize;
    if( m_pStg ) delete m_pStg;
	m_pStg = new short[wmax];
    Clear();
}
//--------------------------------------------------------------------------
void __fastcall CPlayBack::Clear(void)
{
	m_StgCnt = m_StgRCnt = 0;
    m_StgW = m_StgR = 0;
    m_WTimer = 0;
}
//--------------------------------------------------------------------------
void __fastcall CPlayBack::Write(const short *p)
{
	if( m_StgRCnt ) return;
	if( m_WTimer ){
		m_WTimer--;
        return;
    }
	memcpy(&m_pStg[m_StgW*m_StgWidth], p, sizeof(short)*m_StgWidth);
    m_StgW++;
    if( m_StgW >= m_StgMax ) m_StgW = 0;
    if( m_StgCnt < m_StgMax ) m_StgCnt++;
}
//--------------------------------------------------------------------------
BOOL __fastcall CPlayBack::Read(short *p)
{
	if( !m_StgRCnt ) return FALSE;

	memcpy(p, &m_pStg[m_StgR*m_StgWidth], sizeof(WORD)*m_StgWidth);
   	m_StgR++;
    if( m_StgR >= m_StgMax ) m_StgR = 0;
    m_StgRCnt--;
    return TRUE;
}
//--------------------------------------------------------------------------
void __fastcall CPlayBack::StopPlaying(void)
{
    m_StgRCnt = 0;
}
//--------------------------------------------------------------------------
BOOL __fastcall CPlayBack::StartPlaying(int s)
{
	if( !m_StgCnt ) return FALSE;

	m_WTimer = m_StgMax * 3 / 60;
	m_StgRCnt = m_StgMax * s / 60;
    if( m_StgRCnt > m_StgCnt ) m_StgRCnt = m_StgCnt;
    m_StgR = m_StgW - m_StgRCnt;
	if(m_StgR < 0) m_StgR += m_StgMax;
    return m_StgRCnt;
}

/*=============================================================================
  CDelayクラス
=============================================================================*/
//---------------------------------------------------------------------------
__fastcall CDelay::CDelay(void)
{
	m_pStg = NULL;
    m_Delay = 0;
    m_CurPnt = 0;
    m_Count = 0;
}
//---------------------------------------------------------------------------
__fastcall CDelay::~CDelay()
{
	if( m_pStg ) delete m_pStg;
}
//---------------------------------------------------------------------------
void __fastcall CDelay::Create(int delay)
{
	if( !m_pStg || (m_Delay != delay) ){
		if( m_pStg ) delete m_pStg;
        m_pStg = new double[delay];
    }
    m_Delay = delay;
    Reset();
}
//---------------------------------------------------------------------------
void __fastcall CDelay::Reset(void)
{
	memset(m_pStg, 0, sizeof(double)*m_Delay);
    m_CurPnt = 0;
    m_Count = 0;
}
//---------------------------------------------------------------------------
double __fastcall CDelay::Do(const double &d)
{
	double *cp = &m_pStg[m_CurPnt];
    double r = *cp;
    *cp = d;
    m_CurPnt = CIRCULATE(m_CurPnt+1, m_Delay);
    if( m_Count < m_Delay ) m_Count++;
    return r;
}
//---------------------------------------------------------------------------
double __fastcall CDelay::GetData(void)
{
	return m_pStg[m_CurPnt];
}
/*=============================================================================
  CCICクラス
=============================================================================*/
//---------------------------------------------------------------------------
__fastcall CCIC::CCIC(void)
{
	m_N = 0;
    m_K = 0;
}

//---------------------------------------------------------------------------
void __fastcall CCIC::Create(int n)
{
	m_N = n;
    m_K = 1.0 / double(n);

    m_Com.Create(n);
    m_Z = 0;
}

//---------------------------------------------------------------------------
double __fastcall CCIC::Do(double d)
{
	d -= m_Com.Do(d);
	d += m_Z;
	m_Z = d;
    return d * m_K;
}
/*=============================================================================
  CCICMクラス
=============================================================================*/
//---------------------------------------------------------------------------
__fastcall CCICM::CCICM(void)
{
	m_N = 0;
}
//---------------------------------------------------------------------------
__fastcall CCICM::~CCICM(void)
{
}
//---------------------------------------------------------------------------
void __fastcall CCICM::Create(int stages, int N)
{
	m_N = stages;
	for( int i = 0; i < stages; i++ ){
		m_tCIC[i].Create(N);
    }

}
//---------------------------------------------------------------------------
double __fastcall CCICM::Do(double d)
{
	CCIC *cp = m_tCIC;
	for( int i = 0; i < m_N; i++, cp++ ){
		d = cp->Do(d);
    }
    return d;
}
/*=============================================================================
  CNotchesクラス
=============================================================================*/
//---------------------------------------------------------------------------
__fastcall CNotches::CNotches(void)
{
	m_nBaseTaps = 128;
    m_NotchWidth = 1;
	m_Count = m_Max = 0;
    m_pBase = NULL;
    m_SampleFreq = SAMPFREQ;
}
//---------------------------------------------------------------------------
__fastcall CNotches::~CNotches()
{
	Delete();
}
//---------------------------------------------------------------------------
void __fastcall CNotches::Delete(void)
{
	if( m_pBase ){
    	delete m_pBase;
        m_pBase = NULL;
    }
    m_Count = m_Max = 0;
    m_FIR.Delete();
}
//---------------------------------------------------------------------------
void __fastcall CNotches::Create(void)
{
	if( m_Count ){
		if( m_Count == 1 ){		// シングルノッチ
			m_nTaps = m_nBaseTaps * m_SampleFreq / 11025;
    	    m_nTaps = (m_nTaps + 1) & 0x0ffe;
			if( m_nTaps < 4 ) m_nTaps = 4;
			double fl = m_pBase[0].Freq - m_NotchWidth;
			double fh = m_pBase[0].Freq + m_NotchWidth;
        	int att = m_NotchWidth > 50 ? 60 : 10;
			if( fl < 100.0 ){
				m_FIR.Create(m_nTaps, ffHPF, m_SampleFreq, fh, fh, 60, 1.0);
    	    }
	        else if( (fh > sys.m_MaxCarrier) && (m_NotchWidth >= 10) ){
				m_FIR.Create(m_nTaps, ffLPF, m_SampleFreq, fl, fl, 60, 1.0);
			}
	        else {
				m_FIR.Create(m_nTaps, ffBEF, m_SampleFreq, fl, fh, att, 1.0);
        	}
        }
        else {					// マルチノッチ
			m_nTaps = m_nBaseTaps * 1.5 * m_SampleFreq / 11025;
    	    m_nTaps = (m_nTaps + 1) & 0x0ffe;
			if( m_nTaps < 4 ) m_nTaps = 4;
            int e = m_nTaps / 2;
			double *pSamp = new double[e];
            double w = m_SampleFreq / m_nTaps;
            if( w > 30.0 ) w = 30.0;
            double bw = m_NotchWidth;
            if( bw < w ) bw = w;
		    for( int i = 0; i < e; i++ ){
				double fq = i * m_SampleFreq / m_nTaps;
				double gm = 1.0;
			    for( int j = 0; j < m_Count; j++ ){
					double g = fq - m_pBase[j].Freq;
			        g = fabs(g);
			        g = g * 0.5 / bw;
			        g *= g;
			        if( g < gm ) gm = g;
			    }
                pSamp[i] = gm;
		    }
            m_FIR.CreateSamp(m_nTaps, m_SampleFreq, pSamp);
            delete pSamp;
        }
    }
}
//---------------------------------------------------------------------------
void __fastcall CNotches::Alloc(int nIndex)
{
	if( nIndex >= m_Max ){
		int max = m_Max ? m_Max * 2 : 32;
        NOTCHCTR *pNew = new NOTCHCTR[max];
        if( m_Count ) memcpy(pNew, m_pBase, m_Count * sizeof(NOTCHCTR));
        if( m_pBase ) delete m_pBase;
        m_pBase = pNew;
        m_Max = max;
    }
}
//---------------------------------------------------------------------------
int __fastcall CNotches::Find(int Freq)
{
	for( int i = 0; i < m_Count; i++ ){
		if( m_pBase[i].Freq == Freq ) return i;
    }
    return -1;
}
//---------------------------------------------------------------------------
void __fastcall CNotches::Add(int Freq)
{
	if( Find(Freq) >= 0 ) return;

	Alloc(m_Count);
    m_pBase[m_Count].Freq = short(Freq);
    m_pBase[m_Count].m_MX = 0;
    m_pBase[m_Count].m_MY = 0;
    m_Count++;
    Create();
}
//---------------------------------------------------------------------------
void __fastcall CNotches::SetFreq(int nIndex, int Freq)
{
	if( nIndex < m_Count ){
		if( m_pBase[nIndex].Freq != Freq ){
			m_pBase[nIndex].Freq = Freq;
    	    Create();
        }
    }
}
//---------------------------------------------------------------------------
void __fastcall CNotches::Delete(int nIndex)
{
	if( (nIndex < 0) || (nIndex >= m_Count) ) return;

	NOTCHCTR *np = &m_pBase[nIndex];
    int size = sizeof(NOTCHCTR)*(m_Count-nIndex-1);
	if( size > 0 ) memcpy(np, np+1, size);
    m_Count--;
	if( m_Count ){
	    Create();
    }
    else {
		Delete();
    }
}
/*=============================================================================
  CPHASEXクラス Added by JE3HHT on Sep.2010 for FFT RTTY demodulator
=============================================================================*/
__fastcall CPHASEX::CPHASEX()
{
	m_TONES = 4;
	m_SHIFT = 170.0;
	m_SampleFreq = 11025.0*0.5;
    m_CarrierFreq = 1750;
    SetSampleFreq(m_SampleFreq);
}
//--------------------------------------------------------------------------
void __fastcall CPHASEX::ShowPara(void)
{
/*
	if( Application->MainForm ){
		char bf[256];
	    sprintf(bf, "Car=%.lf, Shift=%.lf, Syms=%.lf, Tones=%d", m_CarrierFreq, m_SHIFT, m_SymbolLen, m_TONES);
		Application->MainForm->Caption = bf;
    }
*/
}
//--------------------------------------------------------------------------
void __fastcall CPHASEX::SetSampleFreq(double f)
{
	m_SampleFreq = f;
    Create();
}
//--------------------------------------------------------------------------
void __fastcall CPHASEX::Create(void)
{
//	m_fftSHIFT = m_SHIFT * (m_TONES + 1) / m_TONES;
	m_fftSHIFT = m_SHIFT * m_TONES / (m_TONES - 1);
	m_SymbolLen = m_TONES * m_SampleFreq / m_fftSHIFT;
    m_BASEPOINT = int(CPHASEX_BASEFREQ * m_TONES / m_fftSHIFT);

	m_MixerFreq = double(m_BASEPOINT) * m_SampleFreq / m_SymbolLen;
	m_VCO.SetSampleFreq(m_SampleFreq);
	m_Hilbert.Create(20, m_SampleFreq, 25.0, m_SampleFreq*0.5 - 25.0);
    m_Hilbert.Clear();
    SetCarrierFreq(m_CarrierFreq);
    m_SlideFFT.Create(int(m_SymbolLen + 0.5), m_BASEPOINT, m_TONES);
	m_AGC.SetSampleFreq(m_SampleFreq);
	m_AGC.SetCarrierFreq(m_CarrierFreq);
//	CreateFilter();
#if LOGFFT
    m_fp = fopen("FFT.txt", "wt");
#endif
//	ShowPara();
}
//--------------------------------------------------------------------------
void __fastcall CPHASEX::SetShift(double f)
{
	m_SHIFT = f;
    Create();
}
//--------------------------------------------------------------------------
void __fastcall CPHASEX::SetCarrierFreq(double f)
{
	m_CarrierFreq = f;
    m_VCO.SetFreeFreq(m_CarrierFreq - m_MixerFreq);
	m_AGC.SetCarrierFreq(m_CarrierFreq);
//	ShowPara();
}
//--------------------------------------------------------------------------
CLX* __fastcall CPHASEX::Do(double d)
{
	m_Hilbert.Do(m_sig, d);					// 複素数化

    CLX z;
	z.r = m_VCO.Do();
    z.j = m_VCO.DoCos();
	z *= m_sig;								// 周波数変換

//    m_LPF.Do(z);
	return m_SlideFFT.Do(z);
}
//--------------------------------------------------------------------------
void __fastcall CPHASEX::DoFSK(double d)
{
//	d = m_AGC.Do(d);
	CLX *pFFT = Do(d);
    m_dm = pFFT[0].vAbs() * (1.0 / 32768.0);
    m_ds = pFFT[m_TONES-1].vAbs() * (1.0 / 32768.0);

#if LOGFFT
    for( int i = 0; i < m_TONES; i++ ){
		if( i ) fprintf(m_fp, ",");
		fprintf(m_fp, "%.0lf", pFFT[i].vAbs());
    }
    fprintf(m_fp, "\n");
#endif
}
/*=============================================================================
 CViterbiQPSKクラス Added by JE3HHT on Sep.2010 for QPSK demodulator
=============================================================================*/
CViterbiQPSK::CViterbiQPSK(void)
{
	Reset();
}
//---------------------------------------------------------------------------
void __fastcall CViterbiQPSK::Reset(void)
{
	memset(m_tPath, 0, sizeof(m_tPath));
    memset(m_tBit, 0, sizeof(m_tBit));
}
//---------------------------------------------------------------------------
BOOL __fastcall CViterbiQPSK::Do(double angle, double *pMetric)
{
	double dist[32];
	int	   bits[32];
	double min = MAXDOUBLE;

	int i;
	if( pMetric ){
		for(i = 0; i < 32; i++){
			dist[i] = m_tPath[i/2] + pMetric[tQPSK_Viterbi[i]];
			if(dist[i] < min) min = dist[i];
			bits[i] = ((m_tBit[i/2]) << 1) + (i & 1);
		}
	}
	else {
		const double tt1[4] = {3.0*PI/2.0, 0.0, PI/2.0, PI};
		const double tt2[4] = {3.0*PI/2.0, PI*2.0, PI/2.0, PI};
		const double* pTbl = (angle >= PI) ? tt2 : tt1;
		for(i = 0; i < 32; i++){
			dist[i] = m_tPath[i/2] + fabs(angle - pTbl[tQPSK_Viterbi[i]]);
			if( dist[i] < min ) min = dist[i];
			bits[i] = ((m_tBit[i/2]) << 1) + (i & 1);
		}
	}
	for(i = 0; i < 16; i++){
		if( dist[i] < dist[i + 16]){
			m_tPath[i] = dist[i] - min;
			m_tBit[i] = bits[i];
		}
		else {
			m_tPath[i] = dist[i + 16] - min;
			m_tBit[i] = bits[i + 16];
		}
	}
	int ones = 0;
	for(i = 0; i < 16; i++){
		ones += (m_tBit[i] & (1L << 20));
	}
	if( ones == (8 << 20 ) ){
		return rand() & 1;
	}
	else {
		return ones > (8L << 20);
    }
}
/*=============================================================================
 CDecPSKクラス Added by JE3HHT on Sep.2010 for QPSK demodulator
=============================================================================*/
__fastcall CDecPSK::CDecPSK(void)
{
	m_fLSB = FALSE;
    m_bQPSK = TRUE;
	m_bATC = TRUE;

	m_CarrierFreq = 1750.0;
	m_Angle = 0.0;
	m_Speed = 31.25;
	m_SHDATA = 0;

	m_SN = 0;
	m_dNow = 0;

	m_Tmg = m_SyncState = 0;

    m_RxData.Clear();

	m_fSQ = FALSE;

	m_AvgClock.Create(8);
    SetSampleFreq(11025*0.5);
}
//---------------------------------------------------------------------------
__fastcall CDecPSK::~CDecPSK(void)
{
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::SetCarrierFreq(double f)
{
	m_CarrierFreq = f;
    m_NextCarrierFreq = f;
    m_VCO.SetFreeFreq(f);
	m_dblAvgAFC = 0.0;
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::Reset(void)
{
	m_SHDATA = 0;
	m_SN = 0;

    m_dNow = 0;
	m_dTW = m_dBTW = m_SampleFreq / m_Speed;
    m_dBTWL = m_dBTW * (1.0-(15000.0 * 1.0e-6));
    m_dBTWH = m_dBTW * (1.0+(15000.0 * 1.0e-6));
	m_iW = int(m_dTW / QPSK_SUBFACTOR);
	m_iWM = m_iW/2;

	memset(m_AmpStg, 0, sizeof(m_AmpStg));

	memset(m_StgZ, 0, sizeof(m_StgZ));
    m_Viterbi.Reset();

    m_RxData.Clear();

	m_SyncState = FALSE;

	m_fSQ = FALSE;

	int taps = int(m_SampleFreq * 64.0 * 2.0 / 11025.0 + 0.5) & 0x7ffe;
    m_LPF1.Create(taps, ffLPF, m_SampleFreq, m_Speed*2.0, m_Speed*2.0, 60.0, 1.0);
	taps = int(m_SampleFreq * 8 * 160 / (QPSK_SUBFACTOR * 11025) + 0.5) & 0x7ffe;
    m_LPF2.Create(taps, ffLPF, m_SampleFreq/double(QPSK_SUBFACTOR), m_Speed*QPSK_LPF2K, m_Speed*QPSK_LPF2K, 60.0, 1.0);

	m_dblAvgAFC = 0.0;
    m_vAvg = 32768.0;
    ResetATC();
}
//--------------------------------------------------------------------------
// 送信に切り替える際に呼ばれる
void __fastcall CDecPSK::ResetRX(void)
{
    m_dNow = 0;
	memset(m_AmpStg, 0, sizeof(m_AmpStg));
	memset(m_StgZ, 0, sizeof(m_StgZ));
	m_dblAvgAFC = 0.0;
    m_vAvg = 32768.0;
    m_SHDATA = 0;
	m_Viterbi.Reset();
    m_RxData.Clear();
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::SetSpeed(double d)
{
	m_Speed = d;
	Reset();
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::SetSampleFreq(double f)
{
	m_SampleFreq = f;
	m_dTW = m_dBTW = m_SampleFreq / m_Speed;
	m_iW = int(m_dTW / QPSK_SUBFACTOR);
	m_iWM = m_iW/2;
	memset(m_AmpStg, 0, sizeof(m_AmpStg));

	m_VCO.SetSampleFreq(m_SampleFreq);
	m_Hilbert.Create(20, m_SampleFreq, 25.0, m_SampleFreq*0.5 - 25.0);
    m_Hilbert.Clear();
    SetCarrierFreq(m_CarrierFreq);
	Reset();
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::ResetATC(void)
{
    m_AvgClock.Reset();
    m_MeasClock = m_MeasCounter = m_MeasStage = 0;
    m_dTW = m_dBTW;
	m_iW = int(m_dTW / QPSK_SUBFACTOR);
	m_iWM = m_iW/2;
    m_SN = 0;
};
//---------------------------------------------------------------------------
void __fastcall CDecPSK::RxBit(int bit)
{
	m_SHDATA = m_SHDATA << 1;
    if( bit ) m_SHDATA |= 1;

	if( !(m_SHDATA & 3) ){
		if( m_fSQ ) m_RxData.PutData(g_VariCode.Decode(m_SHDATA >> 2));
		m_SHDATA = 0;
	}
}
//---------------------------------------------------------------------------
double __fastcall vPWR(const double &c){
	return c * c;
}
void __fastcall CDecPSK::DoSym(const CLX &z)
{
	m_StgZ[3] = m_StgZ[2];
    m_StgZ[2] = m_StgZ[1];
    m_StgZ[1] = m_StgZ[0];
	m_StgZ[0] = z;

	double max, v;
	max = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].j);
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	m_Metric[QPSK_ROT_0] = max;

	max = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].j);
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].r);
	if( v > max ) max = v;
	m_Metric[QPSK_ROT_180] = max;

	max = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].j);
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	m_Metric[QPSK_ROT_270] = max;

	max = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].j);
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].r) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].j);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r - m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j + m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j - m_StgZ[1].r - m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r + m_StgZ[1].j - m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].r + m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].j - m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j - m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r - m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	v = vPWR(m_StgZ[3].j + m_StgZ[2].j + m_StgZ[1].r + m_StgZ[0].j) + vPWR(m_StgZ[3].r + m_StgZ[2].r - m_StgZ[1].j + m_StgZ[0].r);
	if( v > max ) max = v;
	m_Metric[QPSK_ROT_90] = max;

	int i;
	max = m_Metric[0];
	for( i = 0; i < 4; i++ ){
		if(m_Metric[i] > max) max = m_Metric[i];
	}
    if( max > 0.0 ){
		for( i = 0; i < 4; i++ ){
			m_Metric[i] = -log10(m_Metric[i]/max + 1.0E-100);
		}
    }

	if( m_bQPSK && m_fLSB ){		// 回転方向を逆転
		double d = m_Metric[QPSK_ROT_90];
		m_Metric[QPSK_ROT_90] = m_Metric[QPSK_ROT_270];
		m_Metric[QPSK_ROT_270] = d;
    }

	if( m_bQPSK && m_fLSB ){
		m_Angle = PI + ATAN2( (m_StgZ[1].j*m_StgZ[0].j + m_StgZ[1].r*m_StgZ[0].r), (m_StgZ[0].j*m_StgZ[1].r - m_StgZ[1].j*m_StgZ[0].r));
    }
	else {
		m_Angle = PI + ATAN2( (m_StgZ[1].j*m_StgZ[0].j + m_StgZ[1].r*m_StgZ[0].r), (m_StgZ[1].j*m_StgZ[0].r - m_StgZ[0].j*m_StgZ[1].r));
    }

    m_Bits = m_Viterbi.Do(m_Angle, m_Metric);
	RxBit(m_Bits);
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::DoAFC(void)
{
//	if( m_SN < 1500 ) return;
	if( m_SN < 1200 ) return;

	double deg = m_Angle;
    if( deg < 0.0 ) deg += 2*PI;

	double w;
	if( deg < (PI/4) ){						// ROT 0
		w = deg;
    }
    else if( deg < (PI/4 + PI/2) ){			// ROT 90
		w = deg - PI/2;
    }
    else if( deg < (PI/4 + PI) ){			// ROT 180
		w = deg - PI;
    }
    else if( deg < (PI/4 + PI + PI/2) ){	// ROT 270
		w = deg - PI - PI/2;
    }
    else {									// ROT 0
		w = deg - (2*PI);
    }
	double err = w * m_SampleFreq / (2 * PI * QPSK_SUBFACTOR * m_Speed);
	DoAvg(m_dblAvgAFC, err, (m_SN > 2000) ? 0.025 : 0.0125);
	if( m_fLSB ){
		m_NextCarrierFreq = m_CarrierFreq - m_dblAvgAFC * 0.25;
    }
    else {
		m_NextCarrierFreq = m_CarrierFreq + m_dblAvgAFC * 0.25;
    }
/*
	char bf[32];
    sprintf(bf, "SN=%u, %.03lf", m_SN, m_dblAvgAFC);
    Application->MainForm->Caption = bf;
*/
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::DoATC(BOOL fATC)
{
	if( m_MeasStage >= 7 ){
        m_SyncState = TRUE;
		m_MeasClock++;
		if( m_MeasClock >= 64 ){
			if( m_MeasStage >= 8 ){
				m_AvgClock.Do(double(m_MeasCounter)/double(m_MeasClock));
/*
					char bf[256];
					sprintf(bf, "%.3lf, %.3lf, %.3lf", m_dBTW, double(m_MeasCounter)/double(m_MeasClock), m_AvgClock.GetAvg());
					Application->MainForm->Caption = bf;
*/
	       		// ATC処理
				if( m_bATC && fATC ){
					DoAvg(m_dTW, m_AvgClock.GetAvg(), m_SN > 2000 ? 0.5 : 0.25);
					if( m_dTW < m_dBTWL ){ m_dTW = m_dBTWL; }
	    		    if( m_dTW > m_dBTWH ){ m_dTW = m_dBTWH; }
					m_iW = int(m_dTW / QPSK_SUBFACTOR);
					m_iWM = m_iW/2;
	            }
			}
            else {
				m_MeasStage++;
            }
		   	m_MeasClock = m_MeasCounter = 0;
        }
	}
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::DoSync(CLX &z)
{
	int N = int(m_dNow / QPSK_SUBFACTOR);
	if( N < 0 ) N += m_iW;
    if( N >= m_iW ) N -= m_iW;
	m_AmpStg[N] = z.vAbs();

	float psum = 0.0;
    float msum = 0.0;
	float *p = m_AmpStg;
    float *t = p + m_iWM;
	for( N = 0; N < m_iWM; N++, p++, t++ ){
		msum += *p - *t;
		psum += *p + *t;
    }
	if( psum > 0.0 ){
		msum /= psum;
		m_dNow -= msum * QPSK_SUBFACTOR * 0.2;
    }

    // タイミング計測の開始
	if( m_MeasStage < 7 ){
    	m_MeasStage++;
        m_SyncState = FALSE;
    }
}
//---------------------------------------------------------------------------
int __fastcall CDecPSK::Do(double d, BOOL fSQ, BOOL fATC)
{
	m_Hilbert.Do(m_sig, d);					// 複素数化

    CLX z;
	z.r = m_VCO.Do();
    z.j = m_VCO.DoCos();
	z *= m_sig;								// 周波数変換

	m_LPF1.Do(z);							// デシメータ

	m_MeasCounter++;
	m_nSubCounter--;
	if( m_nSubCounter <= 0 ){				// サブサンプリング
		m_nSubCounter = QPSK_SUBFACTOR;

		m_LPF2.Do(z);
		m_Z = z;

		if( fSQ ) DoSync(z);

		m_dNow += QPSK_SUBFACTOR;
		if( m_dNow >= m_dTW ){
			m_dNow -= m_dTW;
			m_Tmg = !m_Tmg;

			if( m_fSQ != fSQ ){
				m_fSQ = fSQ;
				m_dblAvgAFC = 0.0;
                ResetATC();
            }
			DoSym(z);
			if( fSQ ){
				DoATC(fATC);
				DoAFC();
		    }
			return TRUE;
		}
	}
	return FALSE;
}
//--------------------------------------------------------------------------
int __fastcall CDecPSK::GetData(void)
{
	if( m_RxData.GetCount() ){
		return m_RxData.GetData();
    }
    else {
		return -1;
    }
}
//--------------------------------------------------------------------------
int __fastcall CDecPSK::GetClockError(void)
{
	if( m_AvgClock.GetCount() ){
		return ((m_dTW / m_dBTW) - 1.0) * 1e6;
    }
    else {
		return 0;
    }
}
//--------------------------------------------------------------------------
void __fastcall CDecPSK::SetTmg(int ppm)
{
	if( ppm < -15000 ) ppm = -15000;
    if( ppm > 15000 ) ppm = 15000;

	m_dBTW = m_SampleFreq / m_Speed;
	m_dTW = m_dBTW = m_dBTW + (m_dBTW * ppm * 1.0e-6);
	m_iW = int(m_dTW / QPSK_SUBFACTOR);
    m_iWM = m_iW / 2;
}
//--------------------------------------------------------------------------
int __fastcall CDecPSK::GetD(void)
{
	double d = m_Z.vAbs();
	DoAvg(m_vAvg, d, 0.001);
	if( m_vAvg > 0.0 ){
		d /= m_vAvg;
		d *= 20000.0;
	}
	if( d > 40000.0 ) d = 40000.0;
   	return d - 20000.0;
}

//--------------------------------------------------------------------------