CUETools.DSP.Resampler: split classes into separate files.

CUETools.DSP.Resampler/Internal/fifo_t.cs

@@ -0,0 +1,90 @@
+using System;
+
+namespace CUETools.DSP.Resampler.Internal
+{
+    class fifo_t
+    {
+        internal byte[] data;
+        int item_size;    /* Size of each item in data */
+        int begin;        /* Offset of the first byte to read. */
+        int end;          /* 1 + Offset of the last byte byte to read. */
+
+        const int FIFO_MIN = 0x4000;
+
+        public int offset
+        {
+            get
+            {
+                return begin;
+            }
+        }
+
+        public int occupancy
+        {
+            get
+            {
+                return (end - begin) / item_size;
+            }
+        }
+
+        public fifo_t(int item_size)
+        {
+            this.data = new byte[FIFO_MIN];
+            this.item_size = item_size;
+            this.begin = 0;
+            this.end = 0;
+        }
+
+        public void clear()
+        {
+            this.begin = 0;
+            this.end = 0;
+        }
+
+        public int reserve(int n)
+        {
+            n *= item_size;
+
+            if (begin == end)
+                clear();
+
+            while (true)
+            {
+                if (end + n <= data.Length)
+                {
+                    int pos = end;
+                    end += n;
+                    return pos;
+                }
+                if (begin > FIFO_MIN)
+                {
+                    Buffer.BlockCopy(data, begin, data, 0, end - begin);
+                    end -= begin;
+                    begin = 0;
+                    continue;
+                }
+                byte[] data1 = new byte[data.Length + Math.Max(n, data.Length)];
+                Buffer.BlockCopy(data, begin, data1, 0, end - begin);
+                data = data1;
+                end -= begin;
+                begin = 0;
+            }
+        }
+
+        public void trim_by(int n)
+        {
+            end -= n * item_size;
+        }
+
+        public int read(int n, byte[] buf)
+        {
+            n *= item_size;
+            if (n > end - begin)
+                throw new InvalidOperationException();
+            if (buf != null)
+                Buffer.BlockCopy(data, begin, buf, 0, n);
+            begin += n;
+            return begin - n;
+        }
+    }
+}