Add support for asymmetric pulse handling like the Software Projects loader.

Author: fmeunier

src/main/java/xyz/meunier/wav2pzx/blocks/PZXDataBlock.java

@@ -25,6 +25,7 @@
  */
 package xyz.meunier.wav2pzx.blocks;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.primitives.Bytes;
 import xyz.meunier.wav2pzx.pulselist.PulseList;
 
@@ -36,6 +37,9 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.ImmutableList.copyOf;
+import static com.google.common.primitives.Longs.asList;
+import static java.lang.Long.valueOf;
 import static xyz.meunier.wav2pzx.blocks.PZXEncodeUtils.*;
 import static xyz.meunier.wav2pzx.romdecoder.LoaderContext.*;
 
@@ -76,30 +80,30 @@ public final class PZXDataBlock implements PZXBlock {
     private final boolean isHeader;
 
     // The length of the zero pulse identified in the source file
-    private final short zeroPulseLength;
+    private final ImmutableList<Long> zeroPulseLengths;
 
     // The length of the one pulse identified in the source file
-    private final short onePulseLength;
+    private final ImmutableList<Long> onePulseLengths;
 
     /**
      * Constructs a new PZXDataBlock.
      * @param newPulses the original tape pulses that have been decoded into this block
-     * @param zeroPulseLength the length of the zero pulses in the block
-     * @param onePulseLength the length of the one pulses in the block
+     * @param zeroPulseLengths the lengths of the zero pulses in the block
+     * @param onePulseLengths the lengths of the one pulses in the block
      * @param tailLength the length of the tail pulse in the block
      * @param numBitsInLastByte the number of bits used in the last byte of the data collection
      * @param data the decoded data from the tape image
      * @throws NullPointerException if newPulses or data is null
      * @throws IllegalArgumentException if data is empty
      */
-    public PZXDataBlock(PulseList newPulses, long zeroPulseLength, long onePulseLength, long tailLength,
+    public PZXDataBlock(PulseList newPulses, List<Long> zeroPulseLengths, List<Long> onePulseLengths, long tailLength,
                         int numBitsInLastByte, Collection<Byte> data) {
         checkNotNull(newPulses, "newPulses must not be null");
         checkNotNull(data, "data must not be null");
         checkArgument(!data.isEmpty(), "data array must not be empty");
         this.pulses = newPulses;
-        this.zeroPulseLength = (short)zeroPulseLength;
-        this.onePulseLength = (short)onePulseLength;
+        this.zeroPulseLengths = copyOf(zeroPulseLengths);
+        this.onePulseLengths = copyOf(onePulseLengths);
         this.tailLength = (short)tailLength;
         this.numBitsInLastByte = numBitsInLastByte;
         this.data = Bytes.toArray(data);
@@ -118,7 +122,8 @@ public PZXDataBlock(PulseList newPulses, long zeroPulseLength, long onePulseLeng
      * @throws IllegalArgumentException if data is empty
      */
     public PZXDataBlock(PulseList newPulses, int numBitsInLastByte, Collection<Byte> data) {
-        this(newPulses, ZERO, ONE, TAIL, numBitsInLastByte, data);
+        this(newPulses, asList(valueOf(ZERO), valueOf(ZERO)), asList(valueOf(ONE), valueOf(ONE)), TAIL,
+                numBitsInLastByte, data);
     }
 
     // Calculates the checksum for the data according to the algorithm in the 
@@ -179,23 +184,27 @@ public byte[] getPZXBlockDiskRepresentation() {
         // use standard duration tail pulse after last bit of the block if we found one
         putUnsignedLittleEndianShort(tailLength == 0 ? 0 : tailLength, output);
 
-        putUnsignedByte((byte)2, output); // number of pulses encoding bit equal to 0.
-        putUnsignedByte((byte)2, output); // number of pulses encoding bit equal to 1.
+        putUnsignedByte((byte)zeroPulseLengths.size(), output); // number of pulses encoding bit equal to 0.
+        putUnsignedByte((byte)onePulseLengths.size(), output); // number of pulses encoding bit equal to 1.
 
         // sequence of pulse durations encoding bit equal to 0.
-        putUnsignedLittleEndianShort(zeroPulseLength, output);
-        putUnsignedLittleEndianShort(zeroPulseLength, output);
-        
+        putPulseList(zeroPulseLengths, output);
+
         // sequence of pulse durations encoding bit equal to 1.
-        putUnsignedLittleEndianShort(onePulseLength, output);
-        putUnsignedLittleEndianShort(onePulseLength, output);
-        
+        putPulseList(onePulseLengths, output);
+
         // data stream
         output.addAll(Bytes.asList(data));
 
         return addPZXBlockHeader("DATA", output);
     }
-    
+
+    private void putPulseList(List<Long> pulseLengths, Collection<Byte> output) {
+        for (Long pulseLength : pulseLengths) {
+            putUnsignedLittleEndianShort(pulseLength.shortValue(), output);
+        }
+    }
+
     @Override
     public String getSummary() {
         StringBuilder retval = new StringBuilder();
@@ -276,8 +285,8 @@ public boolean checkChecksum() {
 
     @Override
     public String toString() {
-        return "PZXDataBlock{" + pulses.toString() + ", zeroPulseLength=" + zeroPulseLength + ", onePulseLength="
-                + onePulseLength + ", tailLength=" + tailLength + ", numBitsInLastByte=" + numBitsInLastByte
+        return "PZXDataBlock{" + pulses.toString() + ", zeroPulseLengths=" + zeroPulseLengths + ", onePulseLengths="
+                + onePulseLengths + ", tailLength=" + tailLength + ", numBitsInLastByte=" + numBitsInLastByte
                 + ", calculatedChecksum=" + String.format("0x%x", calculatedChecksum) + ", suppliedChecksum="
                 + String.format("0x%x", suppliedChecksum) + ", isHeader=" + isHeader + ", data.length="
                 + data.length + '}';
@@ -289,9 +298,11 @@ public int hashCode() {
         result = 31 * result + (int) tailLength;
         result = 31 * result + Arrays.hashCode(data);
         result = 31 * result + numBitsInLastByte;
+        result = 31 * result + (int) calculatedChecksum;
         result = 31 * result + (int) suppliedChecksum;
-        result = 31 * result + (int) zeroPulseLength;
-        result = 31 * result + (int) onePulseLength;
+        result = 31 * result + (isHeader ? 1 : 0);
+        result = 31 * result + zeroPulseLengths.hashCode();
+        result = 31 * result + onePulseLengths.hashCode();
         return result;
     }
 
@@ -304,12 +315,13 @@ public boolean equals(Object o) {
 
         if (tailLength != that.tailLength) return false;
         if (numBitsInLastByte != that.numBitsInLastByte) return false;
+        if (calculatedChecksum != that.calculatedChecksum) return false;
         if (suppliedChecksum != that.suppliedChecksum) return false;
-        if (zeroPulseLength != that.zeroPulseLength) return false;
-        if (onePulseLength != that.onePulseLength) return false;
+        if (isHeader != that.isHeader) return false;
         if (!pulses.equals(that.pulses)) return false;
-        return Arrays.equals(data, that.data);
-
+        if (!Arrays.equals(data, that.data)) return false;
+        if (!zeroPulseLengths.equals(that.zeroPulseLengths)) return false;
+        return onePulseLengths.equals(that.onePulseLengths);
     }
 
     /**

src/main/java/xyz/meunier/wav2pzx/generaldecoder/DualPulseDataBlockProcessor.java

@@ -43,7 +43,7 @@
 import static xyz.meunier.wav2pzx.generaldecoder.RangeFinder.*;
 
 final class DualPulseDataBlockProcessor {
-    private static final int SYNC_OR_TAIL_BUFFER_SIZE = 4;
+    private static final int SYNC_OR_TAIL_BUFFER_SIZE = 10;
     private static final int SYNC_AND_TAIL_TOTAL_LIMIT = SYNC_OR_TAIL_BUFFER_SIZE * 2;
     private static final int MINIMUM_DATA_BLOCK_PULSE_COUNT = SYNC_AND_TAIL_TOTAL_LIMIT + 1;
     private static final int THREE_BYTES_OF_PULSES = 24;
@@ -76,27 +76,27 @@ List<TapeBlock> processDataBlock() {
         int limit = pulseLengths.size() > MINIMUM_DATA_BLOCK_PULSE_COUNT + THREE_BYTES_OF_PULSES ?
                 getPulseLengthsSizeWithoutSyncAndTailArea() : 0;
 
-        ArrayList<Long> fullBits = new ArrayList<>(limit/2);
-        for(int i = SYNC_OR_TAIL_BUFFER_SIZE; i < limit; i+=2) {
-            Long bit = pulseLengths.get(i) + pulseLengths.get(i+1);
+        ArrayList<Long> fullBits = new ArrayList<>(limit / 2);
+        for (int i = SYNC_OR_TAIL_BUFFER_SIZE; i < limit; i += 2) {
+            Long bit = pulseLengths.get(i) + pulseLengths.get(i + 1);
             fullBits.add(bit);
         }
 
         List<Range<Long>> ranges = getRanges(fullBits.stream().distinct().collect(toList()));
 
         // If we don't have enough bits to make a good population of dual pulses just dump out the source pulses
-        if(ranges.isEmpty()) {
+        if (ranges.isEmpty()) {
             ranges = RangeFinder.getRangesForSinglePulses(pulseLengths);
             TapeBlock newBlock = new TapeBlock(UNKNOWN, getSingletonPulseLengthsOfRanges(ranges), pulseList);
             getLogger(LoaderContextImpl.class.getName()).log(Level.INFO, newBlock.toString());
             return singletonList(newBlock);
         }
 
         // Find average of pulse pairs matching each range in this block
-        pulseSubstitutions = getReplacementBitDataOfRanges(ranges, fullBits);
+        pulseSubstitutions = getZeroAndOnePulsePairs(ranges, fullBits);
 
         // If we have more than two ranges we can't encode this block as a data block - just dump out the source pulses
-        if(pulseSubstitutions.size() != 2) {
+        if (pulseSubstitutions.size() != 2) {
             TapeBlock newBlock = new TapeBlock(UNKNOWN, pulseSubstitutions, pulseList);
             getLogger(LoaderContextImpl.class.getName()).log(Level.INFO, newBlock.toString());
             return singletonList(newBlock);
@@ -112,14 +112,14 @@ List<TapeBlock> processDataBlock() {
             List<Long> bitPulse = new ArrayList<>(2);
             bitPulse.addAll(pulseLengths.subList(i, i + 2));
 
-            if(replaceInRangeBitsWithProcessedValues(bitPulse)) {
+            if (replaceInRangeBitsWithProcessedValues(bitPulse)) {
                 newDataBlockPulses.addAll(bitPulse);
             } else {
                 // Finish any open PulseList
-                finishDataBlock();
+                finishBlock(i);
 
                 // Add pulses to new PulseList
-                if(isInSyncCandidateArea(i)) {
+                if (isInSyncCandidateArea(i)) {
                     // SYNC bit candidates at the beginning of the block
                     addTapeBlockForSinglePulses(SYNC_CANDIDATE, bitPulse, firstPulseLevel);
                 } else {
@@ -138,20 +138,34 @@ List<TapeBlock> processDataBlock() {
         return newTapeBlockList;
     }
 
+    private void finishBlock(int index) {
+        // Data blocks should have at least 2 bytes of data
+        if (!newDataBlockPulses.isEmpty() && newDataBlockPulses.size() < (2*8*2)) {
+            if (isInSyncCandidateArea(index)) {
+                addTapeBlockForSinglePulses(SYNC_CANDIDATE, newDataBlockPulses, firstPulseLevel);
+            } else {
+                addTapeBlock(UNKNOWN, pulseSubstitutions, newPulseList(newDataBlockPulses, firstPulseLevel));
+            }
+            newDataBlockPulses.clear();
+            return;
+        }
+        finishDataBlock();
+    }
+
     private int getPulseLengthsSizeWithoutSyncAndTailArea() {
         return (pulseLengths.size() - SYNC_AND_TAIL_TOTAL_LIMIT) - hasCandidateTailPulse;
     }
 
     private void finishDataBlock() {
         // Finish any open PulseList
-        if(!newDataBlockPulses.isEmpty()) {
+        if (!newDataBlockPulses.isEmpty()) {
             addTapeBlock(DATA, pulseSubstitutions, newPulseList(newDataBlockPulses, firstPulseLevel));
             newDataBlockPulses.clear();
         }
     }
 
     private void processCandidateTailPulse() {
-        if(hasCandidateTailPulse == 1) {
+        if (hasCandidateTailPulse == 1) {
             int size = pulseLengths.size();
             addTapeBlockForSinglePulses(TAIL_CANDIDATE, pulseLengths.subList(size - 1, size), flipPulseLevel(firstPulseLevel));
         }
@@ -163,7 +177,7 @@ private boolean replaceInRangeBitsWithProcessedValues(List<Long> bitPulse) {
 
         Long bit = bitPulse.get(0) + bitPulse.get(1);
         for (BitData bitData : pulseSubstitutions) {
-            if(bitData.getQualificationRange().contains(bit)) {
+            if (bitData.getQualificationRange().contains(bit)) {
                 // Transform bit pulses
                 bitPulse.clear();
                 bitPulse.addAll(bitData.getPulses());
@@ -194,7 +208,7 @@ private static int flipPulseLevel(int pulseLevel) {
     }
 
     private static List<BitData> getSyncRange(List<Range<Long>> ranges) {
-        return ranges.stream().distinct().map(r -> new BitData(r, r.lowerEndpoint())).collect(toList());
+        return ranges.stream().distinct().map(r -> new BitData(r, singletonList(r.lowerEndpoint()))).collect(toList());
     }
 
 }

src/main/java/xyz/meunier/wav2pzx/generaldecoder/LoaderContext.java

@@ -42,12 +42,12 @@ public interface LoaderContext {
     /**
      * The minimum length of a pilot pulse
      */
-    long MIN_PILOT_LENGTH = 1600;
+    long MIN_PILOT_LENGTH = 1100;
 
     /**
      * The maximum length of a pilot pulse
      */
-    long MAX_PILOT_LENGTH = 2560;
+    long MAX_PILOT_LENGTH = 3560;
 
     Range<Long> PILOT_CANDIDATE_RANGE = Range.closed(MIN_PILOT_LENGTH, MAX_PILOT_LENGTH);
 

src/main/java/xyz/meunier/wav2pzx/generaldecoder/PZXBuilder.java

@@ -106,24 +106,23 @@ private static PZXBlock getPzxBlock(PeekingIterator<TapeBlock> iterator) {
     private static PZXDataBlock getPzxDataBlock(PeekingIterator<TapeBlock> iterator, TapeBlock block) {
         long tailLength = getTailLength(iterator);
 
-        long zeroPulseLength = block.getZeroBit().getFullPulse() / 2;
-        long onePulseLength = block.getOneBit().getFullPulse() / 2;
+        List<Long> zeroPulseLengths = block.getZeroBit().getPulses();
+        List<Long> onePulseLengths = block.getOneBit().getPulses();
         DataBuilder dataBuilder = new DataBuilder();
 
         ImmutableList<Long> pulseLengths = block.getPulseList().getPulseLengths();
         for (int i = 0; i < pulseLengths.size(); i += 2) {
-            Long pulse1 = pulseLengths.get(i);
-            Long pulse2 = pulseLengths.get(i + 1);
-            if (isSpecifiedPulsePair(zeroPulseLength, pulse1, pulse2)) {
+            ImmutableList<Long> pulses = pulseLengths.subList(i, i + 2);
+            if (isSpecifiedPulseSequence(zeroPulseLengths, pulses)) {
                 dataBuilder.addBit(0);
-            } else if (isSpecifiedPulsePair(onePulseLength, pulse1, pulse2)) {
+            } else if (isSpecifiedPulseSequence(onePulseLengths, pulses)) {
                 dataBuilder.addBit(1);
             }
             // FIXME: Some kind of error, fall back to PulseBlock?
         }
 
         int numBitsInLastByte = dataBuilder.getNumBitsInCurrentByte();
-        return new PZXDataBlock(block.getPulseList(), zeroPulseLength, onePulseLength, tailLength,
+        return new PZXDataBlock(block.getPulseList(), zeroPulseLengths, onePulseLengths, tailLength,
                 numBitsInLastByte, dataBuilder.getData());
     }
 
@@ -135,12 +134,12 @@ private static long getTailLength(PeekingIterator<TapeBlock> iterator) {
         return tailLength;
     }
 
-    private static boolean isSpecifiedPulsePair(long pulseLength, Long pulse1, Long pulse2) {
-        return pulse1 == pulseLength && pulse2 == pulseLength;
+    private static boolean isSpecifiedPulseSequence(List<Long> pulseLength, List<Long> pulses) {
+        return pulseLength.equals(pulses);
     }
 
     private static PZXPulseBlock getPzxPulseBlock(PeekingIterator<TapeBlock> iterator, PulseList blockPulseList) {
-        if (iterator.hasNext() && iterator.peek().getBlockType() == SYNC_CANDIDATE) {
+        while (iterator.hasNext() && iterator.peek().getBlockType() == SYNC_CANDIDATE) {
             // Make a new PulseList with this block and the next one
             blockPulseList = new PulseList(blockPulseList, iterator.next().getPulseList());
         }