Hashes may not be ordered at the time of getting ranges or merging.

Author: AddictedCS

src/SoundFingerprinting/Data/Hashes.cs

@@ -14,8 +14,7 @@ public class Hashes : IEnumerable<HashedFingerprint>
         private readonly List<HashedFingerprint> fingerprints;
 
         [ProtoIgnore]
-        private List<HashedFingerprint> Fingerprints =>
-            fingerprints ?? Enumerable.Empty<HashedFingerprint>().ToList();
+        private List<HashedFingerprint> Fingerprints => fingerprints ?? Enumerable.Empty<HashedFingerprint>().ToList();
 
         public Hashes(IEnumerable<HashedFingerprint> fingerprints, double durationInSeconds):
             this(fingerprints,
@@ -93,19 +92,6 @@ public DateTime EndsAt
             }
         }
 
-        private float LengthOfOneFingerprint
-        {
-            get
-            {
-                if (IsEmpty)
-                {
-                    return 0;
-                }
-
-                return (float)DurationInSeconds - Fingerprints.Last().StartsAt;
-            }
-        }
-
         public bool IsEmpty => !Fingerprints.Any();
 
         public int Count => IsEmpty ? 0: Fingerprints.Count;
@@ -134,11 +120,19 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public Hashes GetRange(DateTime startsAt, float length)
         {
+            if (IsEmpty)
+            {
+                return Empty;
+            }
+            
             var endsAt = startsAt.AddSeconds(length);
-            var filtered = fingerprints.Where(fingerprint =>
+            var ordered = fingerprints.OrderBy(_ => _.SequenceNumber).ToList();
+            var lengthOfOneFingerprint = DurationInSeconds - ordered.Last().StartsAt;
+            
+            var filtered = ordered.Where(fingerprint =>
             {
                 var fingerprintStartsAt = RelativeTo.AddSeconds(fingerprint.StartsAt);
-                var fingerprintEndsAt = RelativeTo.AddSeconds(fingerprint.StartsAt + LengthOfOneFingerprint);
+                var fingerprintEndsAt = RelativeTo.AddSeconds(fingerprint.StartsAt + lengthOfOneFingerprint);
                 return fingerprintStartsAt >= startsAt && fingerprintEndsAt <= endsAt;
             })
             .ToList();
@@ -149,7 +143,7 @@ public Hashes GetRange(DateTime startsAt, float length)
             }
 
             var relativeTo = RelativeTo.AddSeconds(filtered.First().StartsAt);
-            var duration = filtered.Last().StartsAt - filtered.First().StartsAt + LengthOfOneFingerprint;
+            var duration = filtered.Last().StartsAt - filtered.First().StartsAt + lengthOfOneFingerprint;
             return new Hashes(filtered, duration, relativeTo, Origins, StreamId);
         }
 
@@ -183,10 +177,7 @@ public bool MergeWith(Hashes with, out Hashes? merged, double allowedGap = 1.48f
                 return false;
             }
 
-            var result = Merge(this, with);
-            float fullLength = result.Last().StartsAt + LengthOfOneFingerprint;
-            var relativeTo = RelativeTo < with.RelativeTo ? RelativeTo : with.RelativeTo;
-            merged = new Hashes(result, fullLength, relativeTo, new HashSet<string>(Origins.Concat(with.Origins)), streamId);
+            merged = Merge(this, with, streamId);
             return true;
         }
 
@@ -230,29 +221,33 @@ public static IEnumerable<Hashes> Aggregate(IEnumerable<Hashes> hashes, double l
                     });
         }
 
-        private static List<HashedFingerprint> Merge(Hashes left, Hashes right)
+        private static Hashes Merge(Hashes left, Hashes right, string streamId)
         {
             var first = left.OrderBy(_ => _.SequenceNumber).ToList();
+            double lengthOfLeftFingerprint = left.DurationInSeconds - first.Last().StartsAt;
             var firstStartsAt = left.RelativeTo;
             var second = right.OrderBy(_ => _.SequenceNumber).ToList();
+            double lengthOfRightFingerprint = right.DurationInSeconds - second.Last().StartsAt;
             var secondStartsAt = right.RelativeTo;
 
             var result = new List<HashedFingerprint>();
             int i = 0, j = 0;
             var diff = secondStartsAt.Subtract(firstStartsAt);
-            
+            double tailLength = 0;
             for (int k = 0; k < first.Count + second.Count; ++k)
             {
                 if (i == first.Count)
                 {
                     var startAt = diff.TotalSeconds + second[j].StartsAt;
                     result.Add(new HashedFingerprint(second[j].HashBins, (uint)k, (float)startAt, second[j].OriginalPoint));
                     ++j;
+                    tailLength = lengthOfRightFingerprint;
                 }
                 else if (j == second.Count)
                 {
                     result.Add(new HashedFingerprint(first[i].HashBins, (uint)k, first[i].StartsAt, first[i].OriginalPoint));
                     ++i;
+                    tailLength = lengthOfLeftFingerprint;
                 }
                 else if (firstStartsAt.AddSeconds(first[i].StartsAt) <= secondStartsAt.AddSeconds(second[j].StartsAt))
                 {
@@ -266,8 +261,10 @@ private static List<HashedFingerprint> Merge(Hashes left, Hashes right)
                     ++j;
                 }
             }
-
-            return result;
+            
+            var relativeTo = left.RelativeTo < right.RelativeTo ? left.RelativeTo : right.RelativeTo;
+            var fullLength = result.Last().StartsAt + tailLength;
+            return new Hashes(result, fullLength, relativeTo, new HashSet<string>(left.Origins.Concat(right.Origins)), streamId);
         }
     }
 }