diff --git a/demod/mod/demod_mod.c b/demod/mod/demod_mod.c
index 9123e46..df038c9 100644
--- a/demod/mod/demod_mod.c
+++ b/demod/mod/demod_mod.c
@@ -145,9 +145,12 @@ static int getCorrDFT(dsp_t *dsp) {
     float re_cx = 0.0;
     float xnorm = 1;
     ui32_t mpos = 0;
-
     ui32_t pos = dsp->sample_out;
 
+    double dc = 0.0;
+    int mp_ofs = 0;
+    float *sbuf = dsp->bufs;
+
     dsp->mv = 0.0;
     dsp->dc = 0.0;
 
@@ -155,21 +158,38 @@ static int getCorrDFT(dsp_t *dsp) {
     if (dsp->sample_out < dsp->L) return -2;
 
 
-    dsp->dc = get_bufmu(dsp, pos - dsp->sample_out); //oder unten: dft_dc = creal(X[0])/(K+L);
-    // wenn richtige Stelle (Varianz pruefen, kein M10-carrier?), dann von bufs[] subtrahieren
-
-
-    for (i = 0; i < dsp->K + dsp->L; i++) (dsp->DFT).xn[i] = dsp->bufs[(pos+dsp->M -(dsp->K + dsp->L-1) + i) % dsp->M];
+    if (dsp->opt_iq > 1 && dsp->opt_dc) {
+        mp_ofs = (dsp->sps-1)/2;
+        sbuf = dsp->fm_buffer;
+    }
+    else {
+        sbuf = dsp->bufs;
+    }
+    for (i = 0; i < dsp->K + dsp->L; i++) (dsp->DFT).xn[i] = sbuf[(pos+dsp->M -(dsp->K + dsp->L-1) + i) % dsp->M];
     while (i < dsp->DFT.N) (dsp->DFT).xn[i++] = 0.0;
 
+
     rdft(&dsp->DFT, dsp->DFT.xn, dsp->DFT.X);
 
-    // dft_dc = creal(dsp->DFT.X[0])/dsp->DFT.N;
+
+    if (dsp->opt_dc) {
+        //X[0] = 0; // nicht ueber gesamte Laenge ... M10
+        //
+        // L < K ?  // only last 2L samples (avoid M10 carrier offset)
+        dc = 0.0;
+        for (i = dsp->K - dsp->L; i < dsp->K + dsp->L; i++) dc += (dsp->DFT).xn[i];
+        dc /= 2.0*(float)dsp->L;
+        dsp->DFT.X[0] -= dsp->DFT.N * dc  ;//* 0.95;
+        Nidft(&dsp->DFT, dsp->DFT.X, (dsp->DFT).cx);
+        for (i = 0; i < dsp->DFT.N; i++) (dsp->DFT).xn[i] = creal((dsp->DFT).cx[i])/(float)dsp->DFT.N;
+    }
 
     for (i = 0; i < dsp->DFT.N; i++) dsp->DFT.Z[i] = dsp->DFT.X[i]*dsp->DFT.Fm[i];
 
     Nidft(&dsp->DFT, dsp->DFT.Z, dsp->DFT.cx);
 
+    if (fabs(dc) < 0.5) dsp->dc = dc;
+
 
     // relativ Peak - Normierung erst zum Schluss;
     // dann jedoch nicht zwingend corr-Max wenn FM-Amplitude bzw. norm(x) nicht konstant
@@ -192,16 +212,23 @@ static int getCorrDFT(dsp_t *dsp) {
 
     //xnorm = sqrt(dsp->qs[(mpos + 2*dsp->M) % dsp->M]); // Nvar = L
     xnorm = 0.0;
-    for (i = 0; i < dsp->L; i++) xnorm += dsp->bufs[(mpos-i + dsp->M) % dsp->M]*dsp->bufs[(mpos-i + dsp->M) % dsp->M];
+    for (i = 0; i < dsp->L; i++) xnorm += (dsp->DFT).xn[mp-i]*(dsp->DFT).xn[mp-i];
     xnorm = sqrt(xnorm);
 
     mx /= xnorm*(dsp->DFT).N;
 
+    if (dsp->opt_iq > 1 && dsp->opt_dc) mpos += mp_ofs;
+
     dsp->mv = mx;
     dsp->mv_pos = mpos;
 
     if (pos == dsp->sample_out) dsp->buffered = dsp->sample_out - mpos;
 
+// FM: s = gain * carg(w)/M_PI = gain * dphi / PI // gain=0.8
+// FM audio gain? dc relative to FM-envelope?!
+//
+    dsp->dDf = dsp->sr * dsp->dc * 0.5;  // remaining freq offset
+
     return mp;
 }
 
@@ -306,27 +333,50 @@ static int f32read_sample(dsp_t *dsp, float *s) {
     return 0;
 }
 
+typedef struct {
+    double sumIQx;
+    double sumIQy;
+    float avgIQx;
+    float avgIQy;
+    ui32_t cnt;
+    ui32_t maxcnt;
+    ui32_t maxlim;
+} iq_dc_t;
+static iq_dc_t IQdc;
+
 static int f32read_csample(dsp_t *dsp, float complex *z) {
 
-    if (dsp->bps == 32) {
-        float x = 0, y = 0;
+    float x, y;
 
-        if (fread( &x, dsp->bps/8, 1, dsp->fp) != 1) return EOF;
-        if (fread( &y, dsp->bps/8, 1, dsp->fp) != 1) return EOF;
-
-        *z = x + I*y;
+    if (dsp->bps == 32) { //float32
+        float f[2];
+        if (fread( f, dsp->bps/8, 2, dsp->fp) != 2) return EOF;
+        x = f[0];
+        y = f[1];
+    }
+    else if (dsp->bps == 16) { //int16
+        short b[2];
+        if (fread( b, dsp->bps/8, 2, dsp->fp) != 2) return EOF;
+        x = b[0]/32768.0;
+        y = b[1]/32768.0;
+    }
+    else {  // dsp->bps == 8   //uint8
+        ui8_t u[2];
+        if (fread( u, dsp->bps/8, 2, dsp->fp) != 2) return EOF;
+        x = (u[0]-128)/128.0;
+        y = (u[1]-128)/128.0;
     }
-    else {  // dsp->bps == 8,16
-        short a = 0, b = 0;
 
-        if (fread( &a, dsp->bps/8, 1, dsp->fp) != 1) return EOF;
-        if (fread( &b, dsp->bps/8, 1, dsp->fp) != 1) return EOF;
+    *z = (x - IQdc.avgIQx) + I*(y - IQdc.avgIQy);
 
-        *z = a + I*b;
-
-        if (dsp->bps ==  8) { *z -= 128 + I*128; }
-        *z /= 128.0;
-        if (dsp->bps == 16) { *z /= 256.0; }
+    IQdc.sumIQx += x;
+    IQdc.sumIQy += y;
+    IQdc.cnt += 1;
+    if (IQdc.cnt == IQdc.maxcnt) {
+        IQdc.avgIQx = IQdc.sumIQx/(float)IQdc.maxcnt;
+        IQdc.avgIQy = IQdc.sumIQy/(float)IQdc.maxcnt;
+        IQdc.sumIQx = 0; IQdc.sumIQy = 0; IQdc.cnt = 0;
+        if (IQdc.maxcnt < IQdc.maxlim) IQdc.maxcnt *= 2;
     }
 
     return 0;
@@ -336,41 +386,72 @@ static int f32read_cblock(dsp_t *dsp) {
 
     int n;
     int len;
+    float x, y;
 
     len = dsp->decM;
 
     if (dsp->bps == 8) { //uint8
         ui8_t u[2*dsp->decM];
         len = fread( u, dsp->bps/8, 2*dsp->decM, dsp->fp) / 2;
-        for (n = 0; n < len; n++) dsp->decMbuf[n] = (u[2*n]-128)/128.0 + I*(u[2*n+1]-128)/128.0;
+        //for (n = 0; n < len; n++) dsp->decMbuf[n] = (u[2*n]-128)/128.0 + I*(u[2*n+1]-128)/128.0;
+        // u8: 0..255, 128 -> 0V
+        for (n = 0; n < len; n++) {
+            x = (u[2*n  ]-128)/128.0;
+            y = (u[2*n+1]-128)/128.0;
+            dsp->decMbuf[n] = (x-IQdc.avgIQx) + I*(y-IQdc.avgIQy);
+            IQdc.sumIQx += x;
+            IQdc.sumIQy += y;
+            IQdc.cnt += 1;
+            if (IQdc.cnt == IQdc.maxcnt) {
+                IQdc.avgIQx = IQdc.sumIQx/(float)IQdc.maxcnt;
+                IQdc.avgIQy = IQdc.sumIQy/(float)IQdc.maxcnt;
+                IQdc.sumIQx = 0; IQdc.sumIQy = 0; IQdc.cnt = 0;
+                if (IQdc.maxcnt < IQdc.maxlim) IQdc.maxcnt *= 2;
+            }
+        }
     }
     else if (dsp->bps == 16) { //int16
         short b[2*dsp->decM];
         len = fread( b, dsp->bps/8, 2*dsp->decM, dsp->fp) / 2;
-        for (n = 0; n < len; n++) dsp->decMbuf[n] = b[2*n]/32768.0 + I*b[2*n+1]/32768.0;
+        for (n = 0; n < len; n++) {
+            x = b[2*n  ]/32768.0;
+            y = b[2*n+1]/32768.0;
+            dsp->decMbuf[n] = (x-IQdc.avgIQx) + I*(y-IQdc.avgIQy);
+            IQdc.sumIQx += x;
+            IQdc.sumIQy += y;
+            IQdc.cnt += 1;
+            if (IQdc.cnt == IQdc.maxcnt) {
+                IQdc.avgIQx = IQdc.sumIQx/(float)IQdc.maxcnt;
+                IQdc.avgIQy = IQdc.sumIQy/(float)IQdc.maxcnt;
+                IQdc.sumIQx = 0; IQdc.sumIQy = 0; IQdc.cnt = 0;
+                if (IQdc.maxcnt < IQdc.maxlim) IQdc.maxcnt *= 2;
+            }
+        }
     }
     else { // dsp->bps == 32   //float32
         float f[2*dsp->decM];
         len = fread( f, dsp->bps/8, 2*dsp->decM, dsp->fp) / 2;
-        for (n = 0; n < len; n++) dsp->decMbuf[n] = f[2*n] + I*f[2*n+1];
+        for (n = 0; n < len; n++) {
+            x = f[2*n];
+            y = f[2*n+1];
+            dsp->decMbuf[n] = (x-IQdc.avgIQx) + I*(y-IQdc.avgIQy);
+            IQdc.sumIQx += x;
+            IQdc.sumIQy += y;
+            IQdc.cnt += 1;
+            if (IQdc.cnt == IQdc.maxcnt) {
+                IQdc.avgIQx = IQdc.sumIQx/(float)IQdc.maxcnt;
+                IQdc.avgIQy = IQdc.sumIQy/(float)IQdc.maxcnt;
+                IQdc.sumIQx = 0; IQdc.sumIQy = 0; IQdc.cnt = 0;
+                if (IQdc.maxcnt < IQdc.maxlim) IQdc.maxcnt *= 2;
+            }
+        }
     }
 
     return len;
 }
 
-
-float get_bufvar(dsp_t *dsp, int ofs) {
-    float mu  = dsp->xs[(dsp->sample_out+dsp->M + ofs) % dsp->M]/dsp->Nvar;
-    float var = dsp->qs[(dsp->sample_out+dsp->M + ofs) % dsp->M]/dsp->Nvar - mu*mu;
-    return var;
-}
-
-float get_bufmu(dsp_t *dsp, int ofs) {
-    float mu  = dsp->xs[(dsp->sample_out+dsp->M + ofs) % dsp->M]/dsp->Nvar;
-    return mu;
-}
-
-static int get_SNR(dsp_t *dsp) {
+/*
+static int get_SNR_rs41(dsp_t *dsp) {
 
     if (dsp->opt_iq)
     // if(dsp->rs_typ == RS41)
@@ -402,7 +483,7 @@ static int get_SNR(dsp_t *dsp) {
 
     return 0;
 }
-
+*/
 
 // decimate lowpass
 static float *ws_dec;
@@ -445,6 +526,35 @@ static int lowpass_init(float f, int taps, float **pws) {
     return taps;
 }
 
+
+static int lowpass_update(float f, int taps, float *ws) {
+    double *h, *w;
+    double norm = 0;
+    int n;
+
+    if (taps % 2 == 0) taps++; // odd/symmetric
+
+    if ( taps < 1 ) taps = 1;
+
+    h = (double*)calloc( taps+1, sizeof(double)); if (h == NULL) return -1;
+    w = (double*)calloc( taps+1, sizeof(double)); if (w == NULL) return -1;
+
+    for (n = 0; n < taps; n++) {
+        w[n] = 7938/18608.0 - 9240/18608.0*cos(2*M_PI*n/(taps-1)) + 1430/18608.0*cos(4*M_PI*n/(taps-1)); // Blackmann
+        h[n] = 2*f*sinc(2*f*(n-(taps-1)/2));
+        ws[n] = w[n]*h[n];
+        norm += ws[n]; // 1-norm
+    }
+    for (n = 0; n < taps; n++) {
+        ws[n] /= norm; // 1-norm
+    }
+
+    free(h); h = NULL;
+    free(w); w = NULL;
+
+    return taps;
+}
+
 static float complex lowpass(float complex buffer[], ui32_t sample, ui32_t taps, float *ws) {
     ui32_t n;
     double complex w = 0;
@@ -454,6 +564,15 @@ static float complex lowpass(float complex buffer[], ui32_t sample, ui32_t taps,
     return (float complex)w;
 }
 
+static float re_lowpass(float buffer[], ui32_t sample, ui32_t taps, float *ws) {
+    ui32_t n;
+    double w = 0;
+    for (n = 0; n < taps; n++) {
+        w += buffer[(sample+n+1)%taps]*ws[taps-1-n];
+    }
+    return (float)w;
+}
+
 
 int f32buf_sample(dsp_t *dsp, int inv) {
     float s = 0.0;
@@ -476,31 +595,33 @@ int f32buf_sample(dsp_t *dsp, int inv) {
                 if (dsp->sample_dec == s_reset) dsp->sample_dec = 0;
             }
             z = lowpass(dsp->decXbuffer, dsp->sample_dec, dsp->dectaps, ws_dec);
-
         }
         else if ( f32read_csample(dsp, &z) == EOF ) return EOF;
 
+        z *= cexp(-t*2*M_PI*dsp->Df*I);
+
         // IF-lowpass
         if (dsp->opt_lp) {
             dsp->lpIQ_buf[dsp->sample_in % dsp->lpIQtaps] = z;
             z = lowpass(dsp->lpIQ_buf, dsp->sample_in, dsp->lpIQtaps, dsp->ws_lpIQ);
         }
 
-        dsp->raw_iqbuf[dsp->sample_in % dsp->N_IQBUF] = z;
 
-        //z *= cexp(-t*2*M_PI*dsp->df*I);
         z0 = dsp->rot_iqbuf[(dsp->sample_in-1 + dsp->N_IQBUF) % dsp->N_IQBUF];
         w = z * conj(z0);
         s = gain * carg(w)/M_PI;
+
         dsp->rot_iqbuf[dsp->sample_in % dsp->N_IQBUF] = z;
 
-        /*  //if (rs_type==rs41) get_SNR(dsp);
-            // rs41, constant amplitude, avg/filter
-            int n;
-            double r = 0.0;
-            for (n = 0; n < dsp->sps; n++) r += cabs(dsp->rot_iqbuf[(dsp->sample_in - n + dsp->N_IQBUF) % dsp->N_IQBUF]);
-            r /= (float)n;
-        */
+
+        // FM-lowpass
+        if (dsp->opt_lp) {
+            dsp->lpFM_buf[dsp->sample_in % dsp->lpFMtaps] = s;
+            s = re_lowpass(dsp->lpFM_buf, dsp->sample_in, dsp->lpFMtaps, dsp->ws_lpFM);
+        }
+
+        dsp->fm_buffer[(dsp->sample_in - dsp->lpFMtaps/2 + dsp->M) % dsp->M] = s;
+
 
         if (dsp->opt_iq >= 2)
         {
@@ -562,7 +683,7 @@ int f32buf_sample(dsp_t *dsp, int inv) {
     }
 
     if (inv) s = -s;
-    dsp->bufs[dsp->sample_in % dsp->M] = s - dsp->dc_ofs;
+    dsp->bufs[dsp->sample_in % dsp->M] = s;
 
     xneu = dsp->bufs[(dsp->sample_in  ) % dsp->M];
     xalt = dsp->bufs[(dsp->sample_in+dsp->M - dsp->Nvar) % dsp->M];
@@ -587,17 +708,19 @@ static int read_bufbit(dsp_t *dsp, int symlen, char *bits, ui32_t mvp, int pos)
 
     double sum = 0.0;
 
+    // bei symlen=2 (Manchester) kein dc noetig: -dc+dc=0 ;
+    // allerdings M10-header mit symlen=1
 
     rbitgrenze += dsp->sps;
     do {
-        sum += dsp->bufs[(rcount + mvp + dsp->M) % dsp->M];
+        sum += dsp->bufs[(rcount + mvp + dsp->M) % dsp->M] - dsp->dc;
         rcount++;
     } while (rcount < rbitgrenze);  // n < dsp->sps
 
     if (symlen == 2) {
         rbitgrenze += dsp->sps;
         do {
-            sum -= dsp->bufs[(rcount + mvp + dsp->M) % dsp->M];
+            sum -= dsp->bufs[(rcount + mvp + dsp->M) % dsp->M] - dsp->dc;
             rcount++;
         } while (rcount < rbitgrenze);  // n < dsp->sps
     }
@@ -623,6 +746,8 @@ static int headcmp(dsp_t *dsp, int opt_dc) {
     int len = dsp->hdrlen/dsp->symhd;
     int inv = dsp->mv < 0;
 
+    if (opt_dc == 0 || dsp->opt_iq > 1) dsp->dc = 0; // reset? e.g. 2nd pass
+
     if (dsp->symhd != 1) step = 2;
     if (inv) sign=1;
 
@@ -637,53 +762,9 @@ static int headcmp(dsp_t *dsp, int opt_dc) {
         len--;
     }
 
-    if (opt_dc && errs < 3) {
-        dsp->dc_ofs += dsp->dc;
-    }
-
     return errs;
 }
 
-int get_fqofs_rs41(dsp_t *dsp, ui32_t mvp, float *freq, float *snr) {
-    int j;
-    int buf_start;
-    int presamples;
-
-    // if(dsp->rs_typ == RS41_PREAMBLE) ...
-    if (dsp->opt_iq)
-    {
-        presamples = 256*dsp->sps;
-
-        if (presamples > dsp->DFT.N2) presamples = dsp->DFT.N2;
-
-        buf_start = mvp - dsp->hdrlen*dsp->sps - presamples;
-
-        while (buf_start < 0) buf_start += dsp->N_IQBUF;
-
-        for (j = 0; j < dsp->DFT.N2; j++) {
-            dsp->DFT.Z[j] = dsp->DFT.win[j]*dsp->raw_iqbuf[(buf_start+j) % dsp->N_IQBUF];
-        }
-        while (j < dsp->DFT.N) dsp->DFT.Z[j++] = 0;
-
-        raw_dft(&dsp->DFT, dsp->DFT.Z);
-        dsp->df = bin2freq(&dsp->DFT, max_bin(&dsp->DFT, dsp->DFT.Z));
-
-        // if |df|<eps, +-2400Hz dominant (rs41)
-        if (fabs(dsp->df) > 1000.0) dsp->df = 0.0;
-
-
-        dsp->sample_posframe = dsp->sample_in;  // > sample_out  //mvp - dsp->hdrlen*dsp->sps;
-        dsp->sample_posnoise = mvp + dsp->sr*7/8.0; // rs41
-
-
-        *freq = dsp->df;
-        *snr = dsp->SNRdB;
-    }
-    else return -1;
-
-    return 0;
-}
-
 /* -------------------------------------------------------------------------- */
 
 int read_slbit(dsp_t *dsp, int *bit, int inv, int ofs, int pos, float l, int spike) {
@@ -699,6 +780,10 @@ int read_slbit(dsp_t *dsp, int *bit, int inv, int ofs, int pos, float l, int spi
 
     double bg = pos*dsp->symlen*dsp->sps;
 
+    double dc = 0.0;
+
+    if (dsp->opt_dc && dsp->opt_iq < 2) dc = dsp->dc;
+
     if (pos == 0) {
         bg = 0;
         dsp->sc = 0;
@@ -718,6 +803,7 @@ int read_slbit(dsp_t *dsp, int *bit, int inv, int ofs, int pos, float l, int spi
                           +dsp->bufs[(dsp->sample_out-dsp->buffered+1 + ofs + dsp->M) % dsp->M]);
                 sample = avg + scale*(sample - avg); // spikes
             }
+            sample -= dc;
 
             if ( l < 0 || (mid-l < dsp->sc && dsp->sc < mid+l)) sum -= sample;
 
@@ -737,6 +823,7 @@ int read_slbit(dsp_t *dsp, int *bit, int inv, int ofs, int pos, float l, int spi
                       +dsp->bufs[(dsp->sample_out-dsp->buffered+1 + ofs + dsp->M) % dsp->M]);
             sample = avg + scale*(sample - avg); // spikes
         }
+            sample -= dc;
 
         if ( l < 0 || (mid-l < dsp->sc && dsp->sc < mid+l)) sum += sample;
 
@@ -752,6 +839,8 @@ int read_slbit(dsp_t *dsp, int *bit, int inv, int ofs, int pos, float l, int spi
 
 /* -------------------------------------------------------------------------- */
 
+#define IF_TRANSITION_BW (4e3)  // 4kHz transition width
+#define FM_TRANSITION_BW (2e3)  // 2kHz transition width
 
 #define SQRT2 1.4142135624   // sqrt(2)
 // sigma = sqrt(log(2)) / (2*PI*BT):
@@ -871,15 +960,46 @@ int init_buffers(dsp_t *dsp) {
         int taps; // lowpass taps: 4*sr/transition_bw
 
         // IF lowpass
-        taps = 4*dsp->sr/4e3; if (taps%2==0) taps++; // 4kHz transition
-        f_lp = dsp->lpIQ_bw/(float)dsp->sr/2.0;
-        taps = lowpass_init(f_lp, taps, &dsp->ws_lpIQ); if (taps < 0) return -1;
+        f_lp = 24e3; // default
+        if (dsp->lpIQ_bw) f_lp = dsp->lpIQ_bw/(float)dsp->sr/2.0;
+        taps = 4*dsp->sr/IF_TRANSITION_BW; if (taps%2==0) taps++;
+        taps = lowpass_init(1.5*f_lp, taps, &dsp->ws_lpIQ0); if (taps < 0) return -1;
+        taps = lowpass_init(f_lp, taps, &dsp->ws_lpIQ1); if (taps < 0) return -1;
 
+        dsp->lpIQ_fbw = f_lp;
         dsp->lpIQtaps = taps;
         dsp->lpIQ_buf = calloc( dsp->lpIQtaps+3, sizeof(float complex));
         if (dsp->lpIQ_buf == NULL) return -1;
 
-        // dc-offset: if not centered, (aquisition) lowpass bw = lpIQ_bw + 4kHz
+        dsp->ws_lpIQ = dsp->ws_lpIQ1;
+        // dc-offset: if not centered, (acquisition) filter bw = lpIQ_bw + 4kHz
+        // coarse acquisition:
+        if (dsp->opt_dc) {
+            dsp->locked = 0;
+            dsp->ws_lpIQ = dsp->ws_lpIQ0;
+            //taps = lowpass_update(1.5*dsp->lpIQ_fbw, dsp->lpIQtaps, dsp->ws_lpIQ); if (taps < 0) return -1;
+        }
+        // locked:
+        //taps = lowpass_update(dsp->lpIQ_fbw, dsp->lpIQtaps, dsp->ws_lpIQ); if (taps < 0) return -1;
+
+
+        // FM lowpass
+        f_lp = 10e3; // default
+        if (dsp->lpFM_bw > 0) f_lp = dsp->lpFM_bw/(float)dsp->sr;
+        taps = 4*dsp->sr/FM_TRANSITION_BW; if (taps%2==0) taps++;
+        taps = lowpass_init(f_lp, taps, &dsp->ws_lpFM); if (taps < 0) return -1;
+
+        dsp->lpFMtaps = taps;
+        dsp->lpFM_buf = calloc( dsp->lpFMtaps+3, sizeof(float complex));
+        if (dsp->lpFM_buf == NULL) return -1;
+    }
+
+    memset(&IQdc, 0, sizeof(IQdc));
+    IQdc.maxlim = dsp->sr;
+    IQdc.maxcnt = IQdc.maxlim/32; // 32,16,8,4,2,1
+    if (dsp->decM > 1) {
+        IQdc.maxlim *= dsp->decM;
+        IQdc.maxcnt *= dsp->decM;
     }
 
 
@@ -982,12 +1102,11 @@ int init_buffers(dsp_t *dsp) {
         if (dsp->nch < 2) return -1;
 
         dsp->N_IQBUF = dsp->DFT.N;
-        dsp->raw_iqbuf = calloc(dsp->N_IQBUF+1, sizeof(float complex));  if (dsp->raw_iqbuf == NULL) return -1;
         dsp->rot_iqbuf = calloc(dsp->N_IQBUF+1, sizeof(float complex));  if (dsp->rot_iqbuf == NULL) return -1;
-
-        dsp->len_sq = dsp->sps*8;
     }
 
+    dsp->fm_buffer = (float *)calloc( M+1, sizeof(float));  if (dsp->fm_buffer == NULL) return -1; // dsp->bufs[]
+
 
     return K;
 }
@@ -1011,10 +1130,11 @@ int free_buffers(dsp_t *dsp) {
 
     if (dsp->opt_iq)
     {
-        if (dsp->raw_iqbuf) { free(dsp->raw_iqbuf); dsp->raw_iqbuf = NULL; }
         if (dsp->rot_iqbuf) { free(dsp->rot_iqbuf); dsp->rot_iqbuf = NULL; }
     }
 
+
+    // decimate
     if (dsp->opt_iq == 5)
     {
         if (dsp->decXbuffer) { free(dsp->decXbuffer); dsp->decXbuffer = NULL; }
@@ -1024,12 +1144,19 @@ int free_buffers(dsp_t *dsp) {
         if (ws_dec) { free(ws_dec); ws_dec = NULL; }
     }
 
+    // IF lowpass
     if (dsp->opt_iq && dsp->opt_lp)
     {
-        if (dsp->ws_lpIQ)  { free(dsp->ws_lpIQ);  dsp->ws_lpIQ  = NULL; }
+        if (dsp->ws_lpIQ0) { free(dsp->ws_lpIQ0); dsp->ws_lpIQ0 = NULL; }
+        if (dsp->ws_lpIQ1) { free(dsp->ws_lpIQ1); dsp->ws_lpIQ1 = NULL; }
         if (dsp->lpIQ_buf) { free(dsp->lpIQ_buf); dsp->lpIQ_buf = NULL; }
+
+        if (dsp->ws_lpFM)  { free(dsp->ws_lpFM);  dsp->ws_lpFM  = NULL; }
+        if (dsp->lpFM_buf) { free(dsp->lpFM_buf); dsp->lpFM_buf = NULL; }
     }
 
+    if (dsp->fm_buffer) { free(dsp->fm_buffer); dsp->fm_buffer = NULL; }
+
     return 0;
 }
 
@@ -1065,6 +1192,31 @@ int find_header(dsp_t *dsp, float thres, int hdmax, int bitofs, int opt_dc) {
 
         if (dsp->mv > thres || dsp->mv < -thres) {
 
+            if (dsp->opt_dc) {  // Problem: FM-gain
+                if (dsp->opt_iq < 2) dsp->Df += dsp->dDf/2.0 *0.8;
+                else {
+                    double ofs = fabs(dsp->dDf);  // (iq-decode controls FM-gain)
+                    if (ofs > 200.0)
+                    {
+                        dsp->Df += dsp->dDf/1.2 *0.8;
+                    }
+                    if (ofs > 1000.0) {  //dsp->opt_lp
+                        if (dsp->locked) {
+                            dsp->locked = 0;
+                            dsp->ws_lpIQ = dsp->ws_lpIQ0;
+                            // alt: lowpass_update(1.5*dsp->lpIQ_fbw, dsp->lpIQtaps, dsp->ws_lpIQ);
+                        }
+                    }
+                    else {
+                        if (dsp->locked == 0) {
+                            dsp->locked = 1;
+                            dsp->ws_lpIQ = dsp->ws_lpIQ1;
+                            // alt: lowpass_update(dsp->lpIQ_fbw, dsp->lpIQtaps, dsp->ws_lpIQ);
+                        }
+                    }
+                }
+            }
+
             if (dsp->mv_pos > mvpos0) {
 
                 header_found = 0;
diff --git a/demod/mod/demod_mod.h b/demod/mod/demod_mod.h
index 6e457f2..2c5e72c 100644
--- a/demod/mod/demod_mod.h
+++ b/demod/mod/demod_mod.h
@@ -50,8 +50,6 @@ typedef struct {
     int K;
     float *match;
     float *bufs;
-    float dc_ofs;
-    float dc;
     float mv;
     ui32_t mv_pos;
     //
@@ -65,7 +63,6 @@ typedef struct {
     // IQ-data
     int opt_iq;
     int N_IQBUF;
-    float complex *raw_iqbuf;
     float complex *rot_iqbuf;
     float complex F1sum;
     float complex F2sum;
@@ -82,8 +79,12 @@ typedef struct {
     // DFT
     dft_t DFT;
 
-    double df;
-    int len_sq;
+    // dc offset
+    int opt_dc;
+    int locked;
+    double dc;
+    double Df;
+    double dDf;
 
     ui32_t sample_posframe;
     ui32_t sample_posnoise;
@@ -106,10 +107,20 @@ typedef struct {
     // IF: lowpass
     int opt_lp;
     int lpIQ_bw;
+    float lpIQ_fbw;
     int lpIQtaps; // ui32_t
+    float *ws_lpIQ0;
+    float *ws_lpIQ1;
     float *ws_lpIQ;
     float complex *lpIQ_buf;
 
+    // FM: lowpass
+    int lpFM_bw;
+    int lpFMtaps; // ui32_t
+    float *ws_lpFM;
+    float *lpFM_buf;
+	float *fm_buffer;
+
 } dsp_t;
 
 
@@ -126,10 +137,6 @@ float read_wav_header(pcm_t *, FILE *);
 int f32buf_sample(dsp_t *, int);
 int read_slbit(dsp_t *, int*, int, int, int, float, int);
 
-int get_fqofs_rs41(dsp_t *, ui32_t, float *, float *);
-float get_bufvar(dsp_t *, int);
-float get_bufmu(dsp_t *, int);
-
 int init_buffers(dsp_t *);
 int free_buffers(dsp_t *);
 
diff --git a/demod/mod/dfm09mod.c b/demod/mod/dfm09mod.c
index d179703..e044b89 100644
--- a/demod/mod/dfm09mod.c
+++ b/demod/mod/dfm09mod.c
@@ -837,6 +837,7 @@ int main(int argc, char **argv) {
     int option_auto = 0;
     int option_iq = 0;
     int option_lp = 0;
+    int option_dc = 0;
     int option_bin = 0;
     int option_json = 0;     // JSON blob output (for auto_rx)
     int wavloaded = 0;
@@ -952,6 +953,7 @@ int main(int argc, char **argv) {
             option_iq = 5;
         }
         else if   (strcmp(*argv, "--lp") == 0) { option_lp = 1; }  // IQ lowpass
+        else if   (strcmp(*argv, "--dc") == 0) { option_dc = 1; }
         else if   (strcmp(*argv, "--dbg") == 0) { gpx.option.dbg = 1; }
         else {
             fp = fopen(*argv, "rb");
@@ -1012,9 +1014,11 @@ int main(int argc, char **argv) {
         dsp.hdrlen = strlen(dfm_rawheader);
         dsp.BT = 0.5; // bw/time (ISI) // 0.3..0.5
         dsp.h = 1.8;  // 2.4 modulation index abzgl. BT
-        dsp.lpIQ_bw = 12e3;
         dsp.opt_iq = option_iq;
         dsp.opt_lp = option_lp;
+        dsp.lpIQ_bw = 12e3; // IF lowpass bandwidth
+        dsp.lpFM_bw = 4e3; // FM audio lowpass
+        dsp.opt_dc = option_dc;
 
         if ( dsp.sps < 8 ) {
             fprintf(stderr, "note: sample rate low\n");
@@ -1050,8 +1054,8 @@ int main(int argc, char **argv) {
                 header_found = find_binhead(fp, &hdb, &_mv); // symbols or bits?
                 hdrcnt += nfrms;
             }
-            else {
-                header_found = find_header(&dsp, thres, 2, bitofs, 0);
+            else {                                                              // FM-audio:
+                header_found = find_header(&dsp, thres, 2, bitofs, dsp.opt_dc); // optional 2nd pass: dc=0
                 _mv = dsp.mv;
             }
             if (header_found == EOF) break;
diff --git a/demod/mod/lms6Xmod.c b/demod/mod/lms6Xmod.c
index 204c22f..c2da073 100644
--- a/demod/mod/lms6Xmod.c
+++ b/demod/mod/lms6Xmod.c
@@ -1109,9 +1109,11 @@ int main(int argc, char **argv) {
     dsp.hdrlen = strlen(rawheader);
     dsp.BT = 1.2; // bw/time (ISI) // 1.0..2.0  // BT(lmsX) < BT(lms6) ? -> init_buffers()
     dsp.h = 0.9;  // 0.95 modulation index
-    dsp.lpIQ_bw = 8e3;
     dsp.opt_iq = option_iq;
     dsp.opt_lp = option_lp;
+    dsp.lpIQ_bw = 8e3; // IF lowpass bandwidth
+    dsp.lpFM_bw = 6e3; // FM audio lowpass
+    dsp.opt_dc = option_dc;
 
     if ( dsp.sps < 8 ) {
         fprintf(stderr, "note: sample rate low (%.1f sps)\n", dsp.sps);
@@ -1160,8 +1162,8 @@ int main(int argc, char **argv) {
 
     while ( 1 )
     {
-
-        header_found = find_header(&dsp, thres, 3, bitofs, option_dc);
+                                                                        // FM-audio:
+        header_found = find_header(&dsp, thres, 3, bitofs, dsp.opt_dc); // optional 2nd pass: dc=0
         _mv = dsp.mv;
 
         if (header_found == EOF) break;
diff --git a/demod/mod/m10mod.c b/demod/mod/m10mod.c
index 6e50c0b..dcf300f 100644
--- a/demod/mod/m10mod.c
+++ b/demod/mod/m10mod.c
@@ -880,9 +880,9 @@ int main(int argc, char **argv) {
     //int option_res = 0;      // genauere Bitmessung
     int option_color = 0;
     int option_ptu = 0;
-    int option_dc = 0;
     int option_iq = 0;
     int option_lp = 0;
+    int option_dc = 0;
     int wavloaded = 0;
     int sel_wavch = 0;     // audio channel: left
     int spike = 0;
@@ -949,9 +949,6 @@ int main(int argc, char **argv) {
         else if ( (strcmp(*argv, "--ptu") == 0) ) {
             option_ptu = 1;
         }
-        else if ( (strcmp(*argv, "--dc") == 0) ) {
-            option_dc = 1;
-        }
         else if ( (strcmp(*argv, "--spike") == 0) ) {
             spike = 1;
         }
@@ -986,6 +983,7 @@ int main(int argc, char **argv) {
             option_iq = 5;
         }
         else if   (strcmp(*argv, "--lp") == 0) { option_lp = 1; }  // IQ lowpass
+        else if   (strcmp(*argv, "--dc") == 0) { option_dc = 1; }
         else if   (strcmp(*argv, "--json") == 0) { gpx.option.jsn = 1; }
         else {
             fp = fopen(*argv, "rb");
@@ -1036,9 +1034,11 @@ int main(int argc, char **argv) {
     dsp.hdrlen = strlen(rawheader);
     dsp.BT = 1.8; // bw/time (ISI) // 1.0..2.0
     dsp.h = 0.9;  // 1.2 modulation index
-    dsp.lpIQ_bw = 24e3;
     dsp.opt_iq = option_iq;
     dsp.opt_lp = option_lp;
+    dsp.lpIQ_bw = 24e3; // IF lowpass bandwidth
+    dsp.lpFM_bw = 10e3; // FM audio lowpass
+    dsp.opt_dc = option_dc;
 
     if ( dsp.sps < 8 ) {
         fprintf(stderr, "note: sample rate low (%.1f sps)\n", dsp.sps);
@@ -1057,8 +1057,8 @@ int main(int argc, char **argv) {
 
     while ( 1 )
     {
-
-        header_found = find_header(&dsp, thres, 2, bitofs, option_dc);
+                                                                        // FM-audio:
+        header_found = find_header(&dsp, thres, 2, bitofs, dsp.opt_dc); // optional 2nd pass: dc=0
         _mv = dsp.mv;
 
         if (header_found == EOF) break;
@@ -1068,7 +1068,6 @@ int main(int argc, char **argv) {
             gpx.option.inv ^= 0x1;  // M10: irrelevant
         }
 
-
         if (header_found) {
 
             bitpos = 0;
diff --git a/demod/mod/meisei100mod.c b/demod/mod/meisei100mod.c
index b426f42..14dd780 100644
--- a/demod/mod/meisei100mod.c
+++ b/demod/mod/meisei100mod.c
@@ -336,7 +336,7 @@ int main(int argc, char **argv) {
             option_iq = 5;
         }
         else if   (strcmp(*argv, "--lp") == 0) { option_lp = 1; }  // IQ lowpass
-//        else if ( (strcmp(*argv, "--dc") == 0) ) { option_dc = 1; }
+        else if ( (strcmp(*argv, "--dc") == 0) ) { option_dc = 1; }
         else if   (strcmp(*argv, "--json") == 0) {
             option_jsn = 1;
             option_ecc = 1;
@@ -382,9 +382,11 @@ int main(int argc, char **argv) {
     dsp.hdrlen = strlen(rawheader);
     dsp.BT = 1.2; // bw/time (ISI) // 1.0..2.0
     dsp.h = 2.4;  // 2.8
-    dsp.lpIQ_bw = 16e3;
     dsp.opt_iq = option_iq;
     dsp.opt_lp = option_lp;
+    dsp.lpIQ_bw = 16e3; // IF lowpass bandwidth
+    dsp.lpFM_bw = 4e3; // FM audio lowpass
+    dsp.opt_dc = option_dc;
 
     if ( dsp.sps < 8 ) {
         fprintf(stderr, "note: sample rate low (%.1f sps)\n", dsp.sps);
@@ -413,8 +415,8 @@ int main(int argc, char **argv) {
 
     while ( 1 )
     {
-
-        header_found = find_header(&dsp, thres, 1, bitofs, option_dc);
+                                                                        // FM-audio:
+        header_found = find_header(&dsp, thres, 1, bitofs, dsp.opt_dc); // optional 2nd pass: dc=0
         _mv = dsp.mv;
 
         if (header_found == EOF) break;
diff --git a/demod/mod/rs41mod.c b/demod/mod/rs41mod.c
index 30e70d9..9051d06 100644
--- a/demod/mod/rs41mod.c
+++ b/demod/mod/rs41mod.c
@@ -1534,7 +1534,7 @@ int main(int argc, char *argv[]) {
     //int option_inv = 0;    // invertiert Signal
     int option_iq = 0;
     int option_lp = 0;
-    int option_ofs = 0;
+    int option_dc = 0;
     int option_bin = 0;
     int wavloaded = 0;
     int sel_wavch = 0;     // audio channel: left
@@ -1608,13 +1608,8 @@ int main(int argc, char *argv[]) {
         else if   (strcmp(*argv, "--sat") == 0) { gpx.option.sat = 1; }
         else if   (strcmp(*argv, "--ptu") == 0) { gpx.option.ptu = 1; }
         else if   (strcmp(*argv, "--silent") == 0) { gpx.option.slt = 1; }
-        else if   (strcmp(*argv, "--json") == 0) {
-            gpx.option.jsn = 1;
-            gpx.option.ecc = 2;
-            gpx.option.crc = 1;
-        }
         else if   (strcmp(*argv, "--ch2") == 0) { sel_wavch = 1; }  // right channel (default: 0=left)
-        else if ( (strcmp(*argv, "--auto") == 0) ) { gpx.option.aut = 1; }
+        else if   (strcmp(*argv, "--auto") == 0) { gpx.option.aut = 1; }
         else if   (strcmp(*argv, "--bin") == 0) { option_bin = 1; }   // bit/byte binary input
         else if   (strcmp(*argv, "--ths") == 0) {
             ++argv;
@@ -1646,7 +1641,12 @@ int main(int argc, char *argv[]) {
             option_iq = 5;
         }
         else if   (strcmp(*argv, "--lp") == 0) { option_lp = 1; }  // IQ lowpass
-        else if   (strcmp(*argv, "--ofs") == 0) { option_ofs = 1; }
+        else if   (strcmp(*argv, "--dc") == 0) { option_dc = 1; }
+        else if   (strcmp(*argv, "--json") == 0) {
+            gpx.option.jsn = 1;
+            gpx.option.ecc = 2;
+            gpx.option.crc = 1;
+        }
         else if   (strcmp(*argv, "--rawhex") == 0) { rawhex = 2; }  // raw hex input
         else if   (strcmp(*argv, "--xorhex") == 0) { rawhex = 2; xorhex = 1; }  // raw xor input
         else {
@@ -1705,9 +1705,11 @@ int main(int argc, char *argv[]) {
             dsp.hdrlen = strlen(rs41_header);
             dsp.BT = 0.5; // bw/time (ISI) // 0.3..0.5
             dsp.h = 0.6; //0.7;  // 0.7..0.8? modulation index abzgl. BT
-            dsp.lpIQ_bw = 8e3;
             dsp.opt_iq = option_iq;
             dsp.opt_lp = option_lp;
+            dsp.lpIQ_bw = 8e3; // IF lowpass bandwidth
+            dsp.lpFM_bw = 6e3; // FM audio lowpass
+            dsp.opt_dc = option_dc;
 
             if ( dsp.sps < 8 ) {
                 fprintf(stderr, "note: sample rate low (%.1f sps)\n", dsp.sps);
@@ -1741,8 +1743,8 @@ int main(int argc, char *argv[]) {
             if (option_bin) {
                 header_found = find_binhead(fp, &hdb, &_mv);
             }
-            else {
-                header_found = find_header(&dsp, thres, 3, bitofs, 0);
+            else {                                                              // FM-audio:
+                header_found = find_header(&dsp, thres, 3, bitofs, dsp.opt_dc); // optional 2nd pass: dc=0
                 _mv = dsp.mv;
             }
             if (header_found == EOF) break;