Flesh out the disk settings dialog.

[wozmaker] / src / dsp.cpp

//
// dsp.cpp: Digital Signal Processing module
//
// Part of the WOZ Maker project
// by James Hammons
// (C) 2018 Underground Software
//

#include "dsp.h"
#include <math.h>
#include <stdio.h>
#include <string.h>
#include "fileio.h"
#include "global.h"


//#define NOISY

// Really, there shouldn't be more than 5 waveforms per track
uint32_t sNum[6];
double initSyncTime[6];

static const double SIGMA_THRESHOLD = 2.5;


double StdDeviation(double * a, uint32_t num, double * pMean/*= NULL*/)
{
        double sigma = 0, mean = 0;

        for(uint32_t i=0; i<num; i++)
                mean += a[i];

        mean = mean / (double)num;

        if (pMean)
                *pMean = mean;

        for(uint32_t i=0; i<num; i++)
                sigma += (a[i] - mean) * (a[i] - mean);

        return sqrt(sigma / (double)num);
}


double StdDeviationWave(uint32_t * sync, uint32_t num, double * pMean/*= NULL*/)
{
        double sigma = 0, mean = 0;
        double a[6];

        for(uint32_t i=0; i<num; i++)
        {
                a[i] = (double)Global::wave[sNum[i]][sync[i]];
                mean += a[i];
        }

        mean = mean / (double)num;

        // Capture the mean, if a pointer was passed in
        if (pMean)
                *pMean = mean;

        for(uint32_t i=0; i<num; i++)
                sigma += (a[i] - mean) * (a[i] - mean);

        return sqrt(sigma / (double)num);
}


double Largest(double * a, uint32_t num)
{
        double largest = a[0];

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] > largest)
                        largest = a[i];
        }

        return largest;
}


uint32_t Largest(uint32_t * a, uint32_t num)
{
        uint32_t largest = a[0];

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] > largest)
                        largest = a[i];
        }

        return largest;
}


uint32_t LargestIndex(double * a, uint32_t num)
{
        double largest = a[0];
        uint32_t index = 0;

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] > largest)
                {
                        largest = a[i];
                        index = i;
                }
        }

        return index;
}


uint32_t LargestIndex(uint32_t * a, uint32_t num)
{
        uint32_t largest = a[0];
        uint32_t index = 0;

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] > largest)
                {
                        largest = a[i];
                        index = i;
                }
        }

        return index;
}


double Smallest(double * a, uint32_t num)
{
        double smallest = a[0];

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] < smallest)
                        smallest = a[i];
        }

        return smallest;
}


uint32_t Smallest(uint32_t * a, uint32_t num)
{
        uint32_t smallest = a[0];

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] < smallest)
                        smallest = a[i];
        }

        return smallest;
}


uint32_t SmallestIndex(double * a, uint32_t num)
{
        double smallest = a[0];
        uint32_t index = 0;

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] < smallest)
                {
                        smallest = a[i];
                        index = i;
                }
        }

        return index;
}


uint32_t SmallestIndex(uint32_t * a, uint32_t num)
{
        uint32_t smallest = a[0];
        uint32_t index = 0;

        for(uint32_t i=1; i<num; i++)
        {
                if (a[i] < smallest)
                {
                        smallest = a[i];
                        index = i;
                }
        }

        return index;
}


//
// Compare two arrays to see if they are equal
//
bool Equal(uint32_t * a1, uint32_t * a2, uint32_t num)
{
        for(uint32_t i=0; i<num; i++)
        {
                if (a1[i] != a2[i])
                        return false;
        }

        return true;
}


uint32_t IndexForTime(uint32_t trackNum, uint32_t time)
{
        uint32_t curTime = 0, pos = 0;

        while (curTime < time)
                curTime += Global::synWave[trackNum][pos++];

        return pos;
}


//
// This is where we attempt to use the stream data to collapse them down to a single track.  Taken as wholes, each individual track will drift out of sync with respect to the others, and fairly quickly as the drive mechanism does not read consistently at a set RPM as you might expect, but instead it fluctuates all over the place--which throws a big ol' monkey wrench into the works.  (Yes, the overall *average* stays around a set RPM, but locally--nope.)
//
// The big problem is that the disk spins via a motor which isn't perfect in its rotation that is connected to the hub that spins the disk via a belt, which further adds more uncertainty to the speed of the disk as it rotates.  The end result is that there is no consistency vis-a-vis the speed of the disk, and so the results of one read to the next can and will vary wildly.  It's a miracle that these things are readable at all.  O_o
//
// So how do we cope with it?  I'm sure there's a well known paper or set of papers which addresses noise rejection from multiple signals read from a single source, but I have yet to find them.  So what we have below is a set of ad-hoc assumptions and heuristics that attempt to deal with this problem.
//
// The basic assumption is that from any given pulse to the next one, the drift will tend to be small and thus as we move from pulse to pulse, we can stay more or less in sync by resetting the base from which we calculate the next time interval to the previous step.  This works remarkably well until we run into a long period of zeroes, which seems to throw off the Applesauce hardware which read these streams in the first place; or when some spurious one pulses pop up in one stream that doesn't in one or more of the others.
//

void FindInitialSyncForStreams2(uint32_t * sync, uint32_t num)
{
        bool lookAt[6] = { true, true, false, false, false, false };

//      while (FindSyncBetweenFirstTwo(sync) == false)
        while (FindSyncBetweenFirstTwo(sync) < 1000)
        {
                for(uint32_t i=0; i<num; i++)
                {
                        sync[i] += 200;

                        if (sync[i] >= Global::waveLen[sNum[i]])
                        {
                                printf("Could not find initial sync!!\n");
                                return;// -1;
                        }
                }
        }

        uint32_t lookahead = LookaheadWave(sync, 2);

        if (lookAt[0])
                printf("Found sync for streams 1 & 2 at %d and %d (la=%d)\n", sync[0], sync[1], lookahead);

        // Add in the others, one at a time and try to synchronize them
        uint32_t bestSync[6];

        for(uint32_t i=2; i<num; i++)
        {
                lookAt[i] = true;
                uint32_t bestLA = 0;

                for(uint32_t j=0; j<200; j++)
                {
                        uint32_t syncSave = sync[i];

                        // And check again for a match
                        for(uint32_t k=0; k<200; k++)
                        {
                                uint32_t la = LookaheadWave(sync, i + 1);

                                if (la > bestLA)
                                {
                                        bestLA = la;
                                        memcpy(bestSync, sync, sizeof(bestSync));
                                }

                                sync[i]++;
                        }

                        sync[i] = syncSave;

                        // Kick synchronized streams forward to check the rest...
                        for(uint32_t k=0; k<i; k++)
                                sync[k]++;
                }

                memcpy(sync, bestSync, sizeof(bestSync));
        }

        for(uint32_t i=0; i<num; i++)
                printf("Sync for stream %d: %d (%s)\n", i, sync[i], (lookAt[i] ? "yes" : "no"));
        printf("Lookahead: %d\n", LookaheadWave(sync, num));
}


#if 1
uint32_t Synthesize2(uint32_t * sync, uint32_t num, uint32_t * synthWave, float * swAmplitude)
{
        uint32_t swLen = 0;
        uint32_t syncPt[7], syncSave[7];
        double a[7], b[7], currentRow[7];
        Global::bloops = 0;

        memcpy(syncPt, sync, sizeof(syncPt));

        while (true)
        {
                for(uint32_t i=0; i<num; i++)
                {
                        if (syncPt[i] >= Global::streamLen[i])
                                return swLen;
                }

                // Save these *before* we step forward
                memcpy(syncSave, syncPt, sizeof(syncSave));
//              StepForward(syncPt, a, num);
                for(uint32_t i=0; i<num; i++)
                {
                        a[i] = (double)Global::wave[sNum[i]][syncPt[i]];
                        syncPt[i]++;
                }

                double mean;
                double sigma = StdDeviation(a, num, &mean);

                if (sigma <= SIGMA_THRESHOLD)
                {
                        synthWave[swLen] = (uint32_t)(mean + 0.5);
                        swAmplitude[swLen] = 1.0f;
                        swLen++;
                }
                else
                {
                        Global::bloops++;
                        // The basic idea is to find the extent of this anomalous region and then use what's there as an amplitude by summing the signals where they correspond.
                        uint32_t syncSteps = 0;
                        uint32_t lookahead = LookaheadWave(syncPt, num);

                        // Basically we move forward thru the area until either 1) the sigma is OK, or 2) we've pulled everything as far as it can go and thus this becomes our new local start. 3) will go in at some point which is, do a lookahead and see what the sigma looks like; if it's good and the current one is stinko, (not *too* stinko) then we've found a new local start point, otherwise keep going.
/*
Note that 3) works OK to get out of sticky situations, but sometimes the signals are fairly noisy and you will end up in situations where the lookahead is zero and the next sigma isn't great (& the current isn't any good either), but using that as the new local start is OK and will permit walking forward/backward through the stream.  Some of the time you will find the average of the current sigma and the following will be below the threshold with a good lookahead value (10, 100, 1000), this is also a good time to set the new local start.
*/
#ifdef NOISY
printf("a: ");
for(uint32_t i=0; i<num; i++)
        printf("[%.2lf]", a[i]);
//printf(" => %.2lf {drift=%.2lf, la=%d}\n", sigma, driftSigma, lookahead);
printf(" => %.2lf {la=%d}\n", sigma, lookahead);

for(uint32_t j=0; j<num; j++) { printf("{%d}%s", syncPt[j], (j < num - 1 ? "-" : "")); }
printf("\n");//*/
#endif
                        bool keepWorking = true;

                        do
                        {
                                syncSteps++;

                                // If we've been in this loop too long, something's very wrong
                                if (syncSteps > 20)
                                        return swLen;

                                // Pull the lesser streams forward to catch up to the largest
                                uint32_t largestIdx = LargestIndex(a, num);
                                bool pulled = false;

                                for(uint32_t i=0; i<num; i++)
                                {
                                        if (i == largestIdx)
#ifdef NOISY
                                        {
                                                printf("  ~~~~  ");
#endif
                                                continue;
#ifdef NOISY
                                        }
#endif
//                                      if ((a[largestIdx] - a[i]) > 7.0)
                                        if ((a[largestIdx] - a[i]) > 9.0)
                                        {
                                                pulled = true;
                                                a[i] += (double)Global::wave[sNum[i]][syncPt[i]];
#ifdef NOISY
                                                printf(" %6d ", Global::wave[sNum[i]][syncPt[i]]);
#endif
                                                syncPt[i]++;
                                        }
#ifdef NOISY
                                        else
                                                printf("        ");
#endif
                                        // See if we've run out of stream to synthesize...
                                        if (syncPt[i] >= Global::waveLen[sNum[i]])
                                                return swLen;
                                }

#ifdef NOISY
                                printf("\n");

                                for(uint32_t i=0; i<num; i++)
                                        printf("<%6.2lf>", a[i]);
#endif
                                // Calculate the standard deviation at this new point
                                sigma = StdDeviation(a, num);//, &mean);

                                // Calculate the following sigma & lookahead too
                                for(uint32_t i=0; i<num; i++)
                                        b[i] = (double)Global::wave[sNum[i]][syncPt[i]];

                                double nextSigma = StdDeviation(b, num);
                                lookahead = LookaheadWave(syncPt, num);
#ifdef NOISY
                                printf(" ==> %.2lf%s", sigma, (sigma <= SIGMA_THRESHOLD ? " (OK)" : (!pulled ? "(STEP)" : "")));
                                printf(" (lookahead=%.2lf, %d)\n", nextSigma, lookahead);

for(uint32_t j=0; j<num; j++) { printf("{%d}%s", syncPt[j], (j < num - 1 ? "-" : "")); }
printf("\n");//*/
#endif
                                // A handful of heuristics.  If the sigma is OK, we're done
                                if (sigma < 2.5)
                                        keepWorking = false;

                                // If we couldn't pull any streams forward for some reason, punt
                                if (!pulled)
                                        keepWorking = false;

                                // If the average of the current & next sigmas is OK, go ahead
                                if (((sigma + nextSigma) / 2.0) < 2.5)
                                        keepWorking = false;

                                // If the next sigma is OK and the lookahead too, move on
                                if ((nextSigma < 2.5) && (lookahead > 10))
                                        keepWorking = false;
                        }
                        while (keepWorking);

                        // Now, we've re-established sync, now fill the appropriate spots

/*
So the algorithm to do this proppaly is like so:

Step 1: Find the smallest step forward through the section; set amplitude to 0.2.
Step 2: Loop thru the other streams and see if they correspond.  If so, advance their stream start & add 0.2 to the amplitude for each one seen.
Step 3: Add the mean value of the corresponding values to the synthesized waveform + wave amplitude
Step 4: If all of the stream starts are at the end of the section, we are done.
[maybe.  how do you handle the case where you have streams that look like so:

200
150 50
150 50
175 25
200

.......................................|
.............................|.........|
.............................|.........|
..................................|....|
.......................................|

this will fail to add in the correct amount for the times that had no part in the anomaly.  so to fix this, maybe have a baseline value that bumps upward to show where the "cursor" (so to speak) is, so at the end we can subtract the mean that we got above from this baseline to get the remaining time to synthesize, like so:

synthWave[swLen] = (uint32_t)((mean - baseline) + 0.5)
swAmplitude[swLen] = amplitude;

no need for that.  the times that step directly to the end can safely be ignored.
]

150 -> 150 (ignores 175)
150 goes in, ampl. .4, we now have:

200
50
50
175 25
200

only one is left that we can grab:

175

last pulse was at 150 (40%), so we need to subtract that out

-> 25

so maybe we'd do like so:
-1) create a list containing the start values for the start of the anomalous section and replace them as the counters advance.
0) are streams at the end? if so, stuff in the final value to the synthesized wave & stop, otherwise:
1) find the smallest in the current row and use that as a basis.
2) find streams that correlate, if any
3) advance the streams that correlate & subtract out the minimum from the other rows
4) go to 0)

200
150 50
150 50
175 25
200

smallest is 150: pick 150 -> picks up 150
advance the 150 rows & subtract 150 from the rest:

50
50
50
25 25
50

pick smallest: 25 -> picks up nothing
advance the 25 & subtract it from the rest:

25
25
25
25
25

We've reached the end of the section, add the final amount

--------------------------------------------------------------------------------
syncSave before: [2->4][2->6][2->4][2->6][2->6]
syncSave after: [3->4][3->6][3->4][3->6][3->6]

currentRow: [120.89][49.97][46.98][49.98][48.98] => 28.78

2: [3->4][3->6][3->4][3->6][3->6]

a[0]=46.98: [120.89] ==> 36.95
        [49.97]{17.00} ==> 1.50
        <106.00>[49.97][49.98]{28.00} ==> 1.41
        [49.97][49.98][48.98]{26.00} ==> 1.22

3: [3->4][4->6][4->4][4->6][4->6]

a[0]=17.00: [73.91] ==> 28.45
        <56.00>[28.00]{45.00} ==> 5.50
        [28.00][26.00]{47.00} ==> 4.78

4: [3->4][5->6][4->4][5->6][5->6]

a[0]=45.00: [56.91] ==> 5.95
        [56.00]{32.00} ==> 5.50
        <32.00>[56.00][47.00]{32.00} ==> 4.78

5: [3->4][6->6][4->4][6->6][6->6]

a[0]=11.91: <32.00>

6: [4->4][6->6][4->4][6->6][6->6]

 2->4    2->6    2->4    2->6    2->6
[120.89][ 49.97][ 46.98][ 49.98][ 48.98] => 28.78
( 73.91)  17.00  106.00   28.00   26.00
( 56.91)  56.00           45.00   47.00
  32.00   32.00           32.00   32.00

*/
#ifdef NOISY
/*printf("syncSave before: ");
for(uint32_t i=0; i<num; i++)
        printf("[%d->%d]", syncSave[i], syncPt[i]);
printf("\n");//*/

for(uint32_t i=0; i<num; i++)
{
        printf("Sync %d: %d -> %d (", sNum[i], syncSave[i], syncPt[i]);
        for(uint32_t j=syncSave[i]; j<=syncPt[i]; j++)
                printf("%d%s", Global::wave[sNum[i]][j], (j == syncPt[i] ? "" : ", "));
        printf(")\n");
}
#endif
                        // Collect the current row
                        for(uint32_t i=0; i<num; i++)
                        {
                                currentRow[i] = (double)Global::wave[sNum[i]][syncSave[i]];
                                syncSave[i]++;
                        }

/*printf("syncSave after: ");
for(uint32_t i=0; i<num; i++)
        printf("[%d->%d]", syncSave[i], syncPt[i]);
printf("\n");
printf("currentRow: ");
for(uint32_t i=0; i<num; i++)
        printf("[%.2lf]", currentRow[i]);
printf(" => %.2lf\n", StdDeviation(currentRow, num));//*/

//printf("%d: ", swLen);

                        float ampStep = 1.0f / (float)num;

                        while (true)
                        {
                                if (Equal(syncSave, syncPt, num))
                                        break;

                                float amplitude = ampStep;
                                uint32_t smallestIdx = SmallestIndex(currentRow, num);
                                uint32_t cnt = 1;
                                a[0] = currentRow[smallestIdx];
//printf("a[0]=%.2lf: ", a[0]);

                                for(uint32_t i=0; i<num; i++)
                                {
                                        // Make sure we haven't gone beyond the end of any of the streams we're looking at
                                        if (syncSave[i] >= Global::streamLen[i])
                                                return swLen;

                                        if (i == smallestIdx)
                                        {
                                                // We always pick up the smallest in the current set, since that's our basis
                                                currentRow[i] = (double)Global::wave[sNum[i]][syncSave[i]];
                                                syncSave[i]++;
//printf("<%.2lf>", currentRow[i]);
                                                continue;
                                        }

                                        // Save the current row & subtract out the smallest as a basis
                                        double crSave = currentRow[i];
                                        currentRow[i] -= a[0];

                                        // Don't bother with stuff that's out of range (@ current sync point!)  :-P
                                        if (syncSave[i] == syncPt[i])
                                                continue;

                                        // Try to find correlates
                                        a[cnt] = crSave;
                                        cnt++;
                                        sigma = StdDeviation(a, cnt);
//for(uint32_t j=1; j<cnt; j++)
//      printf("[%.2lf]", a[j]);

//relaxed sigma...
                                        if (sigma <= 5.5)//SIGMA_THRESHOLD)
                                        {
                                                // If the sigma is in range for this item, pick it up
                                                currentRow[i] = (double)Global::wave[sNum[i]][syncSave[i]];
                                                syncSave[i]++;

//printf("{%.2lf}", currentRow[i]);
                                                amplitude += ampStep;
                                        }
                                        else
                                        {
                                                // Otherwise reject the last item; it's too far out
                                                cnt--;
                                        }
//printf(" ==> %.2lf\n\t", sigma);
                                }

                                // Get the average of the items picked up and add it to the wave
                                sigma = StdDeviation(a, cnt, &mean);
                                synthWave[swLen] = (uint32_t)(mean + 0.5);
                                swAmplitude[swLen] = amplitude;
                                swLen++;
                        }

                        sigma = StdDeviation(currentRow, num, &mean);
                        synthWave[swLen] = mean;
                        swAmplitude[swLen] = 1.0f;
                        swLen++;
                }
        }

        return swLen;
}
#endif


bool ResyncWave(uint32_t * sync, uint32_t num, int8_t dir/*= 1*/)
{
        double a[6];

        for(uint32_t i=0; i<num; i++)
        {
                a[i] = (double)Global::wave[sNum[i]][sync[i]];
                sync[i] += dir;
        }

#ifdef NOISY
        for(uint32_t i=0; i<num; i++)
                printf("<%4d>", (uint32_t)a[i]);

        printf(" {la: %d}\n", LookaheadWave(sync, num, dir));
#endif

        uint32_t syncCount = 0;
        bool keepGoing = true;

        do
        {
                if (syncCount > 42)
                {
                        printf("Could not synchronize streams...\n");
                        return false;
                }

                for(uint32_t i=0; i<num; i++)
                {
                        if (((dir == 1) && (sync[i] >= Global::waveLen[sNum[i]]))
                                || ((dir == -1) && (sync[i] == 0)))
                        {
                                printf("End of stream...\n");
                                return true;
                        }
                }

                // Deal with the problem.  The heuristic is find the largest value in the set, then advance the other streams by one step until they are "close" to the largest.  If the std. deviation is too large, try again; eventually it should be within good limits.
                uint32_t largestIdx = LargestIndex(a, num);
                bool stepped = false;

                for(uint32_t i=0; i<num; i++)
                {
                        if (i == largestIdx)
#ifdef NOISY
                        {
                                printf(" ~~~~ ");
#endif
                                continue;
#ifdef NOISY
                        }
#endif

                        // If the difference between the highest and this is over 7, add the next time interval and let the sync counter, uh, slip :-)
//                      if ((a[largestIdx] - a[i]) > 7.0)
                        if ((a[largestIdx] - a[i]) > 9.0)
                        {
                                stepped = true;
                                double ttn = (double)Global::wave[sNum[i]][sync[i]];
                                a[i] += ttn;
                                sync[i] += dir;
#ifdef NOISY
                                printf(" %4d ", (uint32_t)ttn);
#endif
                        }
#ifdef NOISY
                        else
                                printf("      ");
#endif
                }

                double sigma = StdDeviation(a, num);
                double nextSigma = StdDeviationWave(sync, num);
                uint32_t lookahead = LookaheadWave(sync, num, dir);
#ifdef NOISY
                printf("\n");

                for(uint32_t i=0; i<num; i++)
                        printf("<%4d>", (uint32_t)a[i]);

                printf(" ==> %.2lf ", sigma);
                printf("(next: %.2lf, la: %d)\n", nextSigma, lookahead);
#endif
                syncCount++;

                // A handful of heuristics...  1st: If sigma is good, we're done
                if (sigma < 2.50)
                        keepGoing = false;

                // Couldn't pull, so punt for now
                if (!stepped)
                        keepGoing = false;

                // If the next sigma + current / 2 is OK, move on
                if (((sigma + nextSigma) / 2.0) < 2.50)
                        keepGoing = false;

                // If the next sigma is good, and the lookahead is good, move on
                // [Slight tweak: only do this if the current sigma isn't terrible]
                if ((nextSigma < 2.50) && (lookahead > 10) && (sigma < 20.0))
                        keepGoing = false;
        }
        while (keepGoing);

        return true;
}


uint32_t LookaheadWave(uint32_t * passedInSync, uint32_t num, int8_t dir/*= 1*/, bool * perfect/*= NULL*/)
{
        uint32_t sync[6];
        uint32_t count = 0;
        memcpy(sync, passedInSync, sizeof(sync));

        if (perfect)
                *perfect = true;

        while (true)
        {
                if (StdDeviationWave(sync, num) > 2.50)
                {
                        if (perfect)
                                *perfect = false;

                        break;
                }

                for(uint32_t i=0; i<num; i++)
                {
                        sync[i] += dir;

                        if (((dir == 1) && (sync[i] >= Global::waveLen[sNum[i]]))
                                || ((dir == -1) && (sync[i] == 0)))
                                return count;
                }

                count++;
        }

        return count;
}


uint32_t FindSyncBetweenFirstTwo(uint32_t * sync)
{
        uint32_t bestSync[2], bestLA = 0, syncSave = sync[0];
        bool perfect;

        // Move the first stream first...
        for(uint32_t i=0; i<200; i++)
        {
                uint32_t la = LookaheadWave(sync, 2, 1, &perfect);

                // See if the sync we've found is the best so far...
                if (la > bestLA)
                {
                        bestLA = la;
                        memcpy(bestSync, sync, sizeof(bestSync));
                }

                if (perfect)
                        break;

                sync[0]++;
        }

        // Otherwise, reset the first stream and move the 2nd
        sync[0] = syncSave;

        for(uint32_t i=0; i<200; i++)
        {
                // We can bump this first since we already checked the [0][0] case above
                sync[1]++;
                uint32_t la = LookaheadWave(sync, 2, 1, &perfect);

                // See if the sync we've found is the best so far...
                if (la > bestLA)
                {
                        bestLA = la;
                        memcpy(bestSync, sync, sizeof(bestSync));
                }

                if (perfect)
                        break;
        }

        // Set sync to the best we found & return the best lookahead count
        memcpy(sync, bestSync, sizeof(bestSync));

        return bestLA;
}


//
// Walk backwards through the streams to try to find the starting point
//
bool AttemptToFindStart(uint32_t * sync, uint32_t num)
{
        // Sanity check...
        for(uint32_t i=0; i<num; i++)
        {
                if (sync[i] == 0)
                        return true;
        }

        bool keepGoing = true;

        do
        {
                double sigma = StdDeviationWave(sync, num);

                if (sigma > 2.50)
                {
                        bool result = ResyncWave(sync, num, -1);

                        if (result == false)
                                return false;
                }
                else
                {
                        for(uint32_t i=0; i<num; i++)
                                sync[i]--;
                }

                for(uint32_t i=0; i<num; i++)
                {
                        if (sync[i] == 0)
                                keepGoing = false;
                }
        }
        while (keepGoing);

//#ifdef NOISY
#if 1
        for(uint32_t i=0; i<num; i++)
                printf("Sync for stream %d: %d\n", i, sync[i]);
        printf("Lookahead: %d\n", LookaheadWave(sync, num));
#endif

        return true;
}


bool InitialSync(uint32_t * sync, uint32_t num)
{
        // Let's try a different approach to this...
        bool lookAt[6] = { true, true, false, false, false, false };
        uint32_t syncSave[2];

//      while (FindSyncBetweenFirstTwo(sync) == false)
//      while (FindSyncBetweenFirstTwo(sync) < 1000)
        while (true)
        {
                memcpy(syncSave, sync, sizeof(syncSave));
                uint32_t bestSBFT = FindSyncBetweenFirstTwo(sync);

                if (bestSBFT >= 1000)
                        break;

                memcpy(sync, syncSave, sizeof(syncSave));

                for(uint32_t i=0; i<num; i++)
                {
                        sync[i] += 200;

                        if (sync[i] >= Global::waveLen[sNum[i]])
                        {
                                printf("Could not find initial sync!!\n");
                                return false;
                        }
                }
        }

        uint32_t lookahead = LookaheadWave(sync, 2);

        if (lookAt[0])
                printf("Found sync for streams 1 & 2 at %d and %d (la=%d)\n", sync[0], sync[1], lookahead);

        // Add in the others, one at a time and try to synchronize them
        uint32_t syncBest[6];
        bool perfect;

        for(uint32_t i=2; i<num; i++)
        {
                lookAt[i] = true;
                uint32_t bestLA = 0;

                for(uint32_t j=0; j<200; j++)
                {
                        uint32_t syncSave = sync[i];

                        for(uint32_t k=0; k<200; k++)
                        {
                                uint32_t la = LookaheadWave(sync, i + 1, 1, &perfect);

                                if (la > bestLA)
                                {
                                        bestLA = la;
                                        memcpy(syncBest, sync, sizeof(syncBest));
                                }

                                if (perfect || ((bestLA + j) == lookahead))
                                {
                                        j = 200;
                                        break;
                                }

                                sync[i]++;
                        }

                        sync[i] = syncSave;

                        // Kick all the other streams forward to check the rest...
                        for(uint32_t k=0; k<i; k++)
                                sync[k]++;
                }

                memcpy(sync, syncBest, sizeof(syncBest));
        }

        for(uint32_t i=0; i<num; i++)
                printf("Sync for stream %d: %d (%s)\n", i, sync[i], (lookAt[i] ? "yes" : "no"));
        printf("Lookahead: %d\n", LookaheadWave(sync, num));

        return true;
}


uint32_t LoopLookahead(uint32_t trackNum, uint32_t start, uint32_t loopPoint, bool * test/*= NULL*/)
{
        uint32_t count = 0;
        bool equal = true;
        double a[2];

        for(uint32_t i=loopPoint, pos=start; i<Global::synWaveLen[trackNum]; i++, pos++)
        {
                a[0] = Global::synWave[trackNum][pos];
                a[1] = Global::synWave[trackNum][i];
                double sigma = StdDeviation(a, 2);

                if (sigma > 2.50)
                {
                        equal = false;
                        break;
                }

                count++;
        }

        if (test)
                *test = equal;

        return count;
}


#define NOISYSYNTH
//#define DEBUGSYNTH
void SynthesizeTrack(uint32_t trackNum)
{
        uint32_t num = 0;
        uint32_t sync[6] = { 0 };

        for(uint32_t i=0; i<Global::numStreams; i++)
        {
                // Skip streams that aren't on the current track & BITS captures
                if ((Global::stream[i]->location != trackNum)
                        || (Global::stream[i]->captureType == 2))
                        continue;

#ifdef DEBUGSYNTH
printf("sNum[%d] = %d\n", num, i);
#endif
                // Save the stream # so we can find it later
                sNum[num++] = i;
        }

        // We should just bypass the synthesis part of this, not the loop point finding...  :-P  !!! FIX !!!
        if (num == 1)
        {
                printf("%.2f: Single stream, length: %d\n", (float) trackNum / 4.0f, Uint32LE(Global::stream[sNum[0]]->dataLength));

                memcpy(Global::synWave[trackNum], Global::wave[sNum[0]], Global::waveLen[sNum[0]] * 4);
                Global::synWaveLen[trackNum] = Global::waveLen[sNum[0]];
        }

/*
This is failing for track 9.00: it finds an initial sync @ 202, 200, la=1257 but real sync point is 0,2,2 (it says 5,0,0, which is wrong)
*/
        if (num > 1)
        {
                InitialSync(sync, num);
                AttemptToFindStart(sync, num);

                uint32_t count = 0, bloops = 0;
                bool keepGoing = true;
                Global::synWaveLen[trackNum] = 0;
                double mean;

                do
                {
                        double sigma = StdDeviationWave(sync, num, &mean);

                        if (sigma <= 2.50)
                        {
                                count++;
                                Global::synWave[trackNum][Global::synWaveLen[trackNum]] = (uint32_t)(mean + 0.5);
                                Global::synWaveLen[trackNum]++;

                                for(uint32_t i=0; i<num; i++)
                                        sync[i]++;
                        }
                        else
                        {
#ifdef NOISYSYNTH
                                uint32_t startOfSynth = Global::synWaveLen[trackNum];
#endif
#ifdef NOISYSYNTH
                                if (bloops < 2)
                                {
                                        printf("Bloop seen at pos ");
                                        for(uint32_t k=0; k<num; k++)
                                                printf("%d%s", sync[k], (k == num - 1 ? "" : ", "));
                                        printf("...\n");
                                }
#endif
                                bloops++;       // Count the # of times we've had to punt
                                uint32_t syncSave[6] = { 0 };
                                memcpy(syncSave, sync, sizeof(syncSave));
                                /*bool result =*/ ResyncWave(sync, num);

                                // Now go through the catty wampus crap and zero out the parts that aren't all ones across the board
                                double timeToOnes = 0;
                                double a[6], currentRow[6];

                                // Collect the current row
                                for(uint32_t i=0; i<num; i++)
                                {
                                        currentRow[i] = (double)Global::wave[sNum[i]][syncSave[i]];
                                        syncSave[i]++;
                                }
#ifdef DEBUGSYNTH
for(uint32_t i=0; i<num; i++)
        printf("syncSave[%d]=%d (sync: %d)\n", i, syncSave[i], sync[i]);
#endif

                                while (true)
                                {
                                        if (Equal(syncSave, sync, num))
                                                break;
#ifdef DEBUGSYNTH
printf("syncSave: ");
for(uint32_t i=0; i<num; i++)
        printf("%d%s", syncSave[i], (i == num - 1 ? "" : ", "));
printf("\n    sync: ");
for(uint32_t i=0; i<num; i++)
        printf("%d%s", sync[i], (i == num - 1 ? "" : ", "));
printf("\n");
#endif

                                        uint32_t amplitude = 1;
                                        uint32_t smallestIdx = SmallestIndex(currentRow, num);
                                        uint32_t cnt = 1;
                                        a[0] = currentRow[smallestIdx];
#ifdef DEBUGSYNTH
printf("a[0]=%.2lf:\n", a[0]);
#endif

                                        for(uint32_t i=0; i<num; i++)
                                        {
                                                // Make sure we haven't gone beyond the end of any of the streams we're looking at
                                                if (syncSave[i] >= Global::waveLen[sNum[i]])
                                                {
                                                        printf("Ran past end of stream %d (stream %d): syncSave=%d, waveLen=%d\n", i, sNum[i], syncSave[i], Global::waveLen[sNum[i]]);
                                                        return;
                                                }

                                                if (i == smallestIdx)
                                                {
                                                        // Maybe we should chuck this above the if()?
//                                                      if (syncSave[i] == sync[i])
//                                                              continue;

                                                        // We always pick up the smallest in the current set, since that's our basis
//the reason this works is because this simulates the "add next and subtract smallest", since the subtraction of the smallest would always be zero.  :-P
                                                        currentRow[i] = Global::wave[sNum[i]][syncSave[i]];
//                                                      currentRow[i] += Global::wave[sNum[i]][syncSave[i]];
                                                        syncSave[i]++;
#ifdef DEBUGSYNTH
printf("\t<%.2lf> (i=%d)\n", currentRow[i], i);
#endif
                                                        continue;
                                                }

                                                // Save the current row & subtract out the smallest as a basis
                                                double crSave = currentRow[i];
                                                currentRow[i] -= a[0];

                                                // Don't bother with stuff that's out of range (@ current sync point!)  :-P
                                                if (syncSave[i] == sync[i])
                                                        continue;

                                                // Try to find correlates
                                                a[cnt] = crSave;
                                                cnt++;
                                                sigma = StdDeviation(a, cnt);
#ifdef DEBUGSYNTH
printf("\t");
for(uint32_t j=1; j<cnt; j++)
        printf("[%.2lf]", a[j]);
#endif

//relaxed sigma...
                                                if (sigma <= 5.5)//SIGMA_THRESHOLD)
                                                {
                                                        // If the sigma is in range for this item, pick it up
                                                        currentRow[i] += (double)Global::wave[sNum[i]][syncSave[i]];
                                                        syncSave[i]++;

#ifdef DEBUGSYNTH
printf("{%.2lf}", currentRow[i]);
#endif
                                                        amplitude++;
                                                }
                                                else
                                                {
                                                        // Otherwise reject the last item; it's too far out
                                                        cnt--;
                                                }
#ifdef DEBUGSYNTH
printf(" ==> %.2lf\n", sigma);
#endif
                                        }

                                        // Get the average of the items picked up and add it to the wave
                                        sigma = StdDeviation(a, cnt, &mean);
                                        timeToOnes += mean;

                                        // Did we find the line of ones yet?  If so, chuck it in the wave
                                        if (amplitude == num)
                                        {
                                                Global::synWave[trackNum][Global::synWaveLen[trackNum]] = (uint32_t)(timeToOnes + 0.5);
                                                Global::synWaveLen[trackNum]++;
                                                timeToOnes = 0;
                                        }
#ifdef DEBUGSYNTH
printf("\t");
for(uint32_t j=0; j<num; j++)
        printf("_%.2lf_", currentRow[j]);
printf("\n\n");
#endif
                                }

                                // Finally, chuck the final line of ones in
                                sigma = StdDeviation(currentRow, num, &mean);
                                timeToOnes += mean;
                                Global::synWave[trackNum][Global::synWaveLen[trackNum]] = (uint32_t)(timeToOnes + 0.5);
                                Global::synWaveLen[trackNum]++;
#ifdef NOISYSYNTH
printf("Blip @ %d: ", startOfSynth);
for(uint32_t w=startOfSynth; w<Global::synWaveLen[trackNum]; w++)
        printf("%d%s", Global::synWave[trackNum][w], (w == Global::synWaveLen[trackNum] - 1 ? "" : ", "));
printf("\n");
#endif
                        }

                        for(uint32_t i=0; i<num; i++)
                        {
                                if (sync[i] >= Global::waveLen[sNum[i]])
                                {
                                        keepGoing = false;
                                        break;
                                }
                        }
                }
                while (keepGoing);

                printf("\n%.2f: Synthesis done. Bit count: %d, bloop count: %d\n", (float)trackNum / 4.0f, count, bloops);
        }

        printf("%.2f: Synthesized wave length: %d\n", (float)trackNum / 4.0f    , Global::synWaveLen[trackNum]);

        // Now, find the loop point and make BITS from it
/*
Now, we take the track and make an ouroborus out of it by finding the sync point.  We can also possibly use it to get rid of more false ones like we did above with the resynchronization code.  So how do we do this?

We could use an approach similar to the original sync between 1 & 2, but there's no guarantee that the lookahead will be good right away.  So we need to do a combination where we count the places where it coincides well and plow through spots where it doesn't (and possibly mask any ones in those areas if it's a good match).

We can start with the estimated loop point that the Applesauce hardware found, by walking it a bit before that point we can make sure we don't miss it.
*/
        uint32_t loopStart, loopEnd;
        bool perfect = FindLoopPoint(trackNum, loopStart, loopEnd);
#if 0
        // We use the loop point from stream #1 because we're lazy
        uint32_t estLoopTime = Uint32LE(Global::stream[sNum[0]]->estLoopPoint);
        uint32_t curTime = 0;
        uint32_t pos = 0, startOfLoop = 0;
        double a[2];
        uint32_t maxLookahead = 0;
        uint32_t maxPos = 0;
        bool /*full, full2,*/ full0, full1;
        uint32_t blips, worstBlips = 0, longestStretch, stretch, maxLongestStretch = 0, worstBlipsPos = 0, mlsPos = 0;
        worstBlips = 1e9;

        // Get the index to the correct time in "pos"
        while (curTime < estLoopTime)
                curTime += Global::synWave[trackNum][pos++];

printf("%.2f: estLoopTime=%d, curTime=%d, pos=%d\n", (float)trackNum / 4.0f, estLoopTime, curTime, pos);
        uint32_t posSave = pos;

        // First, see if we have basically a perfect loop out of the box (typically, all $AAs)
        bool perfect;
        mlsPos = pos;
        worstBlipsPos = pos;
        maxPos = pos;
        maxLongestStretch = LoopLookahead(trackNum, 0, pos, &perfect);

        if (!perfect)
        {
                worstBlips = 1e9;

                // "pos" now holds the start of the search for our loop point.
                for(uint32_t i=0; i<200; i++)
                {
                        uint32_t lookahead = 0;
                        uint32_t j, pos0;
                        bool first = true;
                        blips = 0;
                        longestStretch = stretch = 0;
                        startOfLoop = 0;//shouldn't be necessary...

                        for(j=(pos+i-100), pos0=0; j<Global::synWaveLen[trackNum]; j++, pos0++)
                        {
                                uint32_t lla0 = LoopLookahead(trackNum, pos0 + 0, j, &full0);
                                uint32_t lla1 = LoopLookahead(trackNum, pos0 + 1, j, &full1);

                                lookahead += lla0;
                                stretch = lla0;

                                if (stretch > longestStretch)
                                        longestStretch = stretch;

                                if (full0)
                                {
                                        break;
                                }
                                else if (full1 && first) // only check 1st time (for now)
                                {
                                        startOfLoop = 1;
                                        lookahead = lla1;
                                        stretch = lla1;
                                        break;
                                }

                                if (first)
                                        first = false;

                                pos0 += lla0;
                                j += lla0;

                                a[0] = Global::synWave[trackNum][pos0++];
                                a[1] = Global::synWave[trackNum][j++];

#if 0
                                double sigma = StdDeviation(a, 2);

if (first)
{
        first = false;
//      printf("First blip: %.0lf, %.0lf (sigma=%.2lf) [pos=%d, la=%d]\n", a[0], a[1], sigma, i + pos - 100, pos0);

        if (trackNum == 137)
        {
                uint32_t lla = LoopLookahead(trackNum, 0, j, &full);
                uint32_t llap1 = LoopLookahead(trackNum, 1, j, &full2);
                printf("%.2f: pos0=%d, j=%d, sigma=%lf, la=%d%s, la+1=%d%s", (float)trackNum / 4.0f, pos0, j, sigma, lla, (full ? " *equal" : ""), llap1, (full2 ? " *equal" : ""));
        }
}
#endif

                                // Hmm, not in sync.  See if we can re-sync
                                stretch = 0;
                                blips++;

                                do
                                {
                                        if (a[0] < a[1])
                                                a[0] += Global::synWave[trackNum][pos0++];
                                        else
                                                a[1] += Global::synWave[trackNum][j++];

                                        // Maybe put all the other heuristics in too?
                                        if (StdDeviation(a, 2) <= 2.50)
                                                break;

                                        // Now you've gone *too* far...
                                        if (j >= Global::synWaveLen[trackNum])
                                                break;
                                }
                                while (true);
                        }

#if 0
if (trackNum == 137)
        printf(" blips=%d, la=%d\n", blips, lookahead);
#endif

//maybe we should keep an array of the analyses so we can decide afterward which one is best...
                        if (blips < worstBlips)
                        {
                                worstBlips = blips;
                                worstBlipsPos = pos + i - 100;
                        }

                        if (lookahead > maxLookahead)
                        {
                                maxLookahead = lookahead;
                                maxPos = pos + i - 100;
                        }

                        if (longestStretch > maxLongestStretch)
                        {
                                maxLongestStretch = longestStretch;
                                mlsPos = pos + i - 100;
                        }

                        if (blips == 0)
                                break;
                }
        }
#endif

#if 0
        bitLen[trackNum] = RenderBitstream(bits[trackNum], &byteLen[trackNum], Global::synWave[trackNum], startOfLoop, maxPos);
#endif

        if (perfect)
        {
                uint32_t estLoopTime = Uint32LE(Global::stream[sNum[0]]->estLoopPoint);
                uint32_t pos = IndexForTime(trackNum, estLoopTime);
                printf("Perfect loop point found at position %d (elp%+d, start=%d, end=%d)\n----------------------------------------------------------------------\n", loopEnd + 1, loopEnd + 1 - pos, loopStart, loopEnd);
        }
#if 0
        printf("%s loop point found at position %d (elp%+d, la=%d, startPos=%d, blips=%d, blipsPos=%d, longest stretch=%d, mlsPos=%d, sol=%d)\n----------------------------------------------------------------------\n", (blips == 0 ? "Perfect" : "Possible"), maxPos, maxPos - posSave, maxLookahead, pos, worstBlips, worstBlipsPos, maxLongestStretch, mlsPos, startOfLoop);
#endif
/*
Track 1.00:
36110 is the loop point.  But it fails to find it for some reason. [Because it jumped on the first one it found instead of the longest...]
*/

/*      for(uint32_t i=0; i<maxLookahead+5; i++)
        {
                a[0] = Global::synWave[trackNum][i];
                a[1] = Global::synWave[trackNum][i + maxPos];
                double sigma = StdDeviation(a, 2);
                printf("[%.2lf]", sigma);
        }

        printf("\n");//*/
}


//
// Attempt to find where the track loop is.  Passes back what it thinks they
// are in start and end.
//
bool FindLoopPoint(uint32_t trackNum, uint32_t & start, uint32_t & end)
{
/*
Now, we take the track and make an ouroborus out of it by finding the sync point.  We can also possibly use it to get rid of more false ones like we did with the resynchronization code.  So how do we do this?

We could use an approach similar to the original sync between 1 & 2, but there's no guarantee that the lookahead will be good right away.  So we need to do a combination where we count the places where it coincides well and plow through spots where it doesn't (and possibly mask any ones in those areas if it's a good match).

We can start with the estimated loop point that the Applesauce hardware found, by walking it a bit before that point we can make sure we don't miss it.
*/
        // We use the loop point from stream #1 because we're lazy (better would prolly be to take the average of all of them)
        uint32_t estLoopTime = Uint32LE(Global::stream[sNum[0]]->estLoopPoint);
        uint32_t pos = IndexForTime(trackNum, estLoopTime);
        uint32_t posSave = pos;

        bool full0, full1, perfect;

printf("%.2f: estLoopTime=%d, pos=%d\n", (float)trackNum / 4.0f, estLoopTime, pos);

        // First, see if we have basically a perfect loop out of the box
        // (typically, a track of all $AAs)
        LoopLookahead(trackNum, 0, pos, &perfect);

        if (perfect)
        {
                start = 0;
                end = pos - 1;
                return true;
        }

        uint32_t bestMatchCount = 0, bestBlips = 1e9, longestStretch = 0;
        uint32_t bestMatchCountPos = 0, bestBlipsPos = 0, longestStretchPos = 0;

        // "pos" now holds the start of the search for our loop point.
        // Step from -99 to +99 around "pos" to find the loop point.  If the input wave is very noisy, this might fail!
        for(int32_t i=-99; i<100; i++)
        {
                uint32_t matchCount = 0;
                uint32_t j, pos0;
                bool first = true;
                uint32_t blips = 0;
                start = 0;

                for(j=pos+i, pos0=0; j<Global::synWaveLen[trackNum]; j++, pos0++)
                {
                        uint32_t lla0 = LoopLookahead(trackNum, pos0 + 0, j, &full0);
/*
We do this because it may be the case that the start of the wave has an extraneous one that doesn't exist near the loop point; this way, we can still get a perfect loop point by skipping that bad one at the start.
*/
                        uint32_t lla1 = LoopLookahead(trackNum, pos0 + 1, j, &full1);

                        // We count the # of successful matches, since there might be spots where it doesn't sync up perfectly--the combination of good matches plus least amount of desyncs ("blips") is what we're looking for
                        matchCount += lla0;

                        if (lla0 > longestStretch)
                        {
                                longestStretch = lla0;
                                longestStretchPos = pos + i;
                        }

                        if (full0)
                        {
                                // If we found perfect sync and it's the first time, return
                                if (blips == 0)
                                {
                                        end = pos + i - 1;
                                        return true;
                                }

                                // Otherwise, just break out of the loop since it might not be the best
                                break;
                        }
                        else if (full1 && first) // only check 1st time (for now)
                        {
                                // Since we found perfect sync, return
                                start = 1;
                                end = pos + i - 1;
                                return true;
                        }

                        if (first)
                                first = false;

                        pos0 += lla0;
                        j += lla0;

                        double a[2];
                        a[0] = Global::synWave[trackNum][pos0++];
                        a[1] = Global::synWave[trackNum][j++];

#if 0
                        double sigma = StdDeviation(a, 2);

if (first)
{
first = false;
//      printf("First blip: %.0lf, %.0lf (sigma=%.2lf) [pos=%d, la=%d]\n", a[0], a[1], sigma, i + pos - 100, pos0);

if (trackNum == 137)
{
        uint32_t lla = LoopLookahead(trackNum, 0, j, &full);
        uint32_t llap1 = LoopLookahead(trackNum, 1, j, &full2);
        printf("%.2f: pos0=%d, j=%d, sigma=%lf, la=%d%s, la+1=%d%s", (float)trackNum / 4.0f, pos0, j, sigma, lla, (full ? " *equal" : ""), llap1, (full2 ? " *equal" : ""));
}
}
#endif

                        // Hmm, not in sync.  See if we can re-sync
                        blips++;

                        do
                        {
                                if (a[0] < a[1])
                                        a[0] += Global::synWave[trackNum][pos0++];
                                else
                                        a[1] += Global::synWave[trackNum][j++];

                                // Maybe put all the other heuristics in too?  :-/
                                if ((StdDeviation(a, 2) <= 2.50)
                                        || (j >= Global::synWaveLen[trackNum]))
                                        break;
                        }
                        while (true);
                }

#if 0
if (trackNum == 137)
printf(" blips=%d, la=%d\n", blips, matchCount);
#endif

//maybe we should keep an array of the analyses so we can decide afterward which one is best... probably not necessary...
                if (blips < bestBlips)
                {
                        bestBlips = blips;
                        bestBlipsPos = pos + i;
                }

                if (matchCount > bestMatchCount)
                {
                        bestMatchCount = matchCount;
                        bestMatchCountPos = pos + i;
                }

                // Did we find a perfect lookahead? If so, we're done.
//              if (blips == 0)
//                      break;
        }

        // Now we're done trying to fit the loop, and we didn't find a perfect one, so set up the best we found:
        end = bestMatchCountPos - 1;
#if 1
uint32_t possibleCoverage = Global::synWaveLen[trackNum] - pos;
printf("Possible loop point found at position %d (elp%+d, bestMatchCount=%d (out of %d, %.1f%%), startPos=%d, blips=%d, blipsPos=%d, longest stretch=%d, mlsPos=%d)\n----------------------------------------------------------------------\n", end + 1, end + 1 - posSave, bestMatchCount, possibleCoverage, ((float)bestMatchCount / (float)possibleCoverage) * 100.0f, pos, bestBlips, bestBlipsPos, longestStretch, longestStretchPos);
#endif
        return false;
}


/*
Using a histogram, we can get an idea of the drift from the ones:

                @@
                @@
                @@
                @@
                @@
                @@
                @@
                @@        @@
                @@        @@
                @@        @@
                @@        @@
                @@        @@
                @@   @@   @@
           @@   @@   @@   @@
           @@   @@   @@   @@
      @@   @@   @@   @@   @@
-------------------------------------------------
0000|0584|1792|9611|2627|5382|0482|0058|0013|0000
 28   29   30   31   32   33   34   35   36   37

Peak of the ones occurs at 31, with a secondary at 33. Twos drift:

                @@
                @@        @@
                @@        @@
                @@        @@
                @@        @@
                @@        @@
                @@        @@
                @@   @@   @@
      @@        @@   @@   @@
-------------------------------------------------
0000|0545|0277|5482|1223|5168|0252|0082|0102|0000
 57   58   59   60   61   62   63   64   65   66

This looks like stretched out ones (they might all be spurious...):

      @@
      @@
      @@             @@
      @@             @@
      @@   @@        @@
      @@   @@        @@
      @@   @@        @@
      @@   @@   @@   @@        @@
---------------------------------------
0000|0015|0007|0002|0011|0001|0002|0000
 43   44   45   46   47   48   49   50


*/