Preparing for next version of CTDB

2025-12-16 18:14:25 +00:00 · 2011-10-25 01:16:11 +00:00
parent dd1e372947
commit da7ee90588
10 changed files with 411 additions and 240 deletions
--- a/CUETools.AccurateRip/OffsetSafeCRCRecord.cs
+++ b/CUETools.AccurateRip/OffsetSafeCRCRecord.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Xml.Serialization;
+using CUETools.Codecs;
+
+namespace CUETools.AccurateRip
+{
+    [Serializable]
+    public class OffsetSafeCRCRecord
+    {
+        private uint[] val;
+
+        public OffsetSafeCRCRecord()
+        {
+            this.val = new uint[1];
+        }
+
+        public OffsetSafeCRCRecord(AccurateRipVerify ar)
+            : this(new uint[64 + 64])
+        {
+            int offset = 64 * 64;
+            for (int i = 0; i < 64; i++)
+                this.val[i] = ar.CTDBCRC(0, (i + 1) * 64, offset, 2 * offset);
+            for (int i = 0; i < 64; i++)
+                this.val[i + 64] = ar.CTDBCRC(0, 63 - i, offset, 2 * offset);
+        }
+
+        public OffsetSafeCRCRecord(uint[] val)
+        {
+            this.val = val;
+        }
+
+        [XmlIgnore]
+        public uint[] Value
+        {
+            get
+            {
+                return val;
+            }
+        }
+
+        public unsafe string Base64
+        {
+            get
+            {
+                byte[] res = new byte[val.Length * 4];
+                fixed (byte* pres = &res[0])
+                fixed (uint* psrc = &val[0])
+                    AudioSamples.MemCpy(pres, (byte*)psrc, res.Length);
+                var b64 = new char[res.Length * 2 + 4];
+                int b64len = Convert.ToBase64CharArray(res, 0, res.Length, b64, 0);
+                StringBuilder sb = new StringBuilder(b64len + b64len / 4 + 1);
+                for (int i = 0; i < b64len; i += 64)
+                {
+                    sb.Append(b64, i, Math.Min(64, b64len - i));
+                    sb.AppendLine();
+                }
+                return sb.ToString();
+            }
+
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException();
+                byte[] bytes = Convert.FromBase64String(value);
+                if (bytes.Length % 4 != 0)
+                    throw new InvalidDataException();
+                val = new uint[bytes.Length / 4];
+                fixed (byte* pb = &bytes[0])
+                fixed (uint* pv = &val[0])
+                    AudioSamples.MemCpy((byte*)pv, pb, bytes.Length);
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is OffsetSafeCRCRecord && this == (OffsetSafeCRCRecord)obj;
+        }
+
+        public override int GetHashCode()
+        {
+            return (int)val[0];
+        }
+
+        public static bool operator ==(OffsetSafeCRCRecord x, OffsetSafeCRCRecord y)
+        {
+            if (x as object == null || y as object == null) return x as object == null && y as object == null;
+            if (x.Value.Length != y.Value.Length) return false;
+            for (int i = 0; i < x.Value.Length; i++)
+                if (x.Value[i] != y.Value[i])
+                    return false;
+            return true;
+        }
+
+        public static bool operator !=(OffsetSafeCRCRecord x, OffsetSafeCRCRecord y)
+        {
+            return !(x == y);
+        }
+
+        public bool DifferByOffset(OffsetSafeCRCRecord rec)
+        {
+            int offset;
+            return FindOffset(rec, out offset);
+        }
+
+        public bool FindOffset(OffsetSafeCRCRecord rec, out int offset)
+        {
+            if (this.Value.Length != 128 || rec.Value.Length != 128)
+            {
+                offset = 0;
+                return false;
+                //throw new InvalidDataException("Unsupported OffsetSafeCRCRecord");
+            }
+
+            for (int i = 0; i < 64; i++)
+            {
+                if (rec.Value[0] == Value[i])
+                {
+                    offset = i * 64;
+                    return true;
+                }
+                if (Value[0] == rec.Value[i])
+                {
+                    offset = -i * 64;
+                    return true;
+                }
+                for (int j = 0; j < 64; j++)
+                {
+                    if (rec.Value[i] == Value[64 + j])
+                    {
+                        offset = i * 64 + j + 1;
+                        return true;
+                    }
+                    if (Value[i] == rec.Value[64 + j])
+                    {
+                        offset = -i * 64 - j - 1;
+                        return true;
+                    }
+                }
+            }
+            offset = 0;
+            return false;
+        }
+    }
+}