Move cuetools.net codec locally.

Aaru.Compression/cuetools.net/CUETools.Codecs/AudioBuffer.cs

@@ -0,0 +1,484 @@
+using System;
+
+namespace CUETools.Codecs
+{
+    public class AudioBuffer
+    {
+        #region Static Methods
+
+        public static unsafe void FLACSamplesToBytes_16(int[,] inSamples, int inSampleOffset,
+            byte* outSamples, int sampleCount, int channelCount)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if (inSamples.GetLength(0) - inSampleOffset < sampleCount)
+                throw new IndexOutOfRangeException();
+
+            fixed (int* pInSamplesFixed = &inSamples[inSampleOffset, 0])
+            {
+                int* pInSamples = pInSamplesFixed;
+                short* pOutSamples = (short*)outSamples;
+                for (int i = 0; i < loopCount; i++)
+                    pOutSamples[i] = (short)pInSamples[i];
+                //*(pOutSamples++) = (short)*(pInSamples++);
+            }
+        }
+
+        public static unsafe void FLACSamplesToBytes_16(int[,] inSamples, int inSampleOffset,
+            byte[] outSamples, int outByteOffset, int sampleCount, int channelCount)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if ((inSamples.GetLength(0) - inSampleOffset < sampleCount) ||
+                (outSamples.Length - outByteOffset < loopCount * 2))
+            {
+                throw new IndexOutOfRangeException();
+            }
+
+            fixed (byte* pOutSamplesFixed = &outSamples[outByteOffset])
+                FLACSamplesToBytes_16(inSamples, inSampleOffset, pOutSamplesFixed, sampleCount, channelCount);
+        }
+
+        public static unsafe void FLACSamplesToBytes_24(int[,] inSamples, int inSampleOffset,
+            byte[] outSamples, int outByteOffset, int sampleCount, int channelCount, int wastedBits)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if ((inSamples.GetLength(0) - inSampleOffset < sampleCount) ||
+                (outSamples.Length - outByteOffset < loopCount * 3))
+            {
+                throw new IndexOutOfRangeException();
+            }
+
+            fixed (int* pInSamplesFixed = &inSamples[inSampleOffset, 0])
+            {
+                fixed (byte* pOutSamplesFixed = &outSamples[outByteOffset])
+                {
+                    int* pInSamples = pInSamplesFixed;
+                    byte* pOutSamples = pOutSamplesFixed;
+
+                    for (int i = 0; i < loopCount; i++)
+                    {
+                        uint sample_out = (uint)*(pInSamples++) << wastedBits;
+                        *(pOutSamples++) = (byte)(sample_out & 0xFF);
+                        sample_out >>= 8;
+                        *(pOutSamples++) = (byte)(sample_out & 0xFF);
+                        sample_out >>= 8;
+                        *(pOutSamples++) = (byte)(sample_out & 0xFF);
+                    }
+                }
+            }
+        }
+
+        public static unsafe void FloatToBytes_16(float[,] inSamples, int inSampleOffset,
+            byte[] outSamples, int outByteOffset, int sampleCount, int channelCount)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if ((inSamples.GetLength(0) - inSampleOffset < sampleCount) ||
+                (outSamples.Length - outByteOffset < loopCount * 2))
+            {
+                throw new IndexOutOfRangeException();
+            }
+
+            fixed (float* pInSamplesFixed = &inSamples[inSampleOffset, 0])
+            {
+                fixed (byte* pOutSamplesFixed = &outSamples[outByteOffset])
+                {
+                    float* pInSamples = pInSamplesFixed;
+                    short* pOutSamples = (short*)pOutSamplesFixed;
+
+                    for (int i = 0; i < loopCount; i++)
+                    {
+                        *(pOutSamples++) = (short)(32758 * (*(pInSamples++)));
+                    }
+                }
+            }
+        }
+
+        public static unsafe void FloatToBytes(float[,] inSamples, int inSampleOffset,
+            byte[] outSamples, int outByteOffset, int sampleCount, int channelCount, int bitsPerSample)
+        {
+            if (bitsPerSample == 16)
+                FloatToBytes_16(inSamples, inSampleOffset, outSamples, outByteOffset, sampleCount, channelCount);
+            //else if (bitsPerSample > 16 && bitsPerSample <= 24)
+            //    FLACSamplesToBytes_24(inSamples, inSampleOffset, outSamples, outByteOffset, sampleCount, channelCount, 24 - bitsPerSample);
+            else if (bitsPerSample == 32)
+                Buffer.BlockCopy(inSamples, inSampleOffset * 4 * channelCount, outSamples, outByteOffset, sampleCount * 4 * channelCount);
+            else
+                throw new Exception("Unsupported bitsPerSample value");
+        }
+
+        public static unsafe void FLACSamplesToBytes(int[,] inSamples, int inSampleOffset,
+            byte[] outSamples, int outByteOffset, int sampleCount, int channelCount, int bitsPerSample)
+        {
+            if (bitsPerSample == 16)
+                FLACSamplesToBytes_16(inSamples, inSampleOffset, outSamples, outByteOffset, sampleCount, channelCount);
+            else if (bitsPerSample > 16 && bitsPerSample <= 24)
+                FLACSamplesToBytes_24(inSamples, inSampleOffset, outSamples, outByteOffset, sampleCount, channelCount, 24 - bitsPerSample);
+            else
+                throw new Exception("Unsupported bitsPerSample value");
+        }
+
+        public static unsafe void FLACSamplesToBytes(int[,] inSamples, int inSampleOffset,
+            byte* outSamples, int sampleCount, int channelCount, int bitsPerSample)
+        {
+            if (bitsPerSample == 16)
+                FLACSamplesToBytes_16(inSamples, inSampleOffset, outSamples, sampleCount, channelCount);
+            else
+                throw new Exception("Unsupported bitsPerSample value");
+        }
+
+        public static unsafe void Bytes16ToFloat(byte[] inSamples, int inByteOffset,
+            float[,] outSamples, int outSampleOffset, int sampleCount, int channelCount)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if ((inSamples.Length - inByteOffset < loopCount * 2) ||
+                (outSamples.GetLength(0) - outSampleOffset < sampleCount))
+                throw new IndexOutOfRangeException();
+
+            fixed (byte* pInSamplesFixed = &inSamples[inByteOffset])
+            {
+                fixed (float* pOutSamplesFixed = &outSamples[outSampleOffset, 0])
+                {
+                    short* pInSamples = (short*)pInSamplesFixed;
+                    float* pOutSamples = pOutSamplesFixed;
+                    for (int i = 0; i < loopCount; i++)
+                        *(pOutSamples++) = *(pInSamples++) / 32768.0f;
+                }
+            }
+        }
+
+        public static unsafe void BytesToFLACSamples_16(byte[] inSamples, int inByteOffset,
+            int[,] outSamples, int outSampleOffset, int sampleCount, int channelCount)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if ((inSamples.Length - inByteOffset < loopCount * 2) ||
+                (outSamples.GetLength(0) - outSampleOffset < sampleCount))
+            {
+                throw new IndexOutOfRangeException();
+            }
+
+            fixed (byte* pInSamplesFixed = &inSamples[inByteOffset])
+            {
+                fixed (int* pOutSamplesFixed = &outSamples[outSampleOffset, 0])
+                {
+                    short* pInSamples = (short*)pInSamplesFixed;
+                    int* pOutSamples = pOutSamplesFixed;
+
+                    for (int i = 0; i < loopCount; i++)
+                    {
+                        *(pOutSamples++) = (int)*(pInSamples++);
+                    }
+                }
+            }
+        }
+
+        public static unsafe void BytesToFLACSamples_24(byte[] inSamples, int inByteOffset,
+            int[,] outSamples, int outSampleOffset, int sampleCount, int channelCount, int wastedBits)
+        {
+            int loopCount = sampleCount * channelCount;
+
+            if ((inSamples.Length - inByteOffset < loopCount * 3) ||
+                (outSamples.GetLength(0) - outSampleOffset < sampleCount))
+                throw new IndexOutOfRangeException();
+
+            fixed (byte* pInSamplesFixed = &inSamples[inByteOffset])
+            {
+                fixed (int* pOutSamplesFixed = &outSamples[outSampleOffset, 0])
+                {
+                    byte* pInSamples = (byte*)pInSamplesFixed;
+                    int* pOutSamples = pOutSamplesFixed;
+                    for (int i = 0; i < loopCount; i++)
+                    {
+                        int sample = (int)*(pInSamples++);
+                        sample += (int)*(pInSamples++) << 8;
+                        sample += (int)*(pInSamples++) << 16;
+                        *(pOutSamples++) = (sample << 8) >> (8 + wastedBits);
+                    }
+                }
+            }
+        }
+
+        public static unsafe void BytesToFLACSamples(byte[] inSamples, int inByteOffset,
+            int[,] outSamples, int outSampleOffset, int sampleCount, int channelCount, int bitsPerSample)
+        {
+            if (bitsPerSample == 16)
+                BytesToFLACSamples_16(inSamples, inByteOffset, outSamples, outSampleOffset, sampleCount, channelCount);
+            else if (bitsPerSample > 16 && bitsPerSample <= 24)
+                BytesToFLACSamples_24(inSamples, inByteOffset, outSamples, outSampleOffset, sampleCount, channelCount, 24 - bitsPerSample);
+            else
+                throw new Exception("Unsupported bitsPerSample value");
+        }
+
+        #endregion
+
+        private int[,] samples;
+        private float[,] fsamples;
+        private byte[] bytes;
+        private int length;
+        private int size;
+        private AudioPCMConfig pcm;
+        private bool dataInSamples = false;
+        private bool dataInBytes = false;
+        private bool dataInFloat = false;
+
+        public int Length
+        {
+            get { return length; }
+            set { length = value; }
+        }
+
+        public int Size
+        {
+            get { return size; }
+        }
+
+        public AudioPCMConfig PCM { get { return pcm; } }
+
+        public int ByteLength
+        {
+            get
+            {
+                return length * pcm.BlockAlign;
+            }
+        }
+
+        public int[,] Samples
+        {
+            get
+            {
+                if (samples == null || samples.GetLength(0) < length)
+                    samples = new int[size, pcm.ChannelCount];
+                if (!dataInSamples && dataInBytes && length != 0)
+                    BytesToFLACSamples(bytes, 0, samples, 0, length, pcm.ChannelCount, pcm.BitsPerSample);
+                dataInSamples = true;
+                return samples;
+            }
+        }
+
+        public float[,] Float
+        {
+            get
+            {
+                if (fsamples == null || fsamples.GetLength(0) < length)
+                    fsamples = new float[size, pcm.ChannelCount];
+                if (!dataInFloat && dataInBytes && length != 0)
+                {
+                    if (pcm.BitsPerSample == 16)
+                        Bytes16ToFloat(bytes, 0, fsamples, 0, length, pcm.ChannelCount);
+                    //else if (pcm.BitsPerSample > 16 && PCM.BitsPerSample <= 24)
+                    //    BytesToFLACSamples_24(bytes, 0, fsamples, 0, length, pcm.ChannelCount, 24 - pcm.BitsPerSample);
+                    else if (pcm.BitsPerSample == 32)
+                        Buffer.BlockCopy(bytes, 0, fsamples, 0, length * 4 * pcm.ChannelCount);
+                    else
+                        throw new Exception("Unsupported bitsPerSample value");
+                }
+                dataInFloat = true;
+                return fsamples;
+            }
+        }
+
+        public byte[] Bytes
+        {
+            get
+            {
+                if (bytes == null || bytes.Length < length * pcm.BlockAlign)
+                    bytes = new byte[size * pcm.BlockAlign];
+                if (!dataInBytes && length != 0)
+                {
+                    if (dataInSamples)
+                        FLACSamplesToBytes(samples, 0, bytes, 0, length, pcm.ChannelCount, pcm.BitsPerSample);
+                    else if (dataInFloat)
+                        FloatToBytes(fsamples, 0, bytes, 0, length, pcm.ChannelCount, pcm.BitsPerSample);
+                }
+                dataInBytes = true;
+                return bytes;
+            }
+        }
+
+        public AudioBuffer(AudioPCMConfig _pcm, int _size)
+        {
+            pcm = _pcm;
+            size = _size;
+            length = 0;
+        }
+
+        public AudioBuffer(AudioPCMConfig _pcm, int[,] _samples, int _length)
+        {
+            pcm = _pcm;
+            // assert _samples.GetLength(1) == pcm.ChannelCount
+            Prepare(_samples, _length);
+        }
+
+        public AudioBuffer(AudioPCMConfig _pcm, byte[] _bytes, int _length)
+        {
+            pcm = _pcm;
+            Prepare(_bytes, _length);
+        }
+
+        public AudioBuffer(IAudioSource source, int _size)
+        {
+            pcm = source.PCM;
+            size = _size;
+        }
+
+        public void Prepare(IAudioDest dest)
+        {
+            if (dest.Settings.PCM.ChannelCount != pcm.ChannelCount || dest.Settings.PCM.BitsPerSample != pcm.BitsPerSample)
+                throw new Exception("AudioBuffer format mismatch");
+        }
+
+        public void Prepare(IAudioSource source, int maxLength)
+        {
+            if (source.PCM.ChannelCount != pcm.ChannelCount || source.PCM.BitsPerSample != pcm.BitsPerSample)
+                throw new Exception("AudioBuffer format mismatch");
+            length = size;
+            if (maxLength >= 0)
+                length = Math.Min(length, maxLength);
+            if (source.Remaining >= 0)
+                length = (int)Math.Min((long)length, source.Remaining);
+            dataInBytes = false;
+            dataInSamples = false;
+            dataInFloat = false;
+        }
+
+        public void Prepare(int maxLength)
+        {
+            length = size;
+            if (maxLength >= 0)
+                length = Math.Min(length, maxLength);
+            dataInBytes = false;
+            dataInSamples = false;
+            dataInFloat = false;
+        }
+
+        public void Prepare(int[,] _samples, int _length)
+        {
+            length = _length;
+            size = _samples.GetLength(0);
+            samples = _samples;
+            dataInSamples = true;
+            dataInBytes = false;
+            dataInFloat = false;
+            if (length > size)
+                throw new Exception("Invalid length");
+        }
+
+        public void Prepare(byte[] _bytes, int _length)
+        {
+            length = _length;
+            size = _bytes.Length / PCM.BlockAlign;
+            bytes = _bytes;
+            dataInSamples = false;
+            dataInBytes = true;
+            dataInFloat = false;
+            if (length > size)
+                throw new Exception("Invalid length");
+        }
+
+        internal unsafe void Load(int dstOffset, AudioBuffer src, int srcOffset, int copyLength)
+        {
+            if (dataInBytes)
+                Buffer.BlockCopy(src.Bytes, srcOffset * pcm.BlockAlign, Bytes, dstOffset * pcm.BlockAlign, copyLength * pcm.BlockAlign);
+            if (dataInSamples)
+                Buffer.BlockCopy(src.Samples, srcOffset * pcm.ChannelCount * 4, Samples, dstOffset * pcm.ChannelCount * 4, copyLength * pcm.ChannelCount * 4);
+            if (dataInFloat)
+                Buffer.BlockCopy(src.Float, srcOffset * pcm.ChannelCount * 4, Float, dstOffset * pcm.ChannelCount * 4, copyLength * pcm.ChannelCount * 4);
+        }
+
+        public unsafe void Prepare(AudioBuffer _src, int _offset, int _length)
+        {
+            length = Math.Min(size, _src.Length - _offset);
+            if (_length >= 0)
+                length = Math.Min(length, _length);
+            dataInBytes = false;
+            dataInFloat = false;
+            dataInSamples = false;
+            if (_src.dataInBytes)
+                dataInBytes = true;
+            else if (_src.dataInSamples)
+                dataInSamples = true;
+            else if (_src.dataInFloat)
+                dataInFloat = true;
+            Load(0, _src, _offset, length);
+        }
+
+        public void Swap(AudioBuffer buffer)
+        {
+            if (pcm.BitsPerSample != buffer.PCM.BitsPerSample || pcm.ChannelCount != buffer.PCM.ChannelCount)
+                throw new Exception("AudioBuffer format mismatch");
+
+            int[,] samplesTmp = samples;
+            float[,] floatsTmp = fsamples;
+            byte[] bytesTmp = bytes;
+
+            fsamples = buffer.fsamples;
+            samples = buffer.samples;
+            bytes = buffer.bytes;
+            length = buffer.length;
+            size = buffer.size;
+            dataInSamples = buffer.dataInSamples;
+            dataInBytes = buffer.dataInBytes;
+            dataInFloat = buffer.dataInFloat;
+
+            buffer.samples = samplesTmp;
+            buffer.bytes = bytesTmp;
+            buffer.fsamples = floatsTmp;
+            buffer.length = 0;
+            buffer.dataInSamples = false;
+            buffer.dataInBytes = false;
+            buffer.dataInFloat = false;
+        }
+
+        unsafe public void Interlace(int pos, int* src1, int* src2, int n)
+        {
+            if (PCM.ChannelCount != 2)
+            {
+                throw new Exception("Must be stereo");
+            }
+            if (PCM.BitsPerSample == 16)
+            {
+                fixed (byte* bs = Bytes)
+                {
+                    int* res = ((int*)bs) + pos;
+                    for (int i = n; i > 0; i--)
+                        *(res++) = (*(src1++) & 0xffff) ^ (*(src2++) << 16);
+                }
+            }
+            else if (PCM.BitsPerSample == 24)
+            {
+                fixed (byte* bs = Bytes)
+                {
+                    byte* res = bs + pos * 6;
+                    for (int i = n; i > 0; i--)
+                    {
+                        uint sample_out = (uint)*(src1++);
+                        *(res++) = (byte)(sample_out & 0xFF);
+                        sample_out >>= 8;
+                        *(res++) = (byte)(sample_out & 0xFF);
+                        sample_out >>= 8;
+                        *(res++) = (byte)(sample_out & 0xFF);
+                        sample_out = (uint)*(src2++);
+                        *(res++) = (byte)(sample_out & 0xFF);
+                        sample_out >>= 8;
+                        *(res++) = (byte)(sample_out & 0xFF);
+                        sample_out >>= 8;
+                        *(res++) = (byte)(sample_out & 0xFF);
+                    }
+                }
+            }
+            else
+            {
+                throw new Exception("Unsupported BPS");
+            }
+        }
+
+        //public void Clear()
+        //{
+        //    length = 0;
+        //}
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/AudioDecoderSettings.cs

@@ -0,0 +1,54 @@
+using System;
+using System.ComponentModel;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+using System.Text;
+using Newtonsoft.Json;
+using System.IO;
+
+namespace CUETools.Codecs
+{
+    public interface IAudioDecoderSettings
+    {
+        string Name { get; }
+
+        string Extension { get; }
+
+        Type DecoderType { get; }
+
+        int Priority { get; }
+
+        IAudioDecoderSettings Clone();
+    }
+
+    public static class IAudioDecoderSettingsExtensions
+    {
+        public static bool HasBrowsableAttributes(this IAudioDecoderSettings settings)
+        {
+            bool hasBrowsable = false;
+            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(settings))
+            {
+                bool isBrowsable = true;
+                foreach (var attribute in property.Attributes)
+                {
+                    var browsable = attribute as BrowsableAttribute;
+                    isBrowsable &= browsable == null || browsable.Browsable;
+                }
+                hasBrowsable |= isBrowsable;
+            }
+            return hasBrowsable;
+        }
+
+        public static void Init(this IAudioDecoderSettings settings)
+        {
+            // Iterate through each property and call ResetValue()
+            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(settings))
+                property.ResetValue(settings);
+        }
+
+        public static IAudioSource Open(this IAudioDecoderSettings settings, string path, Stream IO = null)
+        {
+            return Activator.CreateInstance(settings.DecoderType, settings, path, IO) as IAudioSource;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/AudioEncoderSettings.cs

@@ -0,0 +1,124 @@
+using System;
+using System.ComponentModel;
+using System.Collections.Generic;
+using System.Text;
+using Newtonsoft.Json;
+
+#if NET20
+    namespace System.Runtime.CompilerServices
+    {
+        [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class
+             | AttributeTargets.Method)]
+        public sealed class ExtensionAttribute : Attribute { }
+    }
+#endif
+
+namespace CUETools.Codecs
+{
+    public interface IAudioEncoderSettings
+    {
+        string Name { get; }
+
+        string Extension { get; }
+
+        Type EncoderType { get; }
+
+        bool Lossless { get; }
+
+        int Priority { get; }
+
+        string SupportedModes { get; }
+
+        string DefaultMode { get; }
+
+        string EncoderMode { get; set; }
+
+        AudioPCMConfig PCM { get; set; }
+
+        int BlockSize { get; set; }
+
+        int Padding { get; set; }
+
+        IAudioEncoderSettings Clone();
+    }
+
+    public static class IAudioEncoderSettingsExtensions
+    {
+        public static bool HasBrowsableAttributes(this IAudioEncoderSettings settings)
+        {
+            bool hasBrowsable = false;
+            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(settings))
+            {
+                bool isBrowsable = true;
+                foreach (var attribute in property.Attributes)
+                {
+                    var browsable = attribute as BrowsableAttribute;
+                    isBrowsable &= browsable == null || browsable.Browsable;
+                }
+                hasBrowsable |= isBrowsable;
+            }
+            return hasBrowsable;
+        }
+
+        public static int GetEncoderModeIndex(this IAudioEncoderSettings settings)
+        {
+            return new List<string>(settings.SupportedModes.Split(' ')).FindIndex(m => m == settings.EncoderMode);
+        }
+
+        public static void SetEncoderModeIndex(this IAudioEncoderSettings settings, int value)
+        {
+            string[] modes = settings.SupportedModes.Split(' ');
+            if (modes.Length == 0 && value < 0)
+                return;
+            if (value < 0 || value >= modes.Length)
+                throw new IndexOutOfRangeException();
+            settings.EncoderMode = modes[value];
+        }
+
+        public static void SetDefaultValuesForMode(this IAudioEncoderSettings settings)
+        {
+            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(settings))
+                if (!property.CanResetValue(settings))
+                    foreach (var attribute in property.Attributes)
+                        if (attribute is DefaultValueForModeAttribute)
+                        {
+                            var defaultValueForMode = attribute as DefaultValueForModeAttribute;
+                            property.SetValue(settings, defaultValueForMode.m_values[settings.GetEncoderModeIndex()]);
+                        }
+        }
+
+        public static bool HasDefaultValuesForMode(this IAudioEncoderSettings settings, int index)
+        {
+            bool res = true;
+            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(settings))
+                foreach (var attribute in property.Attributes)
+                    if (attribute is DefaultValueForModeAttribute)
+                    {
+                        var defaultValueForMode = attribute as DefaultValueForModeAttribute;
+                        res &= property.GetValue(settings).Equals(defaultValueForMode.m_values[index]);
+                    }
+            return res;
+        }
+
+        public static int GuessEncoderMode(this IAudioEncoderSettings settings)
+        {
+            // return new List<string>(settings.SupportedModes.Split(' ')).FindIndex(m => settings.HasDefaultValuesForMode(m));
+            string[] modes = settings.SupportedModes.Split(' ');
+            if (modes == null || modes.Length < 1)
+                return -1;
+            for (int i = 0; i < modes.Length; i++)
+                if (settings.HasDefaultValuesForMode(i))
+                    return i;
+            return -1;
+        }
+
+        public static void Init(this IAudioEncoderSettings settings, AudioPCMConfig pcm = null)
+        {
+            // Iterate through each property and call ResetValue()
+            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(settings))
+                property.ResetValue(settings);
+            settings.EncoderMode = settings.DefaultMode;
+            settings.PCM = pcm;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/AudioPCMConfig.cs

@@ -0,0 +1,138 @@
+namespace CUETools.Codecs
+{
+    public class AudioPCMConfig
+    {
+        public static readonly AudioPCMConfig RedBook = new AudioPCMConfig(16, 2, 44100);
+        public enum SpeakerConfig
+        {
+            SPEAKER_FRONT_LEFT = 0x1,
+            SPEAKER_FRONT_RIGHT = 0x2,
+            SPEAKER_FRONT_CENTER = 0x4,
+            SPEAKER_LOW_FREQUENCY = 0x8,
+            SPEAKER_BACK_LEFT = 0x10,
+            SPEAKER_BACK_RIGHT = 0x20,
+            SPEAKER_FRONT_LEFT_OF_CENTER = 0x40,
+            SPEAKER_FRONT_RIGHT_OF_CENTER = 0x80,
+            SPEAKER_BACK_CENTER = 0x100,
+            SPEAKER_SIDE_LEFT = 0x200,
+            SPEAKER_SIDE_RIGHT = 0x400,
+            SPEAKER_TOP_CENTER = 0x800,
+            SPEAKER_TOP_FRONT_LEFT = 0x1000,
+            SPEAKER_TOP_FRONT_CENTER = 0x2000,
+            SPEAKER_TOP_FRONT_RIGHT = 0x4000,
+            SPEAKER_TOP_BACK_LEFT = 0x8000,
+            SPEAKER_TOP_BACK_CENTER = 0x10000,
+            SPEAKER_TOP_BACK_RIGHT = 0x20000,
+
+            DIRECTOUT = 0,
+            KSAUDIO_SPEAKER_MONO = (SPEAKER_FRONT_CENTER),
+            KSAUDIO_SPEAKER_STEREO = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT),
+            KSAUDIO_SPEAKER_QUAD = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT),
+            KSAUDIO_SPEAKER_SURROUND = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_BACK_CENTER),
+            KSAUDIO_SPEAKER_5POINT1 = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT),
+            KSAUDIO_SPEAKER_5POINT1_SURROUND = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT),
+            KSAUDIO_SPEAKER_7POINT1 = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_FRONT_RIGHT_OF_CENTER),
+            KSAUDIO_SPEAKER_7POINT1_SURROUND = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT),
+
+            DVDAUDIO_GR1_0 = SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR1_1 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_2 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_3 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_4 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_5 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_6 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_7 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_8 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_9 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_10 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_11 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_12 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
+            DVDAUDIO_GR1_13 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR1_14 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR1_15 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR1_16 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR1_17 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR1_18 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR1_19 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR1_20 = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+
+            DVDAUDIO_GR2_0 = 0,
+            DVDAUDIO_GR2_1 = 0,
+            DVDAUDIO_GR2_2 = SPEAKER_BACK_CENTER,
+            DVDAUDIO_GR2_3 = SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR2_4 = SPEAKER_LOW_FREQUENCY,
+            DVDAUDIO_GR2_5 = SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_CENTER,
+            DVDAUDIO_GR2_6 = SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR2_7 = SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR2_8 = SPEAKER_FRONT_CENTER | SPEAKER_BACK_CENTER,
+            DVDAUDIO_GR2_9 = SPEAKER_FRONT_CENTER | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR2_10 = SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY,
+            DVDAUDIO_GR2_11 = SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_CENTER,
+            DVDAUDIO_GR2_12 = SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR2_13 = SPEAKER_BACK_CENTER,
+            DVDAUDIO_GR2_14 = SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR2_15 = SPEAKER_LOW_FREQUENCY,
+            DVDAUDIO_GR2_16 = SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_CENTER,
+            DVDAUDIO_GR2_17 = SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
+            DVDAUDIO_GR2_18 = SPEAKER_LOW_FREQUENCY,
+            DVDAUDIO_GR2_19 = SPEAKER_FRONT_CENTER,
+            DVDAUDIO_GR2_20 = SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY,
+        }
+
+        private int _bitsPerSample;
+        private int _channelCount;
+        private int _sampleRate;
+        private SpeakerConfig _channelMask;
+
+        public int BitsPerSample { get { return _bitsPerSample; } }
+        public int ChannelCount { get { return _channelCount; } }
+        public int SampleRate { get { return _sampleRate; } }
+        public int BlockAlign { get { return _channelCount * ((_bitsPerSample + 7) / 8); } }
+        public SpeakerConfig ChannelMask { get { return _channelMask; } }
+        public bool IsRedBook { get { return _bitsPerSample == 16 && _channelCount == 2 && _sampleRate == 44100; } }
+        public static int ChannelsInMask(SpeakerConfig mask)
+        {
+            int count = 0;
+            while (mask != 0)
+            {
+                count++;
+                mask &= (mask - 1);
+            }
+            return count;
+        }
+
+        public static SpeakerConfig GetDefaultChannelMask(int channelCount)
+        {
+            switch (channelCount)
+            {
+                case 1:
+                    return SpeakerConfig.KSAUDIO_SPEAKER_MONO;
+                case 2:
+                    return SpeakerConfig.KSAUDIO_SPEAKER_STEREO;
+                case 3:
+                    return SpeakerConfig.KSAUDIO_SPEAKER_STEREO | SpeakerConfig.SPEAKER_LOW_FREQUENCY;
+                case 4:
+                    return SpeakerConfig.KSAUDIO_SPEAKER_QUAD;
+                case 5:
+                    //return SpeakerConfig.KSAUDIO_SPEAKER_5POINT1 & ~SpeakerConfig.SPEAKER_LOW_FREQUENCY;
+                    return SpeakerConfig.KSAUDIO_SPEAKER_5POINT1_SURROUND & ~SpeakerConfig.SPEAKER_LOW_FREQUENCY;
+                case 6:
+                    //return SpeakerConfig.KSAUDIO_SPEAKER_5POINT1;
+                    return SpeakerConfig.KSAUDIO_SPEAKER_5POINT1_SURROUND;
+                case 7:
+                    return SpeakerConfig.KSAUDIO_SPEAKER_5POINT1_SURROUND | SpeakerConfig.SPEAKER_BACK_CENTER;
+                case 8:
+                    return SpeakerConfig.KSAUDIO_SPEAKER_7POINT1_SURROUND; 
+            }
+            return (SpeakerConfig)((1 << channelCount) - 1);
+        }
+
+        public AudioPCMConfig(int bitsPerSample, int channelCount, int sampleRate, SpeakerConfig channelMask = SpeakerConfig.DIRECTOUT)
+        {
+            _bitsPerSample = bitsPerSample;
+            _channelCount = channelCount;
+            _sampleRate = sampleRate;
+            _channelMask = channelMask == 0 ? GetDefaultChannelMask(channelCount) : channelMask;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/AudioPipe.cs

@@ -0,0 +1,269 @@
+using System;
+using System.Threading;
+
+namespace CUETools.Codecs
+{
+    public class AudioPipe : IAudioSource//, IDisposable
+    {
+        private AudioBuffer _readBuffer, _writeBuffer;
+        private AudioPCMConfig pcm;
+        private long _sampleLen, _samplePos;
+        private int _maxLength;
+        private Thread _workThread;
+        private IAudioSource _source;
+        private bool _close = false;
+        private bool _haveData = false;
+        private int _bufferPos = 0;
+        private Exception _ex = null;
+        private bool own;
+        private ThreadPriority priority;
+
+        public IAudioDecoderSettings Settings => null;
+
+        public long Position
+        {
+            get
+            {
+                return _samplePos;
+            }
+            set
+            {
+                if (value == _samplePos)
+                    return;
+
+                if (_source == null)
+                    throw new NotSupportedException();
+
+                lock (this)
+                {
+                    _close = true;
+                    Monitor.Pulse(this);
+                }
+                if (_workThread != null)
+                {
+                    _workThread.Join();
+                    _workThread = null;
+                }
+                _source.Position = value;
+                _samplePos = value;
+                _bufferPos = 0;
+                _haveData = false;
+                _close = false;
+                //Go();
+                //throw new Exception("not supported");
+            }
+        }
+
+        public TimeSpan Duration => Length < 0 ? TimeSpan.Zero : TimeSpan.FromSeconds((double)Length / PCM.SampleRate);
+
+        public long Length
+        {
+            get
+            {
+                return _sampleLen;
+            }
+        }
+
+        public long Remaining
+        {
+            get
+            {
+                return _sampleLen - _samplePos;
+            }
+        }
+
+        public AudioPCMConfig PCM
+        {
+            get
+            {
+                return pcm;
+            }
+        }
+
+        public string Path
+        {
+            get
+            {
+                if (_source == null)
+                    return "";
+                return _source.Path;
+            }
+        }
+
+        public AudioPipe(AudioPCMConfig pcm, int size)
+        {
+            this.pcm = pcm;
+            _readBuffer = new AudioBuffer(pcm, size);
+            _writeBuffer = new AudioBuffer(pcm, size);
+            _maxLength = size;
+            _sampleLen = -1;
+            _samplePos = 0;
+        }
+
+        public AudioPipe(IAudioSource source, int size, bool own, ThreadPriority priority)
+            : this(source.PCM, size)
+        {
+            this.own = own;
+            this.priority = priority;
+            _source = source;
+            _sampleLen = _source.Length;
+            _samplePos = _source.Position;
+        }
+
+        public AudioPipe(IAudioSource source, int size)
+            : this(source, size, true, ThreadPriority.BelowNormal)
+        {
+        }
+
+        private void Decompress(object o)
+        {
+#if !DEBUG
+			try
+#endif
+            {
+                bool done = false;
+                do
+                {
+                    done = _source.Read(_writeBuffer, -1) == 0;
+                    lock (this)
+                    {
+                        while (_haveData && !_close)
+                            Monitor.Wait(this);
+                        if (_close)
+                            break;
+                        AudioBuffer temp = _writeBuffer;
+                        _writeBuffer = _readBuffer;
+                        _readBuffer = temp;
+                        _haveData = true;
+                        Monitor.Pulse(this);
+                    }
+                } while (!done);
+            }
+#if !DEBUG
+			catch (Exception ex)
+			{
+				lock (this)
+				{
+					_ex = ex;
+					Monitor.Pulse(this);
+				}
+			}
+#endif
+        }
+
+        private void Go()
+        {
+            if (_workThread != null || _ex != null || _source == null) return;
+            _workThread = new Thread(Decompress);
+            _workThread.Priority = priority;
+            _workThread.IsBackground = true;
+            _workThread.Name = "AudioPipe";
+            _workThread.Start(null);
+        }
+
+        //public new void Dispose()
+        //{
+        //    _buffer.Clear();
+        //}
+
+        public void Close()
+        {
+            lock (this)
+            {
+                _close = true;
+                Monitor.Pulse(this);
+            }
+            if (_workThread != null)
+            {
+                _workThread.Join();
+                _workThread = null;
+            }
+            if (_source != null)
+            {
+                if (own) _source.Close();
+                _source = null;
+            }
+            if (_readBuffer != null)
+            {
+                //_readBuffer.Clear();
+                _readBuffer = null;
+            }
+            if (_writeBuffer != null)
+            {
+                //_writeBuffer.Clear();
+                _writeBuffer = null;
+            }
+        }
+
+        public int Write(AudioBuffer buff)
+        {
+            if (_writeBuffer.Size < _writeBuffer.Length + buff.Length)
+            {
+                AudioBuffer realloced = new AudioBuffer(pcm, _writeBuffer.Size + buff.Size);
+                realloced.Prepare(_writeBuffer, 0, _writeBuffer.Length);
+                _writeBuffer = realloced;
+            }
+            if (_writeBuffer.Length == 0)
+                _writeBuffer.Prepare(buff, 0, buff.Length);
+            else
+            {
+                _writeBuffer.Load(_writeBuffer.Length, buff, 0, buff.Length);
+                _writeBuffer.Length += buff.Length;
+            }
+            lock (this)
+            {
+                if (!_haveData)
+                {
+                    AudioBuffer temp = _writeBuffer;
+                    _writeBuffer = _readBuffer;
+                    _writeBuffer.Length = 0;
+                    _readBuffer = temp;
+                    _haveData = true;
+                    Monitor.Pulse(this);
+                }
+            }
+            return _writeBuffer.Length;
+        }
+
+        public int Read(AudioBuffer buff, int maxLength)
+        {
+            Go();
+
+            bool needToCopy = false;
+            if (_bufferPos != 0)
+                needToCopy = true;
+            else
+                lock (this)
+                {
+                    while (!_haveData && _ex == null)
+                        Monitor.Wait(this);
+                    if (_ex != null)
+                        throw _ex;
+                    if (_bufferPos == 0 && (maxLength < 0 || _readBuffer.Length <= maxLength))
+                    {
+                        buff.Swap(_readBuffer);
+                        _haveData = false;
+                        Monitor.Pulse(this);
+                    }
+                    else
+                        needToCopy = true;
+                }
+            if (needToCopy)
+            {
+                buff.Prepare(_readBuffer, _bufferPos, maxLength);
+                _bufferPos += buff.Length;
+                if (_bufferPos == _readBuffer.Length)
+                {
+                    _bufferPos = 0;
+                    lock (this)
+                    {
+                        _haveData = false;
+                        Monitor.Pulse(this);
+                    }
+                }
+            }
+            _samplePos += buff.Length;
+            return buff.Length;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/AudioSamples.cs

@@ -0,0 +1,142 @@
+using System;
+
+namespace CUETools.Codecs
+{
+    public class AudioSamples
+    {
+        public const uint UINT32_MAX = 0xffffffff;
+
+        unsafe public static void Interlace(int* res, int* src1, int* src2, int n)
+        {
+            for (int i = n; i > 0; i--)
+            {
+                *(res++) = *(src1++);
+                *(res++) = *(src2++);
+            }
+        }
+
+        unsafe public static void Deinterlace(int* dst1, int* dst2, int* src, int n)
+        {
+            for (int i = n; i > 0; i--)
+            {
+                *(dst1++) = *(src++);
+                *(dst2++) = *(src++);
+            }
+        }
+
+        unsafe public static bool MemCmp(int* res, int* smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                if (*(res++) != *(smp++))
+                    return true;
+            return false;
+        }
+
+        unsafe public static void MemCpy(uint* res, uint* smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                *(res++) = *(smp++);
+        }
+
+        unsafe public static void MemCpy(int* res, int* smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                *(res++) = *(smp++);
+        }
+
+        unsafe public static void MemCpy(long* res, long* smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                *(res++) = *(smp++);
+        }
+
+        unsafe public static void MemCpy(short* res, short* smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                *(res++) = *(smp++);
+        }
+
+        unsafe public static void MemCpy(byte* res, byte* smp, int n)
+        {
+            if ((((IntPtr)smp).ToInt64() & 7) == (((IntPtr)res).ToInt64() & 7) && n > 32)
+            {
+                int delta = (int)((8 - (((IntPtr)smp).ToInt64() & 7)) & 7);
+                for (int i = delta; i > 0; i--)
+                    *(res++) = *(smp++);
+                n -= delta;
+
+                MemCpy((long*)res, (long*)smp, n >> 3);
+                int n8 = (n >> 3) << 3;
+                n -= n8;
+                smp += n8;
+                res += n8;
+            }
+            if ((((IntPtr)smp).ToInt64() & 3) == (((IntPtr)res).ToInt64() & 3) && n > 16)
+            {
+                int delta = (int)((4 - (((IntPtr)smp).ToInt64() & 3)) & 3);
+                for (int i = delta; i > 0; i--)
+                    *(res++) = *(smp++);
+                n -= delta;
+
+                MemCpy((int*)res, (int*)smp, n >> 2);
+                int n4 = (n >> 2) << 2;
+                n -= n4;
+                smp += n4;
+                res += n4;
+            }
+            for (int i = n; i > 0; i--)
+                *(res++) = *(smp++);
+        }
+
+        unsafe public static void MemSet(int* res, int smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                *(res++) = smp;
+        }
+
+        unsafe public static void MemSet(long* res, long smp, int n)
+        {
+            for (int i = n; i > 0; i--)
+                *(res++) = smp;
+        }
+
+        unsafe public static void MemSet(byte* res, byte smp, int n)
+        {
+            if (IntPtr.Size == 8 && (((IntPtr)res).ToInt64() & 7) == 0 && smp == 0 && n > 8)
+            {
+                MemSet((long*)res, 0, n >> 3);
+                int n8 = (n >> 3) << 3;
+                n -= n8;
+                res += n8;
+            }
+            if ((((IntPtr)res).ToInt64() & 3) == 0 && smp == 0 && n > 4)
+            {
+                MemSet((int*)res, 0, n >> 2);
+                int n4 = (n >> 2) << 2;
+                n -= n4;
+                res += n4;
+            }
+            for (int i = n; i > 0; i--)
+                *(res++) = smp;
+        }
+
+        unsafe public static void MemSet(byte[] res, byte smp, int offs, int n)
+        {
+            fixed (byte* pres = &res[offs])
+                MemSet(pres, smp, n);
+        }
+
+        unsafe public static void MemSet(int[] res, int smp, int offs, int n)
+        {
+            fixed (int* pres = &res[offs])
+                MemSet(pres, smp, n);
+        }
+
+        unsafe public static void MemSet(long[] res, long smp, int offs, int n)
+        {
+            fixed (long* pres = &res[offs])
+                MemSet(pres, smp, n);
+        }
+    }
+
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/BitReader.cs

@@ -0,0 +1,335 @@
+using System;
+
+namespace CUETools.Codecs
+{
+	unsafe public class BitReader
+    {
+        #region Static Methods
+
+        public static int log2i(int v)
+        {
+            return log2i((uint)v);
+        }
+
+        public static readonly byte[] MultiplyDeBruijnBitPosition = new byte[32]
+        {
+            0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
+            8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
+        };
+
+        public static int log2i(ulong v)
+        {
+            v |= v >> 1; // first round down to one less than a power of 2 
+            v |= v >> 2;
+            v |= v >> 4;
+            v |= v >> 8;
+            v |= v >> 16;
+            if (v >> 32 == 0)
+                return MultiplyDeBruijnBitPosition[(uint)((uint)v * 0x07C4ACDDU) >> 27];
+            return 32 + MultiplyDeBruijnBitPosition[(uint)((uint)(v >> 32) * 0x07C4ACDDU) >> 27];
+        }
+
+        public static int log2i(uint v)
+        {
+            v |= v >> 1; // first round down to one less than a power of 2 
+            v |= v >> 2;
+            v |= v >> 4;
+            v |= v >> 8;
+            v |= v >> 16;
+            return MultiplyDeBruijnBitPosition[(uint)(v * 0x07C4ACDDU) >> 27];
+        }
+
+        public static readonly byte[] byte_to_unary_table = new byte[] 
+		{
+			8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
+			3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+		};
+
+        #endregion
+
+        private byte* buffer_m;
+        private byte* bptr_m;
+        private int buffer_len_m;
+        private int have_bits_m;
+        private ulong cache_m;
+        private ushort crc16_m;
+
+		public int Position
+		{
+			get { return (int)(bptr_m - buffer_m - (have_bits_m >> 3)); }
+		}
+
+		public byte* Buffer
+		{
+			get
+			{
+				return buffer_m;
+			}
+		}
+
+		public BitReader()
+		{
+			buffer_m = null;
+            bptr_m = null;
+			buffer_len_m = 0;
+			have_bits_m = 0;
+			cache_m = 0;
+            crc16_m = 0;
+		}
+
+		public BitReader(byte* _buffer, int _pos, int _len)
+		{
+			Reset(_buffer, _pos, _len);
+		}
+
+		public void Reset(byte* _buffer, int _pos, int _len)
+		{
+			buffer_m = _buffer;
+            bptr_m = _buffer + _pos;
+			buffer_len_m = _len;
+			have_bits_m = 0;
+            cache_m = 0;
+            crc16_m = 0;
+			fill();
+		}
+
+		public void fill()
+		{
+            while (have_bits_m < 56)
+            {
+                have_bits_m += 8;
+                byte b = *(bptr_m++);
+                cache_m |= (ulong)b << (64 - have_bits_m);
+                crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
+            }
+        }
+
+		/* skip any number of bits */
+		public void skipbits(int bits)
+		{
+            while (bits > have_bits_m)
+            {
+                bits -= have_bits_m;
+                cache_m = 0;
+                have_bits_m = 0;
+                fill();
+            }
+            cache_m <<= bits;
+            have_bits_m -= bits;
+		}
+
+        public long read_long()
+        {
+            return ((long)readbits(32) << 32) | readbits(32);
+        }
+
+        public ulong read_ulong()
+        {
+            return ((ulong)readbits(32) << 32) | readbits(32);
+        }
+
+        public int read_int()
+        {
+            return (int)readbits(sizeof(int));
+        }
+        
+        public uint read_uint()
+        {
+            return (uint)readbits(sizeof(uint));
+        }
+
+        public short read_short()
+        {
+            return (short)readbits(16);
+        }
+
+        public ushort read_ushort()
+        {
+            return (ushort)readbits(16);
+        }
+
+		/* supports reading 1 to 32 bits, in big endian format */
+        public uint readbits(int bits)
+        {
+            fill();
+            uint result = (uint)(cache_m >> 64 - bits);
+            skipbits(bits);
+            return result;
+        }
+
+        /* supports reading 1 to 64 bits, in big endian format */
+        public ulong readbits64(int bits)
+		{
+			if (bits <= 56)
+				return readbits(bits);
+			return ((ulong)readbits(32) << bits - 32) | readbits(bits - 32);
+		}
+
+		/* reads a single bit */
+		public uint readbit()
+		{
+            return readbits(1);
+		}
+
+		public uint read_unary()
+		{
+            fill();
+            uint val = 0;
+			ulong result = cache_m >> 56;
+			while (result == 0)
+			{
+				val += 8;
+                cache_m <<= 8;
+                byte b = *(bptr_m++);
+                cache_m |= (ulong)b << (64 - have_bits_m);
+                crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
+                result = cache_m >> 56;
+			}
+			val += byte_to_unary_table[result];
+			skipbits((int)(val & 7) + 1);
+			return val;
+		}
+
+		public void flush()
+		{
+            if ((have_bits_m & 7) > 0)
+            {
+                cache_m <<= have_bits_m & 7;
+                have_bits_m -= have_bits_m & 7;
+            }
+        }
+
+        public ushort get_crc16()
+        {
+            if (have_bits_m == 0)
+                return crc16_m;
+            ushort crc = 0;
+            int n = have_bits_m >> 3;
+            for (int i = 0; i < n; i++)
+                crc = (ushort)((crc << 8) ^ Crc16.table[(crc >> 8) ^ (byte)(cache_m >> (56 - (i << 3)))]);
+            return Crc16.Subtract(crc16_m, crc, n);
+        }
+
+        public int readbits_signed(int bits)
+		{
+			int val = (int)readbits(bits);
+			val <<= (32 - bits);
+			val >>= (32 - bits);
+			return val;
+		}
+
+		public uint read_utf8()
+		{
+			uint x = readbits(8);
+			uint v;
+			int i;
+			if (0 == (x & 0x80))
+			{
+				v = x;
+				i = 0;
+			}
+			else if (0xC0 == (x & 0xE0)) /* 110xxxxx */
+			{
+				v = x & 0x1F;
+				i = 1;
+			}
+			else if (0xE0 == (x & 0xF0)) /* 1110xxxx */
+			{
+				v = x & 0x0F;
+				i = 2;
+			}
+			else if (0xF0 == (x & 0xF8)) /* 11110xxx */
+			{
+				v = x & 0x07;
+				i = 3;
+			}
+			else if (0xF8 == (x & 0xFC)) /* 111110xx */
+			{
+				v = x & 0x03;
+				i = 4;
+			}
+			else if (0xFC == (x & 0xFE)) /* 1111110x */
+			{
+				v = x & 0x01;
+				i = 5;
+			}
+            else if (0xFE == x) /* 11111110 */
+            {
+                v = 0;
+                i = 6;
+            }
+            else
+            {
+                throw new Exception("invalid utf8 encoding");
+            }
+			for (; i > 0; i--)
+			{
+				x = readbits(8);
+				if (0x80 != (x & 0xC0))  /* 10xxxxxx */
+					throw new Exception("invalid utf8 encoding");
+				v <<= 6;
+				v |= (x & 0x3F);
+			}
+			return v;
+		}
+
+		public void read_rice_block(int n, int k, int* r)
+		{
+            fill();
+            fixed (byte* unary_table = byte_to_unary_table)
+            fixed (ushort* t = Crc16.table)
+            {
+                uint mask = (1U << k) - 1;
+                byte* bptr = bptr_m;
+                int have_bits = have_bits_m;
+                ulong cache = cache_m;
+                ushort crc = crc16_m;
+                for (int i = n; i > 0; i--)
+                {
+                    uint bits;
+                    byte* orig_bptr = bptr;
+                    while ((bits = unary_table[cache >> 56]) == 8)
+                    {
+                        cache <<= 8;
+                        byte b = *(bptr++);
+                        cache |= (ulong)b << (64 - have_bits);
+                        crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
+                    }
+                    uint msbs = bits + ((uint)(bptr - orig_bptr) << 3);
+                    // assumes k <= 41 (have_bits < 41 + 7 + 1 + 8 == 57, so we don't loose bits here)
+                    while (have_bits < 56)
+                    {
+                        have_bits += 8;
+                        byte b = *(bptr++);
+                        cache |= (ulong)b << (64 - have_bits);
+                        crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
+                    }
+
+                    int btsk = k + (int)bits + 1;
+                    uint uval = (msbs << k) | (uint)((cache >> (64 - btsk)) & mask);
+                    cache <<= btsk;
+                    have_bits -= btsk;
+                    *(r++) = (int)(uval >> 1 ^ -(int)(uval & 1));
+                }
+                have_bits_m = have_bits;
+                cache_m = cache;
+                bptr_m = bptr;
+                crc16_m = crc;
+            }
+		}
+	}
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/BitWriter.cs

@@ -0,0 +1,370 @@
+using System;
+
+namespace CUETools.Codecs
+{
+    public class BitWriter
+    {
+        private ushort crc16_m;
+        private ulong bit_buf_m;
+        private int bit_left_m;
+        private byte[] buffer;
+        private int buf_start, buf_ptr_m, buf_end;
+        private bool eof;
+
+        public byte[] Buffer
+        {
+            get
+            {
+                return buffer;
+            }
+        }
+
+        public int Length
+        {
+            get
+            {
+                return buf_ptr_m - buf_start;
+            }
+            set
+            {
+                flush();
+                buf_ptr_m = buf_start + value;
+            }
+        }
+
+        public int BitLength
+        {
+            get
+            {
+                return buf_ptr_m * 8 + 64 - bit_left_m;
+            }
+        }
+
+        public ushort get_crc16()
+        {
+            return crc16_m;
+        }
+
+        public BitWriter(byte[] buf, int pos, int len)
+        {
+            buffer = buf;
+            buf_start = pos;
+            buf_ptr_m = pos;
+            buf_end = pos + len;
+            bit_left_m = 64;
+            bit_buf_m = 0;
+            crc16_m = 0;
+            eof = false;
+        }
+
+        public void Reset()
+        {
+            buf_ptr_m = buf_start;
+            bit_left_m = 64;
+            bit_buf_m = 0;
+            crc16_m = 0;
+            eof = false;
+        }
+
+        public void writebytes(int bytes, byte c)
+        {
+            for (; bytes > 0; bytes--)
+            {
+                writebits(8, c);
+            }
+        }
+
+        public unsafe void writeints(int len, int pos, byte* buf)
+        {
+            int old_pos = BitLength;
+            int start = old_pos / 8;
+            int start1 = pos / 8;
+            int end = (old_pos + len) / 8;
+            int end1 = (pos + len) / 8;
+            flush();
+            byte start_val = old_pos % 8 != 0 ? buffer[start] : (byte)0;
+            fixed (byte* buf1 = &buffer[0])
+            {
+                if (old_pos % 8 != 0)
+                    crc16_m = Crc16.Subtract(crc16_m, 0, 1);
+                crc16_m = Crc16.ComputeChecksum(crc16_m, buf + start1, end - start);
+                AudioSamples.MemCpy(buf1 + start, buf + start1, end - start);
+                buf1[start] |= start_val;
+            }
+            buf_ptr_m = end;
+            if ((old_pos + len) % 8 != 0)
+                writebits((old_pos + len) % 8, buf[end1] >> (8 - ((old_pos + len) % 8)));
+        }
+
+        public void write(params char[] chars)
+        {
+            foreach (char c in chars)
+                writebits(8, (byte)c);
+        }
+
+        public void write(string s)
+        {
+            for (int i = 0; i < s.Length; i++)
+                writebits(8, (byte)s[i]);
+        }
+
+        public void write(byte[] s)
+        {
+            for (int i = 0; i < s.Length; i++)
+                writebits(8, s[i]);
+        }
+
+        public void writebits_signed(int bits, int val)
+        {
+            writebits(bits, val & ((1 << bits) - 1));
+        }
+
+        public void writebits_signed(uint bits, int val)
+        {
+            writebits((int)bits, val & ((1 << (int)bits) - 1));
+        }
+
+        public void writebits(int bits, int val)
+        {
+            writebits(bits, (ulong)val);
+        }
+
+        public void writebits(DateTime val)
+        {
+            TimeSpan span = val.ToUniversalTime() - new DateTime(1904, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
+            writebits(32, (ulong)span.TotalSeconds);
+        }
+
+        public void writebits(int bits, uint val)
+        {
+            writebits(bits, (ulong)val);
+        }
+
+        public void writebits(int bits, ulong val)
+        {
+            //assert(bits == 32 || val < (1U << bits));
+
+            if (bits == 0 || eof) return;
+            if (bits < bit_left_m)
+            {
+                bit_left_m -= bits;
+                bit_buf_m |= val << bit_left_m;
+            }
+            else
+            {
+                ulong bb = bit_buf_m | (val >> (bits - bit_left_m));
+                if (buffer != null)
+                {
+                    if (buf_ptr_m + 8 > buf_end)
+                    {
+                        eof = true;
+                        return;
+                    }
+
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >> 56)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >> 48)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >> 40)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >> 32)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >> 24)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >> 16)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb >>  8)]);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ (byte)(bb      )]);
+
+                    buffer[buf_ptr_m + 7] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 6] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 5] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 4] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 3] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 2] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 1] = (byte)(bb & 0xFF); bb >>= 8;
+                    buffer[buf_ptr_m + 0] = (byte)(bb & 0xFF);
+                    buf_ptr_m += 8;
+                }
+                // cannot do this in one shift, because bit_left_m can be 64,
+                // 
+                bit_left_m += 64 - bits;
+                bit_buf_m = bit_left_m == 64 ? 0 : val << bit_left_m;
+            }
+        }
+
+        /// <summary>
+        /// Assumes there's enough space, buffer != null and bits is in range 1..31
+        /// </summary>
+        /// <param name="bits"></param>
+        /// <param name="val"></param>
+//        unsafe void writebits_fast(int bits, uint val, ref byte* buf)
+//        {
+//#if DEBUG
+//            if ((buf_ptr + 3) >= buf_end)
+//            {
+//                eof = true;
+//                return;
+//            }
+//#endif
+//            if (bits < bit_left)
+//            {
+//                bit_buf = (bit_buf << bits) | val;
+//                bit_left -= bits;
+//            }
+//            else
+//            {
+//                uint bb = (bit_buf << bit_left) | (val >> (bits - bit_left));
+//                bit_left += (32 - bits);
+
+//                *(buf++) = (byte)(bb >> 24);
+//                *(buf++) = (byte)(bb >> 16);
+//                *(buf++) = (byte)(bb >> 8);
+//                *(buf++) = (byte)(bb);
+
+//                bit_buf = val;
+//            }
+//        }
+
+        public void write_utf8(int val)
+        {
+            write_utf8((uint)val);
+        }
+
+        public void write_utf8(uint val)
+        {
+            if (val < 0x80)
+            {
+                writebits(8, val);
+                return;
+            }
+            int bytes = (BitReader.log2i(val) + 4) / 5;
+            int shift = (bytes - 1) * 6;
+            writebits(8, (256U - (256U >> bytes)) | (val >> shift));
+            while (shift >= 6)
+            {
+                shift -= 6;
+                writebits(8, 0x80 | ((val >> shift) & 0x3F));
+            }
+        }
+
+        public void write_unary_signed(int val)
+        {
+            // convert signed to unsigned
+            int v = -2 * val - 1;
+            v ^= (v >> 31);
+
+            // write quotient in unary
+            int q = v + 1;
+            while (q > 31)
+            {
+                writebits(31, 0);
+                q -= 31;
+            }
+            writebits(q, 1);
+        }
+
+        public void write_rice_signed(int k, int val)
+        {
+            // convert signed to unsigned
+            int v = -2 * val - 1;
+            v ^= (v >> 31);
+
+            // write quotient in unary
+            int q = (v >> k) + 1;
+            while (q + k > 31)
+            {
+                int b = Math.Min(q + k - 31, 31);
+                writebits(b, 0);
+                q -= b;
+            }
+
+            // write remainder in binary using 'k' bits
+            writebits(k + q, (v & ((1 << k) - 1)) | (1 << k));
+        }
+
+        public unsafe void write_rice_block_signed(byte* fixedbuf, int k, int* residual, int count)
+        {
+            byte* buf = &fixedbuf[buf_ptr_m];
+            ulong bit_buf = bit_buf_m;
+            int bit_left = bit_left_m;
+            ushort crc16 = crc16_m;
+            fixed (ushort *crc16_t = Crc16.table)
+            for (int i = count; i > 0; i--)
+            {
+                int vi = *(residual++);
+                uint v = (uint)((vi << 1) ^ (vi >> 31));
+
+                // write quotient in unary
+                int q = (int)(v >> k) + 1;
+                int bits = k + q;
+                while (bits > 64)
+                {
+#if DEBUG
+                    if (buf + 1 > fixedbuf + buf_end)
+                    {
+                        eof = true;
+                        return;
+                    }
+#endif
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bit_buf >> 56))]);
+                    bit_buf <<= 8;
+                    bits -= 8;
+                }
+
+                // write remainder in binary using 'k' bits
+                //writebits_fast(k + q, (uint)((v & ((1 << k) - 1)) | (1 << k)), ref buf);
+                ulong val = (uint)((v & ((1U << k) - 1)) | (1U << k));
+                if (bits < bit_left)
+                {
+                    bit_left -= bits;
+                    bit_buf |= val << bit_left;
+                }
+                else
+                {
+                    ulong bb = bit_buf | (val >> (bits - bit_left));
+#if DEBUG
+                    if (buf + 8 > fixedbuf + buf_end)
+                    {
+                        eof = true;
+                        return;
+                    }
+#endif
+
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 56))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 48))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 40))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 32))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 24))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 16))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 8))]);
+                    crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb))]);
+
+                    bit_left += 64 - bits;
+                    bit_buf = (val << bit_left - 1) << 1;
+                }
+            }
+            crc16_m = crc16;
+            buf_ptr_m = (int)(buf - fixedbuf);
+            bit_buf_m = bit_buf;
+            bit_left_m = bit_left;
+        }
+
+        public void flush()
+        {
+            while (bit_left_m < 64 && !eof)
+            {
+                if (buf_ptr_m >= buf_end)
+                {
+                    eof = true;
+                    break;
+                }
+                if (buffer != null)
+                {
+                    byte b = (byte)(bit_buf_m >> 56);
+                    crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
+                    buffer[buf_ptr_m] = b;
+                }
+                buf_ptr_m++;
+                bit_buf_m <<= 8;
+                bit_left_m += 8;
+            }
+            bit_left_m = 64;
+            bit_buf_m = 0;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CRC/CRC16.cs

@@ -0,0 +1,164 @@
+using System;
+namespace CUETools.Codecs
+{
+	public static class Crc16
+	{
+        const int GF2_DIM = 16;
+        public static ushort[] table = new ushort[256];
+        private static readonly ushort[,] combineTable = new ushort[GF2_DIM, GF2_DIM];
+        private static readonly ushort[,] substractTable = new ushort[GF2_DIM, GF2_DIM];
+
+		public static unsafe ushort ComputeChecksum(ushort crc, byte[] bytes, int pos, int count)
+		{
+			fixed (byte* bs = bytes)
+				return ComputeChecksum(crc, bs + pos, count);
+		}
+
+        public static unsafe ushort ComputeChecksum(ushort crc, byte* bytes, int count)
+		{
+			fixed (ushort* t = table)
+                for (int i = count; i > 0; i--)
+                {
+                    crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ *(bytes++)]);
+                }
+			return crc;
+		}
+
+        const ushort polynomial = 0x8005;
+        const ushort reversePolynomial = 0x4003;
+
+		static unsafe Crc16()
+		{
+            for (ushort i = 0; i < table.Length; i++)
+            {
+                int crc = i;
+                for (int j = 0; j < GF2_DIM; j++)
+                {
+                    if ((crc & (1U << (GF2_DIM - 1))) != 0)
+                        crc = ((crc << 1) ^ polynomial);
+                    else
+                        crc <<= 1;
+                }
+                table[i] = (ushort)(crc & ((1 << GF2_DIM) - 1));
+            }
+
+            combineTable[0, 0] = Crc16.Reflect(polynomial);
+            substractTable[0, GF2_DIM - 1] = reversePolynomial;
+            for (int n = 1; n < GF2_DIM; n++)
+            {
+                combineTable[0, n] = (ushort)(1 << (n - 1));
+                substractTable[0, n - 1] = (ushort)(1 << n);
+            }
+            
+            fixed (ushort* ct = &combineTable[0, 0], st = &substractTable[0, 0])
+            {
+                //for (int i = 0; i < GF2_DIM; i++)
+                //	st[32 + i] = ct[i];
+                //invert_binary_matrix(st + 32, st, GF2_DIM);
+
+                for (int i = 1; i < GF2_DIM; i++)
+                {
+                    gf2_matrix_square(ct + i * GF2_DIM, ct + (i - 1) * GF2_DIM);
+                    gf2_matrix_square(st + i * GF2_DIM, st + (i - 1) * GF2_DIM);
+                }
+            }
+        }
+
+        private static unsafe ushort gf2_matrix_times(ushort* mat, ushort uvec)
+        {
+            int vec = ((int) uvec) << 16;
+            return (ushort)(
+                (*(mat++) & ((vec << 15) >> 31)) ^
+                (*(mat++) & ((vec << 14) >> 31)) ^
+                (*(mat++) & ((vec << 13) >> 31)) ^
+                (*(mat++) & ((vec << 12) >> 31)) ^
+                (*(mat++) & ((vec << 11) >> 31)) ^
+                (*(mat++) & ((vec << 10) >> 31)) ^
+                (*(mat++) & ((vec << 09) >> 31)) ^
+                (*(mat++) & ((vec << 08) >> 31)) ^
+                (*(mat++) & ((vec << 07) >> 31)) ^
+                (*(mat++) & ((vec << 06) >> 31)) ^
+                (*(mat++) & ((vec << 05) >> 31)) ^
+                (*(mat++) & ((vec << 04) >> 31)) ^
+                (*(mat++) & ((vec << 03) >> 31)) ^
+                (*(mat++) & ((vec << 02) >> 31)) ^
+                (*(mat++) & ((vec << 01) >> 31)) ^
+                (*(mat++) & (vec >> 31)));
+        }
+
+        private static unsafe void gf2_matrix_square(ushort* square, ushort* mat)
+        {
+            for (int n = 0; n < GF2_DIM; n++)
+                square[n] = gf2_matrix_times(mat, mat[n]);
+        }
+
+        public static ushort Reflect(ushort crc)
+        {
+            return (ushort)Crc32.Reflect(crc, 16);
+        }
+
+        public static unsafe ushort Combine(ushort crc1, ushort crc2, long len2)
+        {
+            crc1 = Crc16.Reflect(crc1);
+            crc2 = Crc16.Reflect(crc2);
+
+            /* degenerate case */
+            if (len2 == 0)
+                return crc1;
+            if (crc1 == 0)
+                return crc2;
+            if (len2 < 0)
+                throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+            fixed (ushort* ct = &combineTable[0, 0])
+            {
+                int n = 3;
+                do
+                {
+                    /* apply zeros operator for this bit of len2 */
+                    if ((len2 & 1) != 0)
+                        crc1 = gf2_matrix_times(ct + GF2_DIM * n, crc1);
+                    len2 >>= 1;
+                    n = (n + 1) & (GF2_DIM - 1);
+                    /* if no more bits set, then done */
+                } while (len2 != 0);
+            }
+
+            /* return combined crc */
+            crc1 ^= crc2;
+            crc1 = Crc16.Reflect(crc1);
+            return crc1;
+        }
+
+        public static unsafe ushort Subtract(ushort crc1, ushort crc2, long len2)
+        {
+            crc1 = Crc16.Reflect(crc1);
+            crc2 = Crc16.Reflect(crc2);
+            /* degenerate case */
+            if (len2 == 0)
+                return crc1;
+            if (len2 < 0)
+                throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+            crc1 ^= crc2;
+
+            fixed (ushort* st = &substractTable[0, 0])
+            {
+                int n = 3;
+                do
+                {
+                    /* apply zeros operator for this bit of len2 */
+                    if ((len2 & 1) != 0)
+                        crc1 = gf2_matrix_times(st + GF2_DIM * n, crc1);
+                    len2 >>= 1;
+                    n = (n + 1) & (GF2_DIM - 1);
+                    /* if no more bits set, then done */
+                } while (len2 != 0);
+            }
+
+            /* return combined crc */
+            crc1 = Crc16.Reflect(crc1);
+            return crc1;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CRC/CRC16CCITT.cs

@@ -0,0 +1,51 @@
+namespace CUETools.Codecs
+{
+	public enum InitialCrcValue { Zeros, NonZero1 = 0xffff, NonZero2 = 0x1D0F }
+
+	public class Crc16Ccitt
+	{
+		const ushort poly = 4129;
+		ushort[] table = new ushort[256];
+		ushort initialValue = 0;
+
+		public ushort ComputeChecksum(byte[] bytes, int pos, int count)
+		{
+			ushort crc = this.initialValue;
+			for (int i = pos; i < pos + count; i++)
+			{
+				crc = (ushort)((crc << 8) ^ table[((crc >> 8) ^ (0xff & bytes[i]))]);
+			}
+			return crc;
+		}
+
+		public byte[] ComputeChecksumBytes(byte[] bytes, int pos, int count)
+		{
+			ushort crc = ComputeChecksum(bytes, pos, count);
+			return new byte[] { (byte)(crc >> 8), (byte)(crc & 0x00ff) };
+		}
+
+		public Crc16Ccitt(InitialCrcValue initialValue)
+		{
+			this.initialValue = (ushort)initialValue;
+			ushort temp, a;
+			for (int i = 0; i < table.Length; i++)
+			{
+				temp = 0;
+				a = (ushort)(i << 8);
+				for (int j = 0; j < 8; j++)
+				{
+					if (((temp ^ a) & 0x8000) != 0)
+					{
+						temp = (ushort)((temp << 1) ^ poly);
+					}
+					else
+					{
+						temp <<= 1;
+					}
+					a <<= 1;
+				}
+				table[i] = temp;
+			}
+		}
+	}
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CRC/CRC32.cs

@@ -0,0 +1,259 @@
+using System;
+
+namespace CUETools.Codecs
+{
+	public static class Crc32
+	{
+		public static readonly uint[] table;
+
+		public static uint ComputeChecksum(uint crc, byte val)
+		{
+			return (crc >> 8) ^ table[(crc & 0xff) ^ val];
+		}
+
+		public static unsafe uint ComputeChecksum(uint crc, byte* bytes, int count)
+		{
+			fixed (uint *t = table)
+				for (int i = 0; i < count; i++)
+					crc = (crc >> 8) ^ t[(crc ^ bytes[i]) & 0xff];
+			return crc;
+		}
+
+		public static unsafe uint ComputeChecksum(uint crc, byte[] bytes, int pos, int count)
+		{
+			fixed (byte* pbytes = &bytes[pos])
+				return ComputeChecksum(crc, pbytes, count);
+		}
+
+		public static uint ComputeChecksum(uint crc, uint s)
+		{
+			return ComputeChecksum(ComputeChecksum(ComputeChecksum(ComputeChecksum(
+				crc, (byte)s), (byte)(s >> 8)), (byte)(s >> 16)), (byte)(s >> 24));
+		}
+
+		public static unsafe uint ComputeChecksum(uint crc, int* samples, int count)
+		{
+			for (int i = 0; i < count; i++)
+			{
+				int s1 = samples[2 * i], s2 = samples[2 * i + 1];
+				crc = ComputeChecksum(ComputeChecksum(ComputeChecksum(ComputeChecksum(
+					crc, (byte)s1), (byte)(s1 >> 8)), (byte)s2), (byte)(s2 >> 8));
+			}
+			return crc;
+		}
+
+		internal static uint Reflect(uint val, int ch)
+		{
+			uint value = 0;
+			// Swap bit 0 for bit 7
+			// bit 1 for bit 6, etc.
+			for (int i = 1; i < (ch + 1); i++)
+			{
+				if (0 != (val & 1))
+					value |= 1U << (ch - i);
+				val >>= 1;
+			}
+			return value;
+		}
+
+		const uint uPolynomial = 0x04c11db7;
+        const uint uReversePolynomial = 0xedb88320;
+        const uint uReversePolynomial2 = 0xdb710641;
+
+		private static readonly uint[,] combineTable;
+		private static readonly uint[,] substractTable;
+
+#if need_invert_binary_matrix
+		static unsafe void invert_binary_matrix(uint* mat, uint* inv, int rows)
+		{
+			int cols, i, j;
+			uint tmp;
+
+			cols = rows;
+
+			for (i = 0; i < rows; i++) inv[i] = (1U << i);
+
+			/* First -- convert into upper triangular */
+
+			for (i = 0; i < cols; i++)
+			{
+
+				/* Swap rows if we ave a zero i,i element.  If we can't swap, then the 
+				   matrix was not invertible */
+
+				if ((mat[i] & (1 << i)) == 0)
+				{
+					for (j = i + 1; j < rows && (mat[j] & (1 << i)) == 0; j++) ;
+					if (j == rows)
+						throw new Exception("Matrix not invertible");
+					tmp = mat[i]; mat[i] = mat[j]; mat[j] = tmp;
+					tmp = inv[i]; inv[i] = inv[j]; inv[j] = tmp;
+				}
+
+				/* Now for each j>i, add A_ji*Ai to Aj */
+				for (j = i + 1; j != rows; j++)
+				{
+					if ((mat[j] & (1 << i)) != 0)
+					{
+						mat[j] ^= mat[i];
+						inv[j] ^= inv[i];
+					}
+				}
+			}
+
+			/* Now the matrix is upper triangular.  Start at the top and multiply down */
+
+			for (i = rows - 1; i >= 0; i--)
+			{
+				for (j = 0; j < i; j++)
+				{
+					if ((mat[j] & (1 << i)) != 0)
+					{
+						/*        mat[j] ^= mat[i]; */
+						inv[j] ^= inv[i];
+					}
+				}
+			}
+		}
+#endif
+
+		static unsafe Crc32()
+		{
+			table = new uint[256];
+			for (uint i = 0; i < table.Length; i++)
+			{
+				table[i] = Reflect(i, 8) << 24;
+				for (int j = 0; j < 8; j++)
+					table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : uPolynomial);
+				table[i] = Reflect(table[i], 32);
+			}
+			combineTable = new uint[GF2_DIM, GF2_DIM];
+			substractTable = new uint[GF2_DIM, GF2_DIM];
+            combineTable[0, 0] = uReversePolynomial;
+            substractTable[0, 31] = uReversePolynomial2;
+			for (int n = 1; n < GF2_DIM; n++)
+			{
+				combineTable[0, n] = 1U << (n - 1);
+				substractTable[0, n - 1] = 1U << n;
+			}
+			fixed (uint* ct = &combineTable[0, 0], st = &substractTable[0, 0])
+			{
+				//for (int i = 0; i < GF2_DIM; i++)
+				//	st[32 + i] = ct[i];
+				//invert_binary_matrix(st + 32, st, GF2_DIM);
+
+				for (int i = 1; i < GF2_DIM; i++)
+				{
+					gf2_matrix_square(ct + i * 32, ct + (i - 1) * 32);
+					gf2_matrix_square(st + i * 32, st + (i - 1) * 32);
+				}
+			}
+		}
+
+		const int GF2_DIM = 32;
+		//const int GF2_DIM2 = 67;
+
+        private static unsafe uint gf2_matrix_times(uint* umat, uint uvec)
+        {
+            int vec = (int)uvec;
+            int* mat = (int*)umat;
+            return (uint)(
+                (*(mat++) & ((vec << 31) >> 31)) ^
+                (*(mat++) & ((vec << 30) >> 31)) ^
+                (*(mat++) & ((vec << 29) >> 31)) ^
+                (*(mat++) & ((vec << 28) >> 31)) ^
+                (*(mat++) & ((vec << 27) >> 31)) ^
+                (*(mat++) & ((vec << 26) >> 31)) ^
+                (*(mat++) & ((vec << 25) >> 31)) ^
+                (*(mat++) & ((vec << 24) >> 31)) ^
+                (*(mat++) & ((vec << 23) >> 31)) ^
+                (*(mat++) & ((vec << 22) >> 31)) ^
+                (*(mat++) & ((vec << 21) >> 31)) ^
+                (*(mat++) & ((vec << 20) >> 31)) ^
+                (*(mat++) & ((vec << 19) >> 31)) ^
+                (*(mat++) & ((vec << 18) >> 31)) ^
+                (*(mat++) & ((vec << 17) >> 31)) ^
+                (*(mat++) & ((vec << 16) >> 31)) ^
+                (*(mat++) & ((vec << 15) >> 31)) ^
+                (*(mat++) & ((vec << 14) >> 31)) ^
+                (*(mat++) & ((vec << 13) >> 31)) ^
+                (*(mat++) & ((vec << 12) >> 31)) ^
+                (*(mat++) & ((vec << 11) >> 31)) ^
+                (*(mat++) & ((vec << 10) >> 31)) ^
+                (*(mat++) & ((vec << 09) >> 31)) ^
+                (*(mat++) & ((vec << 08) >> 31)) ^
+                (*(mat++) & ((vec << 07) >> 31)) ^
+                (*(mat++) & ((vec << 06) >> 31)) ^
+                (*(mat++) & ((vec << 05) >> 31)) ^
+                (*(mat++) & ((vec << 04) >> 31)) ^
+                (*(mat++) & ((vec << 03) >> 31)) ^
+                (*(mat++) & ((vec << 02) >> 31)) ^
+                (*(mat++) & ((vec << 01) >> 31)) ^
+                (*(mat++) & (vec >> 31)));
+        }
+
+		/* ========================================================================= */
+		private static unsafe void gf2_matrix_square(uint *square, uint *mat)
+		{
+			for (int n = 0; n < GF2_DIM; n++)
+				square[n] = gf2_matrix_times(mat, mat[n]);
+		}
+
+		public static unsafe uint Combine(uint crc1, uint crc2, long len2)
+		{
+			/* degenerate case */
+			if (len2 == 0)
+				return crc1;
+			if (crc1 == 0)
+				return crc2;
+			if (len2 < 0)
+				throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+			fixed (uint* ct = &combineTable[0, 0])
+			{
+				int n = 3;
+				do
+				{
+					/* apply zeros operator for this bit of len2 */
+					if ((len2 & 1) != 0)
+						crc1 = gf2_matrix_times(ct + 32 * n, crc1);
+					len2 >>= 1;
+					n = (n + 1) & (GF2_DIM - 1);
+					/* if no more bits set, then done */
+				} while (len2 != 0);
+			}
+
+			/* return combined crc */
+			crc1 ^= crc2;
+			return crc1;
+		}
+
+		public static unsafe uint Subtract(uint crc1, uint crc2, long len2)
+		{
+			/* degenerate case */
+			if (len2 == 0)
+				return crc1;
+			if (len2 < 0)
+				throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+			crc1 ^= crc2;
+
+			fixed (uint* st = &substractTable[0, 0])
+			{
+				int n = 3;
+				do
+				{
+					/* apply zeros operator for this bit of len2 */
+					if ((len2 & 1) != 0)
+						crc1 = gf2_matrix_times(st + 32 * n, crc1);
+					len2 >>= 1;
+					n = (n + 1) & (GF2_DIM - 1);
+					/* if no more bits set, then done */
+				} while (len2 != 0);
+			}
+
+			/* return combined crc */
+			return crc1;
+		}
+	}
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CRC/CRC8.cs

@@ -0,0 +1,43 @@
+namespace CUETools.Codecs
+{
+	public class Crc8
+	{
+		private const ushort poly8 = 0x07;
+
+		private ushort[] table = new ushort[256];
+
+		public Crc8()
+		{
+			int bits = 8;
+			ushort poly = (ushort) (poly8 + (1U << bits));
+			for (ushort i = 0; i < table.Length; i++)
+			{
+				ushort crc = i;
+				for (int j = 0; j < bits; j++)
+				{
+					if ((crc & (1U << (bits - 1))) != 0)
+						crc = (ushort)((crc << 1) ^ poly);
+					else
+						crc <<= 1;
+				}
+				table[i] = (ushort)(crc & 0x00ff);
+			}
+        }
+
+        public byte ComputeChecksum(byte[] bytes, int pos, int count)
+        {
+            ushort crc = 0;
+            for (int i = pos; i < pos + count; i++)
+                crc = table[crc ^ bytes[i]];
+            return (byte)crc;
+        }
+
+        public unsafe byte ComputeChecksum(byte* bytes, int pos, int count)
+        {
+            ushort crc = 0;
+            for (int i = pos; i < pos + count; i++)
+                crc = table[crc ^ bytes[i]];
+            return (byte)crc;
+        }
+	}
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CUETools.Codecs.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Version>2.1.9.0</Version>
+    <AssemblyName>CUETools.Codecs</AssemblyName>
+    <RootNamespace>CUETools.Codecs</RootNamespace>
+    <Product>CUETools</Product>
+    <Description>A library for encoding and decoding audio.</Description>
+    <Copyright>Copyright (c) 2008-2021 Grigory Chudov</Copyright>
+    <Authors>Grigory Chudov</Authors>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputPath>..\bin\$(Configuration)\</OutputPath>
+    <RepositoryUrl>https://github.com/gchudov/cuetools.net</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <Company />
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="11.0.1" />
+  </ItemGroup>
+
+</Project>

Aaru.Compression/cuetools.net/CUETools.Codecs/CUEToolsCodecsConfig.cs

@@ -0,0 +1,94 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace CUETools.Codecs
+{
+    public class CUEToolsCodecsConfig
+    {
+        [JsonIgnore]
+        public Dictionary<string, CUEToolsFormat> formats;
+        public List<IAudioEncoderSettings> encoders;
+        public List<IAudioDecoderSettings> decoders;
+        [JsonIgnore]
+        public EncoderListViewModel encodersViewModel;
+        [JsonIgnore]
+        public DecoderListViewModel decodersViewModel;
+
+        public CUEToolsCodecsConfig()
+        {
+            encoders = new List<IAudioEncoderSettings>();
+            decoders = new List<IAudioDecoderSettings>();
+            encodersViewModel = new EncoderListViewModel(encoders);
+            decodersViewModel = new DecoderListViewModel(decoders);
+            formats = new Dictionary<string, CUEToolsFormat>();
+        }
+
+        public CUEToolsCodecsConfig(CUEToolsCodecsConfig src)
+        {
+            encoders = new List<IAudioEncoderSettings>();
+            decoders = new List<IAudioDecoderSettings>();
+            src.encoders.ForEach(item => encoders.Add(item.Clone()));
+            src.decoders.ForEach(item => decoders.Add(item.Clone()));
+            encodersViewModel = new EncoderListViewModel(encoders);
+            decodersViewModel = new DecoderListViewModel(decoders);
+            formats = new Dictionary<string, CUEToolsFormat>();
+            foreach (var fmt in src.formats)
+                formats.Add(fmt.Key, fmt.Value.Clone(this));
+        }
+
+        public void Init(List<IAudioEncoderSettings> src_encoders, List<IAudioDecoderSettings> src_decoders)
+        {
+            encoders = new List<IAudioEncoderSettings>();
+            decoders = new List<IAudioDecoderSettings>();
+            src_encoders.ForEach(item => encoders.Add(item.Clone()));
+            src_decoders.ForEach(item => decoders.Add(item.Clone()));
+
+            if (Type.GetType("Mono.Runtime", false) == null)
+            {
+                encoders.Add(new CommandLine.EncoderSettings("flake.exe", "flac", true, "0 1 2 3 4 5 6 7 8 9 10 11 12", "8", "flake.exe", "-%M - -o %O -p %P"));
+                encoders.Add(new CommandLine.EncoderSettings("takc.exe", "tak", true, "0 1 2 2e 2m 3 3e 3m 4 4e 4m", "2", "takc.exe", "-e -p%M -overwrite - %O"));
+                encoders.Add(new CommandLine.EncoderSettings("ffmpeg.exe", "m4a", true, "", "", "ffmpeg.exe", "-i - -f ipod -acodec alac -y %O"));
+                encoders.Add(new CommandLine.EncoderSettings("lame.exe (VBR)", "mp3", false, "V9 V8 V7 V6 V5 V4 V3 V2 V1 V0", "V2", "lame.exe", "--vbr-new -%M - %O"));
+                encoders.Add(new CommandLine.EncoderSettings("lame.exe (CBR)", "mp3", false, "96 128 192 256 320", "256", "lame.exe", "-m s -q 0 -b %M --noreplaygain - %O"));
+                encoders.Add(new CommandLine.EncoderSettings("oggenc.exe", "ogg", false, "-1 -0.5 0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 6 6.5 7 7.5 8", "3", "oggenc.exe", "-q %M - -o %O"));
+                encoders.Add(new CommandLine.EncoderSettings("opusenc.exe", "opus", false, "6 16 32 48 64 96 128 192 256", "128", "opusenc.exe", "--bitrate %M - %O"));
+                encoders.Add(new CommandLine.EncoderSettings("neroAacEnc.exe", "m4a", false, "0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9", "0.4", "neroAacEnc.exe", "-q %M -if - -of %O"));
+                encoders.Add(new CommandLine.EncoderSettings("qaac.exe (tvbr)", "m4a", false, "10 20 30 40 50 60 70 80 90 100 110 127", "80", "qaac.exe", "-s -V %M -q 2 - -o %O"));
+
+                decoders.Add(new CommandLine.DecoderSettings("takc.exe", "tak", "takc.exe", "-d %I -"));
+                decoders.Add(new CommandLine.DecoderSettings("ffmpeg.exe", "m4a", "ffmpeg.exe", "-v 0 -i %I -f wav -"));
+            }
+            else
+            {
+                // !!!
+            }
+
+            encodersViewModel = new EncoderListViewModel(encoders);
+            decodersViewModel = new DecoderListViewModel(decoders);
+
+            formats = new Dictionary<string, CUEToolsFormat>();
+            formats.Add("flac", new CUEToolsFormat("flac", CUEToolsTagger.TagLibSharp, true, false, true, true, encodersViewModel.GetDefault("flac", true), null, decodersViewModel.GetDefault("flac")));
+            formats.Add("wv", new CUEToolsFormat("wv", CUEToolsTagger.TagLibSharp, true, false, true, true, encodersViewModel.GetDefault("wv", true), null, decodersViewModel.GetDefault("wv")));
+            formats.Add("ape", new CUEToolsFormat("ape", CUEToolsTagger.TagLibSharp, true, false, true, true, encodersViewModel.GetDefault("ape", true), null, decodersViewModel.GetDefault("ape")));
+            formats.Add("tta", new CUEToolsFormat("tta", CUEToolsTagger.APEv2, true, false, false, true, encodersViewModel.GetDefault("tta", true), null, decodersViewModel.GetDefault("tta")));
+            formats.Add("m2ts", new CUEToolsFormat("m2ts", CUEToolsTagger.APEv2, true, false, false, true, null, null, decodersViewModel.GetDefault("m2ts")));
+            formats.Add("mpls", new CUEToolsFormat("mpls", CUEToolsTagger.APEv2, true, false, false, true, null, null, decodersViewModel.GetDefault("mpls")));
+            formats.Add("wav", new CUEToolsFormat("wav", CUEToolsTagger.TagLibSharp, true, false, false, true, encodersViewModel.GetDefault("wav", true), null, decodersViewModel.GetDefault("wav")));
+            formats.Add("m4a", new CUEToolsFormat("m4a", CUEToolsTagger.TagLibSharp, true, true, false, true, encodersViewModel.GetDefault("m4a", true), encodersViewModel.GetDefault("m4a", false), decodersViewModel.GetDefault("m4a")));
+            formats.Add("tak", new CUEToolsFormat("tak", CUEToolsTagger.APEv2, true, false, true, true, encodersViewModel.GetDefault("tak", true), null, decodersViewModel.GetDefault("tak")));
+            formats.Add("wma", new CUEToolsFormat("wma", CUEToolsTagger.TagLibSharp, true, true, false, true, encodersViewModel.GetDefault("wma", true), encodersViewModel.GetDefault("wma", false), decodersViewModel.GetDefault("wma")));
+            formats.Add("mp3", new CUEToolsFormat("mp3", CUEToolsTagger.TagLibSharp, false, true, false, true, null, encodersViewModel.GetDefault("mp3", false), null));
+            formats.Add("ogg", new CUEToolsFormat("ogg", CUEToolsTagger.TagLibSharp, false, true, false, true, null, encodersViewModel.GetDefault("ogg", false), null));
+            formats.Add("opus", new CUEToolsFormat("opus", CUEToolsTagger.TagLibSharp, false, true, false, true, null, encodersViewModel.GetDefault("opus", false), null));
+            formats.Add("mlp", new CUEToolsFormat("mlp", CUEToolsTagger.APEv2, true, false, false, false, null, null, decodersViewModel.GetDefault("mlp")));
+            formats.Add("aob", new CUEToolsFormat("aob", CUEToolsTagger.APEv2, true, false, false, false, null, null, decodersViewModel.GetDefault("aob")));
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CUEToolsFormat.cs

@@ -0,0 +1,55 @@
+namespace CUETools.Codecs
+{
+    public class CUEToolsFormat
+    {
+        public CUEToolsFormat(
+            string _extension,
+            CUEToolsTagger _tagger,
+            bool _allowLossless,
+            bool _allowLossy,
+            bool _allowEmbed,
+            bool _builtin,
+            AudioEncoderSettingsViewModel _encoderLossless,
+            AudioEncoderSettingsViewModel _encoderLossy,
+            AudioDecoderSettingsViewModel _decoder)
+        {
+            extension = _extension;
+            tagger = _tagger;
+            allowLossless = _allowLossless;
+            allowLossy = _allowLossy;
+            allowEmbed = _allowEmbed;
+            builtin = _builtin;
+            encoderLossless = _encoderLossless;
+            encoderLossy = _encoderLossy;
+            decoder = _decoder;
+        }
+        public string DotExtension
+        {
+            get
+            {
+                return "." + extension;
+            }
+        }
+
+        public CUEToolsFormat Clone(CUEToolsCodecsConfig cfg)
+        {
+            var res = this.MemberwiseClone() as CUEToolsFormat;
+            if (decoder != null) cfg.decodersViewModel.TryGetValue(decoder.Settings.Extension, decoder.Settings.Name, out res.decoder);
+            if (encoderLossy != null) cfg.encodersViewModel.TryGetValue(encoderLossy.Settings.Extension, encoderLossy.Lossless, encoderLossy.Settings.Name, out res.encoderLossy);
+            if (encoderLossless != null) cfg.encodersViewModel.TryGetValue(encoderLossless.Settings.Extension, encoderLossless.Lossless, encoderLossless.Settings.Name, out res.encoderLossless);
+            return res;
+        }
+
+        public override string ToString()
+        {
+            return extension;
+        }
+
+        public string extension;
+        public AudioEncoderSettingsViewModel encoderLossless;
+        public AudioEncoderSettingsViewModel encoderLossy;
+        public AudioDecoderSettingsViewModel decoder;
+        public CUEToolsTagger tagger;
+        public bool allowLossless, allowLossy, allowEmbed, builtin;
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CUEToolsTagger.cs

@@ -0,0 +1,9 @@
+namespace CUETools.Codecs
+{
+    public enum CUEToolsTagger
+    {
+        TagLibSharp = 0,
+        APEv2 = 1,
+        ID3v2 = 2,
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CommandLine/AudioDecoder.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace CUETools.Codecs.CommandLine
+{
+    public class AudioDecoder : IAudioSource
+    {
+        string _path;
+        Process _decoderProcess;
+        WAV.AudioDecoder rdr;
+
+        private DecoderSettings m_settings;
+        public IAudioDecoderSettings Settings => m_settings;
+
+        public long Position
+        {
+            get
+            {
+                Initialize();
+                return rdr.Position;
+            }
+            set
+            {
+                Initialize();
+                rdr.Position = value;
+            }
+        }
+
+        public TimeSpan Duration
+        {
+            get
+            {
+                Initialize();
+                return rdr.Duration;
+            }
+        }
+
+        public long Length
+        {
+            get
+            {
+                Initialize();
+                return rdr.Length;
+            }
+        }
+
+        public long Remaining
+        {
+            get
+            {
+                Initialize();
+                return rdr.Remaining;
+            }
+        }
+
+        public AudioPCMConfig PCM
+        {
+            get
+            {
+                Initialize();
+                return rdr.PCM;
+            }
+        }
+
+        public string Path { get { return _path; } }
+
+        public AudioDecoder(DecoderSettings settings, string path, Stream IO)
+        {
+            m_settings = settings;
+            _path = path;
+            _decoderProcess = null;
+            rdr = null;
+        }
+
+        void Initialize()
+        {
+            if (_decoderProcess != null)
+                return;
+            _decoderProcess = new Process();
+            _decoderProcess.StartInfo.FileName = m_settings.Path;
+            _decoderProcess.StartInfo.Arguments = m_settings.Parameters.Replace("%I", "\"" + _path + "\"");
+            _decoderProcess.StartInfo.CreateNoWindow = true;
+            _decoderProcess.StartInfo.RedirectStandardOutput = true;
+            _decoderProcess.StartInfo.UseShellExecute = false;
+            bool started = false;
+            Exception ex = null;
+            try
+            {
+                started = _decoderProcess.Start();
+                if (started)
+                    _decoderProcess.PriorityClass = Process.GetCurrentProcess().PriorityClass;
+            }
+            catch (Exception _ex)
+            {
+                ex = _ex;
+            }
+            if (!started)
+            {
+                _decoderProcess = null;
+                throw new Exception(m_settings.Path + ": " + (ex == null ? "please check the path" : ex.Message));
+            }
+            rdr = new WAV.AudioDecoder(new WAV.DecoderSettings(), _path, _decoderProcess.StandardOutput.BaseStream);
+        }
+
+        public void Close()
+        {
+            if (rdr != null)
+                rdr.Close();
+            if (_decoderProcess != null && !_decoderProcess.HasExited)
+                try { _decoderProcess.Kill(); _decoderProcess.WaitForExit(); }
+                catch { }
+        }
+
+        public int Read(AudioBuffer buff, int maxLength)
+        {
+            Initialize();
+            return rdr.Read(buff, maxLength);
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CommandLine/AudioEncoder.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace CUETools.Codecs.CommandLine
+{
+    public class AudioEncoder : IAudioDest
+    {
+        string _path;
+        Process _encoderProcess;
+        WAV.AudioEncoder wrt;
+        CyclicBuffer outputBuffer = null;
+        bool useTempFile = false;
+        string tempFile = null;
+        long _finalSampleCount = -1;
+        bool closed = false;
+
+        public long Position
+        {
+            get
+            {
+                return wrt.Position;
+            }
+        }
+
+        public long FinalSampleCount
+        {
+            set { _finalSampleCount = wrt.FinalSampleCount = value; }
+        }
+
+        // !!!! Must not start the process in constructor, so that we can set CompressionLevel via Settings!
+        private EncoderSettings m_settings;
+        public IAudioEncoderSettings Settings => m_settings;
+
+        public string Path { get { return _path; } }
+
+        public AudioEncoder(EncoderSettings settings, string path, Stream IO = null)
+        {
+            m_settings = settings;
+            _path = path;
+            useTempFile = m_settings.Parameters.Contains("%I");
+            tempFile = path + ".tmp.wav";
+
+            _encoderProcess = new Process();
+            _encoderProcess.StartInfo.FileName = m_settings.Path;
+            _encoderProcess.StartInfo.Arguments = m_settings.Parameters.Replace("%O", "\"" + path + "\"").Replace("%M", m_settings.EncoderMode).Replace("%P", m_settings.Padding.ToString()).Replace("%I", "\"" + tempFile + "\"");
+            _encoderProcess.StartInfo.CreateNoWindow = true;
+            if (!useTempFile)
+                _encoderProcess.StartInfo.RedirectStandardInput = true;
+            _encoderProcess.StartInfo.UseShellExecute = false;
+            if (!m_settings.Parameters.Contains("%O"))
+                _encoderProcess.StartInfo.RedirectStandardOutput = true;
+            if (useTempFile)
+            {
+                wrt = new WAV.AudioEncoder(new WAV.EncoderSettings(settings.PCM), tempFile);
+                return;
+            }
+            bool started = false;
+            Exception ex = null;
+            try
+            {
+                started = _encoderProcess.Start();
+                if (started)
+                    _encoderProcess.PriorityClass = Process.GetCurrentProcess().PriorityClass;
+            }
+            catch (Exception _ex)
+            {
+                ex = _ex;
+            }
+            if (!started)
+                throw new Exception(m_settings.Path + ": " + (ex == null ? "please check the path" : ex.Message));
+            if (_encoderProcess.StartInfo.RedirectStandardOutput)
+            {
+                Stream outputStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read);
+                outputBuffer = new CyclicBuffer(2 * 1024 * 1024, _encoderProcess.StandardOutput.BaseStream, outputStream);
+            }
+            Stream inputStream = new CyclicBufferOutputStream(_encoderProcess.StandardInput.BaseStream, 128 * 1024);
+            wrt = new WAV.AudioEncoder(new WAV.EncoderSettings(settings.PCM), path, inputStream);
+        }
+
+        public void Close()
+        {
+            if (closed)
+                return;
+            closed = true;
+            wrt.Close();
+            if (useTempFile && (_finalSampleCount < 0 || wrt.Position == _finalSampleCount))
+            {
+                bool started = false;
+                Exception ex = null;
+                try
+                {
+                    started = _encoderProcess.Start();
+                    if (started)
+                        _encoderProcess.PriorityClass = Process.GetCurrentProcess().PriorityClass;
+                }
+                catch (Exception _ex)
+                {
+                    ex = _ex;
+                }
+                if (!started)
+                    throw new Exception(m_settings.Path + ": " + (ex == null ? "please check the path" : ex.Message));
+            }
+            wrt = null;
+            if (!_encoderProcess.HasExited)
+                _encoderProcess.WaitForExit();
+            if (useTempFile)
+                File.Delete(tempFile);
+            if (outputBuffer != null)
+                outputBuffer.Close();
+            if (_encoderProcess.ExitCode != 0)
+                throw new Exception(String.Format("{0} returned error code {1}", m_settings.Path, _encoderProcess.ExitCode));
+        }
+
+        public void Delete()
+        {
+            Close();
+            File.Delete(_path);
+        }
+
+        public void Write(AudioBuffer buff)
+        {
+            try
+            {
+                wrt.Write(buff);
+            }
+            catch (IOException ex)
+            {
+                if (_encoderProcess.HasExited)
+                    throw new IOException(string.Format("{0} has exited prematurely with code {1}", m_settings.Path, _encoderProcess.ExitCode), ex);
+                else
+                    throw ex;
+            }
+            //_sampleLen += sampleCount;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CommandLine/DecoderSettings.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.ComponentModel;
+using Newtonsoft.Json;
+
+namespace CUETools.Codecs.CommandLine
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class DecoderSettings : IAudioDecoderSettings
+    {
+        #region IAudioDecoderSettings implementation
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Name { get; set; }
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Extension { get; set; }
+
+        [Browsable(false)]
+        public Type DecoderType => typeof(AudioDecoder);
+
+        [Browsable(false)]
+        public int Priority => 2;
+
+        public IAudioDecoderSettings Clone()
+        {
+            return MemberwiseClone() as IAudioDecoderSettings;
+        }
+        #endregion
+
+        public DecoderSettings()
+        {
+            this.Init();
+        }
+
+        public DecoderSettings(
+            string name,
+            string extension,
+            string path,
+            string parameters)
+            : base()
+        {
+            Name = name;
+            Extension = extension;
+            Path = path;
+            Parameters = parameters;
+        }
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Path
+        {
+            get;
+            set;
+        }
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Parameters
+        {
+            get;
+            set;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CommandLine/EncoderSettings.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.ComponentModel;
+using Newtonsoft.Json;
+
+namespace CUETools.Codecs.CommandLine
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class EncoderSettings : IAudioEncoderSettings
+    {
+        #region IAudioEncoderSettings implementation
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Name { get; set; }
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Extension { get; set; }
+
+        [Browsable(false)]
+        public Type EncoderType => typeof(AudioEncoder);
+
+        [JsonProperty]
+        public bool Lossless { get; set; }
+
+        [Browsable(false)]
+        public int Priority => 0;
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string SupportedModes { get; set; }
+
+        public string DefaultMode => EncoderMode;
+
+        [Browsable(false)]
+        [DefaultValue("")]
+        [JsonProperty]
+        public string EncoderMode { get; set; }
+
+        [Browsable(false)]
+        public AudioPCMConfig PCM { get; set; }
+
+        [Browsable(false)]
+        public int BlockSize { get; set; }
+
+        [Browsable(false)]
+        [DefaultValue(4096)]
+        public int Padding { get; set; }
+
+        public IAudioEncoderSettings Clone()
+        {
+            return MemberwiseClone() as IAudioEncoderSettings;
+        }
+        #endregion
+
+        public EncoderSettings()
+        {
+            this.Init();
+        }
+
+        public EncoderSettings(
+            string name,
+            string extension,
+            bool lossless,
+            string supportedModes,
+            string defaultMode,
+            string path,
+            string parameters
+            )
+        {
+            this.Init();
+            Name = name;
+            Extension = extension;
+            Lossless = lossless;
+            SupportedModes = supportedModes;
+            Path = path;
+            EncoderMode = defaultMode;
+            Parameters = parameters;
+        }
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Path
+        {
+            get;
+            set;
+        }
+
+        [DefaultValue("")]
+        [JsonProperty]
+        public string Parameters
+        {
+            get;
+            set;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CyclicBuffer.cs

@@ -0,0 +1,231 @@
+using System;
+using System.IO;
+using System.Threading;
+
+namespace CUETools.Codecs
+{
+    public class CyclicBuffer
+    {
+        private byte[] _buffer;
+        private int _size;
+        private int _start = 0; // moved only by Write
+        private int _end = 0; // moved only by Read
+        private bool _eof = false;
+        private Thread _readThread = null, _writeThread = null;
+        private Exception _ex = null;
+
+        private int DataAvailable
+        {
+            get
+            {
+                return _end - _start;
+            }
+        }
+
+        private int FreeSpace
+        {
+            get
+            {
+                return _size - DataAvailable;
+            }
+        }
+
+        public CyclicBuffer(int len)
+        {
+            _size = len;
+            _buffer = new byte[len];
+        }
+
+        public CyclicBuffer(int len, Stream input, Stream output)
+        {
+            _size = len;
+            _buffer = new byte[len];
+            ReadFrom(input);
+            WriteTo(output);
+        }
+
+        public void ReadFrom(Stream input)
+        {
+            _readThread = new Thread(PumpRead);
+            _readThread.Priority = ThreadPriority.Highest;
+            _readThread.IsBackground = true;
+            _readThread.Start(input);
+        }
+
+        public void WriteTo(Stream output)
+        {
+            WriteTo(flushOutputToStream, closeOutputToStream, ThreadPriority.Highest, output);
+        }
+
+        public void WriteTo(FlushOutput flushOutputDelegate, CloseOutput closeOutputDelegate, ThreadPriority priority, object to)
+        {
+            if (flushOutputDelegate != null)
+                flushOutput += flushOutputDelegate;
+            if (closeOutputDelegate != null)
+                closeOutput += closeOutputDelegate;
+            _writeThread = new Thread(FlushThread);
+            _writeThread.Priority = priority;
+            _writeThread.IsBackground = true;
+            _writeThread.Start(to);
+        }
+
+        private void closeOutputToStream(object to)
+        {
+            ((Stream)to).Close();
+        }
+
+        private void flushOutputToStream(byte[] buffer, int pos, int chunk, object to)
+        {
+            ((Stream)to).Write(buffer, pos, chunk);
+        }
+
+        private void PumpRead(object o)
+        {
+            while (Read((Stream)o))
+                ;
+            SetEOF();
+        }
+
+        public void Close()
+        {
+            if (_readThread != null)
+            {
+                _readThread.Join();
+                _readThread = null;
+            }
+            SetEOF();
+            if (_writeThread != null)
+            {
+                _writeThread.Join();
+                _writeThread = null;
+            }
+        }
+
+        public void SetEOF()
+        {
+            lock (this)
+            {
+                _eof = true;
+                Monitor.Pulse(this);
+            }
+        }
+
+        public bool Read(Stream input)
+        {
+            int pos, chunk;
+            lock (this)
+            {
+                while (FreeSpace == 0 && _ex == null)
+                    Monitor.Wait(this);
+                if (_ex != null)
+                    throw _ex;
+                pos = _end % _size;
+                chunk = Math.Min(FreeSpace, _size - pos);
+            }
+            chunk = input.Read(_buffer, pos, chunk);
+            if (chunk == 0)
+                return false;
+            lock (this)
+            {
+                _end += chunk;
+                Monitor.Pulse(this);
+            }
+            return true;
+        }
+
+        public void Read(byte[] array, int offset, int count)
+        {
+            int pos, chunk;
+            while (count > 0)
+            {
+                lock (this)
+                {
+                    while (FreeSpace == 0 && _ex == null)
+                        Monitor.Wait(this);
+                    if (_ex != null)
+                        throw _ex;
+                    pos = _end % _size;
+                    chunk = Math.Min(FreeSpace, _size - pos);
+                    chunk = Math.Min(chunk, count);
+                }
+                Array.Copy(array, offset, _buffer, pos, chunk);
+                lock (this)
+                {
+                    _end += chunk;
+                    Monitor.Pulse(this);
+                }
+                count -= chunk;
+                offset += chunk;
+            }
+        }
+
+        public void Write(byte[] buff, int offs, int count)
+        {
+            while (count > 0)
+            {
+                int pos, chunk;
+                lock (this)
+                {
+                    while (DataAvailable == 0 && !_eof)
+                        Monitor.Wait(this);
+                    if (DataAvailable == 0)
+                        break;
+                    pos = _start % _size;
+                    chunk = Math.Min(DataAvailable, _size - pos);
+                }
+                if (flushOutput != null)
+                    Array.Copy(_buffer, pos, buff, offs, chunk);
+                offs += chunk;
+                lock (this)
+                {
+                    _start += chunk;
+                    Monitor.Pulse(this);
+                }
+            }
+        }
+
+        private void FlushThread(object to)
+        {
+            while (true)
+            {
+                int pos, chunk;
+                lock (this)
+                {
+                    while (DataAvailable == 0 && !_eof)
+                        Monitor.Wait(this);
+                    if (DataAvailable == 0)
+                        break;
+                    pos = _start % _size;
+                    chunk = Math.Min(DataAvailable, _size - pos);
+                }
+                if (flushOutput != null)
+                    try
+                    {
+                        flushOutput(_buffer, pos, chunk, to);
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (this)
+                        {
+                            _ex = ex;
+                            Monitor.Pulse(this);
+                            return;
+                        }
+                    }
+                lock (this)
+                {
+                    _start += chunk;
+                    Monitor.Pulse(this);
+                }
+            }
+            if (closeOutput != null)
+                closeOutput(to);
+        }
+
+        public delegate void FlushOutput(byte[] buffer, int pos, int chunk, object to);
+        public delegate void CloseOutput(object to);
+
+        public event FlushOutput flushOutput;
+        public event CloseOutput closeOutput;
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CyclicBufferInputStream.cs

@@ -0,0 +1,75 @@
+using System;
+using System.IO;
+
+namespace CUETools.Codecs
+{
+    public class CyclicBufferInputStream : Stream
+    {
+        private CyclicBuffer _buffer;
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+
+        public override long Length
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+        public CyclicBufferInputStream(CyclicBuffer buffer)
+        {
+            _buffer = buffer;
+        }
+
+        public override void Close()
+        {
+            _buffer.Close();
+        }
+
+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] array, int offset, int count)
+        {
+            _buffer.Write(array, offset, count);
+            return count;
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] array, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/CyclicBufferOutputStream.cs

@@ -0,0 +1,80 @@
+using System;
+using System.IO;
+
+namespace CUETools.Codecs
+{
+    public class CyclicBufferOutputStream : Stream
+    {
+        private CyclicBuffer _buffer;
+
+        public override bool CanRead
+        {
+            get { return false; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return true; }
+        }
+
+        public override long Length
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+        public CyclicBufferOutputStream(CyclicBuffer buffer)
+        {
+            _buffer = buffer;
+        }
+
+        public CyclicBufferOutputStream(Stream output, int size)
+        {
+            _buffer = new CyclicBuffer(size);
+            _buffer.WriteTo(output);
+        }
+
+        public override void Close()
+        {
+            _buffer.Close();
+        }
+
+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] array, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] array, int offset, int count)
+        {
+            _buffer.Read(array, offset, count);
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/DefaultValueForMode.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CUETools.Codecs
+{
+    /// <summary>
+    /// Default property value for each encoder mode attribute
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
+    public class DefaultValueForModeAttribute : Attribute
+    {
+        /// <summary>
+        /// Resource manager to use;
+        /// </summary>
+        public object[] m_values;
+
+        /// <summary>
+        /// Construct the description attribute
+        /// </summary>
+        /// <param name="text"></param>
+        public DefaultValueForModeAttribute(params object[] values)
+        {
+            this.m_values = values;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/IAudioDest.cs

@@ -0,0 +1,14 @@
+namespace CUETools.Codecs
+{
+	public interface IAudioDest
+	{
+        IAudioEncoderSettings Settings { get; }
+        
+        string Path { get; }
+        long FinalSampleCount { set; }
+
+		void Write(AudioBuffer buffer);
+		void Close();
+		void Delete();
+	}
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/IAudioFilter.cs

@@ -0,0 +1,7 @@
+namespace CUETools.Codecs
+{
+    public interface IAudioFilter
+    {
+        IAudioDest AudioDest { set; }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/IAudioSource.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+
+namespace CUETools.Codecs
+{
+	public interface IAudioSource
+	{
+        IAudioDecoderSettings Settings { get; }
+
+		AudioPCMConfig PCM { get; }
+		string Path { get; }
+
+        TimeSpan Duration { get; }
+        long Length { get; }
+		long Position { get; set; }
+		long Remaining { get; }
+
+		int Read(AudioBuffer buffer, int maxLength);
+		void Close();
+	}
+
+    public interface IAudioTitle
+    {
+        List<TimeSpan> Chapters { get; }
+        AudioPCMConfig PCM { get; }
+        string Codec { get; }
+        string Language { get; }
+        int StreamId { get; }
+        //IAudioSource Open { get; }
+    }
+
+    public interface IAudioTitleSet
+    {
+        List<IAudioTitle> AudioTitles { get; }
+    }
+
+    public static class IAudioTitleExtensions
+    {
+        public static TimeSpan GetDuration(this IAudioTitle title)
+        {
+            var chapters = title.Chapters;
+            return chapters[chapters.Count - 1];
+        }
+
+
+        public static string GetRateString(this IAudioTitle title)
+        {
+            var sr = title.PCM.SampleRate;
+            if (sr % 1000 == 0) return $"{sr / 1000}KHz";
+            if (sr % 100 == 0) return $"{sr / 100}.{(sr / 100) % 10}KHz";
+            return $"{sr}Hz";
+        }
+
+        public static string GetFormatString(this IAudioTitle title)
+        {
+            switch (title.PCM.ChannelCount)
+            {
+                case 1: return "mono";
+                case 2: return "stereo";
+                default: return "multi-channel";
+            }
+        }
+    }
+
+    public class SingleAudioTitle : IAudioTitle
+    {
+        public SingleAudioTitle(IAudioSource source) { this.source = source; }
+        public List<TimeSpan> Chapters => new List<TimeSpan> { TimeSpan.Zero, source.Duration };
+        public AudioPCMConfig PCM => source.PCM;
+        public string Codec => source.Settings.Extension;
+        public string Language => "";
+        public int StreamId => 0;
+        IAudioSource source;
+    }
+
+    public class SingleAudioTitleSet : IAudioTitleSet
+    {
+        public SingleAudioTitleSet(IAudioSource source) { this.source = source; }
+        public List<IAudioTitle> AudioTitles => new List<IAudioTitle> { new SingleAudioTitle(source) };
+        IAudioSource source;
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/IWavePlayer.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace CUETools.Codecs
+{
+    /// <summary>
+    /// Represents the interface to a device that can play a WaveFile
+    /// </summary>
+    public interface IWavePlayer : IDisposable, IAudioDest
+    {
+        /// <summary>
+        /// Begin playback
+        /// </summary>
+        void Play();
+
+        /// <summary>
+        /// Stop playback
+        /// </summary>
+        void Stop();
+
+        /// <summary>
+        /// Pause Playback
+        /// </summary>        
+        void Pause();
+
+        /// <summary>
+        /// Current playback state
+        /// </summary>
+        PlaybackState PlaybackState { get; }
+
+        /// <summary>
+        /// The volume 1.0 is full scale
+        /// </summary>
+        float Volume { get; set; }
+
+        /// <summary>
+        /// Indicates that playback has gone into a stopped state due to 
+        /// reaching the end of the input stream
+        /// </summary>
+        event EventHandler PlaybackStopped;
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/License.txt

@@ -0,0 +1,16 @@
+CUETools.Codecs: common audio encoder/decoder routines
+Copyright (c) 2009-2021 Gregory S. Chudov
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

Aaru.Compression/cuetools.net/CUETools.Codecs/LpcContext.cs

@@ -0,0 +1,393 @@
+using System;
+using System.Collections.Generic;
+
+namespace CUETools.Codecs
+{
+    unsafe public class LpcSubframeInfo
+    {
+        public LpcSubframeInfo()
+        {
+            autocorr_section_values = new double[lpc.MAX_LPC_SECTIONS, lpc.MAX_LPC_ORDER + 1];
+            autocorr_section_orders = new int[lpc.MAX_LPC_SECTIONS];
+        }
+
+        // public LpcContext[] lpc_ctx;
+        public double[,] autocorr_section_values;
+        public int[] autocorr_section_orders;
+        //public int obits;
+
+        public void Reset()
+        {
+            for (int sec = 0; sec < autocorr_section_orders.Length; sec++)
+                autocorr_section_orders[sec] = 0;
+        }
+    }
+
+    unsafe public struct LpcWindowSection
+    {
+        public enum SectionType
+        {
+            Zero,
+            One,
+            OneLarge,
+            Data,
+            OneGlue,
+            Glue
+        };
+        public int m_start;
+        public int m_end;
+        public SectionType m_type;
+        public int m_id;
+        public LpcWindowSection(int end)
+        {
+            m_id = -1;
+            m_start = 0;
+            m_end = end;
+            m_type = SectionType.Data;
+        }
+        public void setData(int start, int end)
+        {
+            m_id = -1;
+            m_start = start;
+            m_end = end;
+            m_type = SectionType.Data;
+        }
+        public void setOne(int start, int end)
+        {
+            m_id = -1;
+            m_start = start;
+            m_end = end;
+            m_type = SectionType.One;
+        }
+        public void setGlue(int start)
+        {
+            m_id = -1;
+            m_start = start;
+            m_end = start;
+            m_type = SectionType.Glue;
+        }
+        public void setZero(int start, int end)
+        {
+            m_id = -1;
+            m_start = start;
+            m_end = end;
+            m_type = SectionType.Zero;
+        }
+
+        unsafe public void compute_autocorr(/*const*/ int* data, float* window, int min_order, int order, int blocksize, double* autoc)
+        {
+            if (m_type == SectionType.OneLarge)
+                lpc.compute_autocorr_windowless_large(data + m_start, m_end - m_start, min_order, order, autoc);
+            else if (m_type == SectionType.One)
+                lpc.compute_autocorr_windowless(data + m_start, m_end - m_start, min_order, order, autoc);
+            else if (m_type == SectionType.Data)
+                lpc.compute_autocorr(data + m_start, window + m_start, m_end - m_start, min_order, order, autoc);
+            else if (m_type == SectionType.Glue)
+                lpc.compute_autocorr_glue(data, window, m_start, m_end, min_order, order, autoc);
+            else if (m_type == SectionType.OneGlue)
+                lpc.compute_autocorr_glue(data + m_start, min_order, order, autoc);
+        }
+
+        unsafe public static void Detect(int _windowcount, float* window_segment, int stride, int sz, int bps, LpcWindowSection* sections)
+        {
+            int section_id = 0;
+            var boundaries = new List<int>();
+            var types = new LpcWindowSection.SectionType[_windowcount, lpc.MAX_LPC_SECTIONS * 2];
+            var alias = new int[_windowcount, lpc.MAX_LPC_SECTIONS * 2];
+            var alias_set = new int[_windowcount, lpc.MAX_LPC_SECTIONS * 2];
+            for (int x = 0; x < sz; x++)
+            {
+                for (int i = 0; i < _windowcount; i++)
+                {
+                    int a = alias[i, boundaries.Count];
+                    float w = window_segment[i * stride + x];
+                    float wa = window_segment[a * stride + x];
+                    if (wa != w)
+                    {
+                        for (int i1 = i; i1 < _windowcount; i1++)
+                            if (alias[i1, boundaries.Count] == a
+                                && w == window_segment[i1 * stride + x])
+                                alias[i1, boundaries.Count] = i;
+                    }
+                    if (boundaries.Count >= lpc.MAX_LPC_SECTIONS * 2) throw new IndexOutOfRangeException();
+                    types[i, boundaries.Count] =
+                        boundaries.Count >= lpc.MAX_LPC_SECTIONS * 2 - 2 ?
+                        LpcWindowSection.SectionType.Data : w == 0.0 ?
+                        LpcWindowSection.SectionType.Zero : w != 1.0 ?
+                        LpcWindowSection.SectionType.Data : bps * 2 + BitReader.log2i(sz) >= 61 ?
+                        LpcWindowSection.SectionType.OneLarge :
+                        LpcWindowSection.SectionType.One ;
+                }
+                bool isBoundary = false;
+                for (int i = 0; i < _windowcount; i++)
+                {
+                    isBoundary |= boundaries.Count == 0 ||
+                        types[i, boundaries.Count - 1] != types[i, boundaries.Count];
+                }
+                if (isBoundary)
+                {
+                    for (int i = 0; i < _windowcount; i++)
+                        for (int i1 = 0; i1 < _windowcount; i1++)
+                            if (i != i1 && alias[i, boundaries.Count] == alias[i1, boundaries.Count])
+                                alias_set[i, boundaries.Count] |= 1 << i1;
+                    boundaries.Add(x);
+                }
+            }
+            boundaries.Add(sz);
+            var secs = new int[_windowcount];
+            // Reconstruct segments list.
+            for (int j = 0; j < boundaries.Count - 1; j++)
+            {
+                for (int i = 0; i < _windowcount; i++)
+                {
+                    LpcWindowSection* window_sections = sections + i * lpc.MAX_LPC_SECTIONS;
+                    // leave room for glue
+                    if (secs[i] >= lpc.MAX_LPC_SECTIONS - 1)
+                    {
+                        throw new IndexOutOfRangeException();
+                        //window_sections[secs[i] - 1].m_type = LpcWindowSection.SectionType.Data;
+                        //window_sections[secs[i] - 1].m_end = boundaries[j + 1];
+                        //continue;
+                    }
+                    window_sections[secs[i]].setData(boundaries[j], boundaries[j + 1]);
+                    window_sections[secs[i]++].m_type = types[i, j];
+                }
+                for (int i = 0; i < _windowcount; i++)
+                {
+                    LpcWindowSection* window_sections = sections + i * lpc.MAX_LPC_SECTIONS;
+                    int sec = secs[i] - 1;
+                    if (sec > 0
+                        && j > 0 && (alias_set[i, j] == alias_set[i, j - 1] || window_sections[sec].m_type == SectionType.Zero)
+                        && window_sections[sec].m_start == boundaries[j]
+                        && window_sections[sec].m_end == boundaries[j + 1]
+                        && window_sections[sec - 1].m_end == boundaries[j]
+                        && window_sections[sec - 1].m_type == window_sections[sec].m_type)
+                    {
+                        window_sections[sec - 1].m_end = window_sections[sec].m_end;
+                        secs[i]--;
+                        continue;
+                    }
+                    if (section_id >= lpc.MAX_LPC_SECTIONS) throw new IndexOutOfRangeException();
+                    if (alias_set[i, j] != 0
+                        && types[i, j] != SectionType.Zero
+                        && section_id < lpc.MAX_LPC_SECTIONS)
+                    {
+                        for (int i1 = i; i1 < _windowcount; i1++)
+                            if (alias[i1, j] == i && secs[i1] > 0)
+                                sections[i1 * lpc.MAX_LPC_SECTIONS + secs[i1] - 1].m_id = section_id;
+                        section_id++;
+                    }
+                    // TODO: section_id for glue? nontrivial, must be sure next sections are the same size
+                    if (sec > 0
+                        && (window_sections[sec].m_type == SectionType.One || window_sections[sec].m_type == SectionType.OneLarge)
+                        && window_sections[sec].m_end - window_sections[sec].m_start >= lpc.MAX_LPC_ORDER
+                        && (window_sections[sec - 1].m_type == SectionType.One || window_sections[sec - 1].m_type == SectionType.OneLarge)
+                        && window_sections[sec - 1].m_end - window_sections[sec - 1].m_start >= lpc.MAX_LPC_ORDER)
+                    {
+                        window_sections[sec + 1] = window_sections[sec];
+                        window_sections[sec].m_end = window_sections[sec].m_start;
+                        window_sections[sec].m_type = SectionType.OneGlue;
+                        window_sections[sec].m_id = -1;
+                        secs[i]++;
+                        continue;
+                    }
+                    if (sec > 0
+                        && window_sections[sec].m_type != SectionType.Zero
+                        && window_sections[sec - 1].m_type != SectionType.Zero)
+                    {
+                        window_sections[sec + 1] = window_sections[sec];
+                        window_sections[sec].m_end = window_sections[sec].m_start;
+                        window_sections[sec].m_type = SectionType.Glue;
+                        window_sections[sec].m_id = -1;
+                        secs[i]++;
+                        continue;
+                    }
+                }
+            }
+            for (int i = 0; i < _windowcount; i++)
+            {
+                for (int s = 0; s < secs[i]; s++)
+                {
+                    LpcWindowSection* window_sections = sections + i * lpc.MAX_LPC_SECTIONS;
+                    if (window_sections[s].m_type == SectionType.Glue
+                        || window_sections[s].m_type == SectionType.OneGlue)
+                    {
+                        window_sections[s].m_end = window_sections[s + 1].m_end;
+                    }
+                }
+                while (secs[i] < lpc.MAX_LPC_SECTIONS)
+                {
+                    LpcWindowSection* window_sections = sections + i * lpc.MAX_LPC_SECTIONS;
+                    window_sections[secs[i]++].setZero(sz, sz);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Context for LPC coefficients calculation and order estimation
+    /// </summary>
+    unsafe public class LpcContext
+    {
+        public LpcContext()
+        {
+            coefs = new int[lpc.MAX_LPC_ORDER];
+            reflection_coeffs = new double[lpc.MAX_LPC_ORDER];
+            prediction_error = new double[lpc.MAX_LPC_ORDER];
+            autocorr_values = new double[lpc.MAX_LPC_ORDER + 1];
+            best_orders = new int[lpc.MAX_LPC_ORDER];
+            done_lpcs = new uint[lpc.MAX_LPC_PRECISIONS];
+        }
+
+        /// <summary>
+        /// Reset to initial (blank) state
+        /// </summary>
+        public void Reset()
+        {
+            autocorr_order = 0;
+            for (int iPrecision = 0; iPrecision < lpc.MAX_LPC_PRECISIONS; iPrecision++)
+                done_lpcs[iPrecision] = 0;
+        }
+
+        /// <summary>
+        /// Calculate autocorrelation data and reflection coefficients.
+        /// Can be used to incrementaly compute coefficients for higher orders,
+        /// because it caches them.
+        /// </summary>
+        /// <param name="order">Maximum order</param>
+        /// <param name="samples">Samples pointer</param>
+        /// <param name="blocksize">Block size</param>
+        /// <param name="window">Window function</param>
+        public void GetReflection(LpcSubframeInfo subframe, int order, int blocksize, int* samples, float* window, LpcWindowSection* sections)
+        {
+            if (autocorr_order > order)
+                return;
+            fixed (double* reff = reflection_coeffs, autoc = autocorr_values, err = prediction_error)
+            {
+                for (int i = autocorr_order; i <= order; i++) autoc[i] = 0;
+                for (int section = 0; section < lpc.MAX_LPC_SECTIONS; section++)
+                {
+                    if (sections[section].m_type == LpcWindowSection.SectionType.Zero)
+                    {
+                        continue;
+                    }
+                    if (sections[section].m_id >= 0)
+                    {
+                        if (subframe.autocorr_section_orders[sections[section].m_id] <= order)
+                        {
+                            fixed (double* autocsec = &subframe.autocorr_section_values[sections[section].m_id, 0])
+                            {
+                                int min_order = subframe.autocorr_section_orders[sections[section].m_id];
+                                for (int i = min_order; i <= order; i++) autocsec[i] = 0;
+                                sections[section].compute_autocorr(samples, window, min_order, order, blocksize, autocsec);
+                            }
+                            subframe.autocorr_section_orders[sections[section].m_id] = order + 1;
+                        }
+                        for (int i = autocorr_order; i <= order; i++)
+                            autoc[i] += subframe.autocorr_section_values[sections[section].m_id, i];
+                    }
+                    else
+                    {
+                        sections[section].compute_autocorr(samples, window, autocorr_order, order, blocksize, autoc);
+                    }
+                }
+                lpc.compute_schur_reflection(autoc, (uint)order, reff, err);
+                autocorr_order = order + 1;
+            }
+        }
+#if XXX
+        public void GetReflection1(int order, int* samples, int blocksize, float* window)
+        {
+            if (autocorr_order > order)
+                return;
+            fixed (double* reff = reflection_coeffs, autoc = autocorr_values, err = prediction_error)
+            {
+                lpc.compute_autocorr(samples, blocksize, 0, order + 1, autoc, window);
+                for (int i = 1; i <= order; i++)
+                    autoc[i] = autoc[i + 1];
+                lpc.compute_schur_reflection(autoc, (uint)order, reff, err);
+                autocorr_order = order + 1;
+            }
+        }
+
+        public void ComputeReflection(int order, float* autocorr)
+        {
+            fixed (double* reff = reflection_coeffs, autoc = autocorr_values, err = prediction_error)
+            {
+                for (int i = 0; i <= order; i++)
+                    autoc[i] = autocorr[i];
+                lpc.compute_schur_reflection(autoc, (uint)order, reff, err);
+                autocorr_order = order + 1;
+            }
+        }
+
+        public void ComputeReflection(int order, double* autocorr)
+        {
+            fixed (double* reff = reflection_coeffs, autoc = autocorr_values, err = prediction_error)
+            {
+                for (int i = 0; i <= order; i++)
+                    autoc[i] = autocorr[i];
+                lpc.compute_schur_reflection(autoc, (uint)order, reff, err);
+                autocorr_order = order + 1;
+            }
+        }
+#endif
+        public double Akaike(int blocksize, int order, double alpha, double beta)
+        {
+            //return (blocksize - order) * (Math.Log(prediction_error[order - 1]) - Math.Log(1.0)) + Math.Log(blocksize) * order * (alpha + beta * order);
+            //return blocksize * (Math.Log(prediction_error[order - 1]) - Math.Log(autocorr_values[0]) / 2) + Math.Log(blocksize) * order * (alpha + beta * order);
+            return blocksize * (Math.Log(prediction_error[order - 1])) + Math.Log(blocksize) * order * (alpha + beta * order);
+        }
+
+        /// <summary>
+        /// Sorts orders based on Akaike's criteria
+        /// </summary>
+        /// <param name="blocksize">Frame size</param>
+        public void SortOrdersAkaike(int blocksize, int count, int min_order, int max_order, double alpha, double beta)
+        {
+            for (int i = min_order; i <= max_order; i++)
+                best_orders[i - min_order] = i;
+            int lim = max_order - min_order + 1;
+            for (int i = 0; i < lim && i < count; i++)
+            {
+                for (int j = i + 1; j < lim; j++)
+                {
+                    if (Akaike(blocksize, best_orders[j], alpha, beta) < Akaike(blocksize, best_orders[i], alpha, beta))
+                    {
+                        int tmp = best_orders[j];
+                        best_orders[j] = best_orders[i];
+                        best_orders[i] = tmp;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Produces LPC coefficients from autocorrelation data.
+        /// </summary>
+        /// <param name="lpcs">LPC coefficients buffer (for all orders)</param>
+        public void ComputeLPC(float* lpcs)
+        {
+            fixed (double* reff = reflection_coeffs)
+                lpc.compute_lpc_coefs((uint)autocorr_order - 1, reff, lpcs);
+        }
+
+        public double[] autocorr_values;
+        double[] reflection_coeffs;
+        public double[] prediction_error;
+        public int[] best_orders;
+        public int[] coefs;
+        int autocorr_order;
+        public int shift;
+
+        public double[] Reflection
+        {
+            get
+            {
+                return reflection_coeffs;
+            }
+        }
+
+        public uint[] done_lpcs;
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/NULL/AudioDecoder.cs

@@ -0,0 +1,65 @@
+using System;
+
+namespace CUETools.Codecs.NULL
+{
+    public class AudioDecoder : IAudioSource
+    {
+        private long _sampleOffset, _sampleCount;
+        private AudioPCMConfig pcm;
+        private int _sampleVal;
+
+        public IAudioDecoderSettings Settings => null;
+
+        public TimeSpan Duration => TimeSpan.FromSeconds((double)Length / PCM.SampleRate);
+
+        public long Length
+        {
+            get { return _sampleCount; }
+        }
+
+        public long Remaining
+        {
+            get { return _sampleCount - _sampleOffset; }
+        }
+
+        public long Position
+        {
+            get { return _sampleOffset; }
+            set { _sampleOffset = value; }
+        }
+
+        public AudioPCMConfig PCM { get { return pcm; } }
+
+        public string Path { get { return null; } }
+
+        public AudioDecoder(AudioPCMConfig pcm, long sampleCount, int sampleVal)
+        {
+            this._sampleVal = sampleVal;
+            this._sampleOffset = 0;
+            this._sampleCount = sampleCount;
+            this.pcm = pcm;
+        }
+
+        public AudioDecoder(long sampleCount)
+            : this(AudioPCMConfig.RedBook, sampleCount, 0)
+        {
+        }
+
+        public int Read(AudioBuffer buff, int maxLength)
+        {
+            buff.Prepare(this, maxLength);
+
+            int[,] samples = buff.Samples;
+            for (int i = 0; i < buff.Length; i++)
+                for (int j = 0; j < PCM.ChannelCount; j++)
+                    samples[i, j] = _sampleVal;
+
+            _sampleOffset += buff.Length;
+            return buff.Length;
+        }
+
+        public void Close()
+        {
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/NULL/AudioEncoder.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace CUETools.Codecs.NULL
+{
+    public class AudioEncoder : IAudioDest
+    {
+        IAudioEncoderSettings m_settings;
+
+        public AudioEncoder(string path, IAudioEncoderSettings settings)
+        {
+            m_settings = settings;
+        }
+
+        public void Close()
+        {
+        }
+
+        public void Delete()
+        {
+        }
+
+        public long FinalSampleCount
+        {
+            set { }
+        }
+
+        public IAudioEncoderSettings Settings => m_settings;
+
+        public void Write(AudioBuffer buff)
+        {
+        }
+
+        public string Path => null;
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/NullStream.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+
+namespace CUETools.Codecs
+{
+    public class NullStream : Stream
+    {
+        public override bool CanRead
+        {
+            get { return false; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return true; }
+        }
+
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+        public NullStream()
+        {
+        }
+
+        public override void Close()
+        {
+        }
+
+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] array, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] array, int offset, int count)
+        {
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/PlaybackState.cs

@@ -0,0 +1,21 @@
+namespace CUETools.Codecs
+{
+    /// <summary>
+    /// Playback State
+    /// </summary>
+    public enum PlaybackState
+    {
+        /// <summary>
+        /// Stopped
+        /// </summary>
+        Stopped,
+        /// <summary>
+        /// Playing
+        /// </summary>
+        Playing,
+        /// <summary>
+        /// Paused
+        /// </summary>
+        Paused
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/SRDescriptionAttribute.cs

@@ -0,0 +1,56 @@
+using System;
+using System.ComponentModel;
+
+namespace CUETools.Codecs
+{
+	/// <summary>
+	/// Localized description attribute
+	/// </summary>
+	[AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)]
+	public class SRDescriptionAttribute : DescriptionAttribute
+    {
+        /// <summary>
+        /// Store a flag indicating whether this has been localized
+        /// </summary>
+        private bool localized;
+
+        /// <summary>
+        /// Resource manager to use;
+        /// </summary>
+        private Type SR;
+
+		/// <summary>
+		/// Construct the description attribute
+		/// </summary>
+		/// <param name="text"></param>
+		public SRDescriptionAttribute(Type SR, string text)
+			: base(text)
+		{
+			this.localized = false;
+			this.SR = SR;
+		}
+
+		/// <summary>
+		/// Override the return of the description text to localize the text
+		/// </summary>
+		public override string Description
+		{
+			get
+			{
+				if (!localized)
+				{
+					localized = true;
+					this.DescriptionValue = SR.InvokeMember(
+						 this.DescriptionValue,
+						 System.Reflection.BindingFlags.GetProperty | System.Reflection.BindingFlags.Static |
+						 System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic,
+						 null,
+						 null,
+						 new object[] { }) as string;
+				}
+
+				return base.Description;
+			}
+		}
+	}
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/ViewModel/AudioDecoderSettingsViewModel.cs

@@ -0,0 +1,97 @@
+using Newtonsoft.Json;
+using System;
+using System.ComponentModel;
+
+namespace CUETools.Codecs
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class AudioDecoderSettingsViewModel : INotifyPropertyChanged
+    {
+        [JsonProperty]
+        public IAudioDecoderSettings Settings = null;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [JsonConstructor]
+        private AudioDecoderSettingsViewModel()
+        {
+        }
+
+        public AudioDecoderSettingsViewModel(IAudioDecoderSettings settings)
+        {
+            this.Settings = settings;
+        }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        public string FullName => Name + " [" + Extension + "]";
+
+        public string Path
+        {
+            get
+            {
+                if (Settings is CommandLine.DecoderSettings)
+                    return (Settings as CommandLine.DecoderSettings).Path;
+                return "";
+            }
+            set
+            {
+                if (Settings is CommandLine.DecoderSettings)
+                    (Settings as CommandLine.DecoderSettings).Path = value;
+                else throw new InvalidOperationException();
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Path"));
+            }
+        }
+        public string Parameters
+        {
+            get
+            {
+                if (Settings is CommandLine.DecoderSettings)
+                    return (Settings as CommandLine.DecoderSettings).Parameters;
+                return "";
+            }
+            set
+            {
+                if (Settings is CommandLine.DecoderSettings)
+                    (Settings as CommandLine.DecoderSettings).Parameters = value;
+                else throw new InvalidOperationException();
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Parameters"));
+            }
+        }
+
+        public string Name
+        {
+            get => Settings.Name;
+            set
+            {
+                if (Settings is CommandLine.DecoderSettings)
+                    (Settings as CommandLine.DecoderSettings).Name = value;
+                else throw new InvalidOperationException();
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Name"));
+            }
+        }
+
+        public string Extension
+        {
+            get => Settings.Extension;
+            set
+            {
+                if (Settings is CommandLine.DecoderSettings)
+                    (Settings as CommandLine.DecoderSettings).Extension = value;
+                else throw new InvalidOperationException();
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Extension"));
+            }
+        }
+
+        public string DotExtension => "." + Extension;
+
+        public bool CanBeDeleted => Settings is CommandLine.DecoderSettings;
+
+        public bool IsValid =>
+               (Settings != null)
+            && (Settings is CommandLine.DecoderSettings ? (Settings as CommandLine.DecoderSettings).Path != "" : true);
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/ViewModel/AudioEncoderSettingsViewModel.cs

@@ -0,0 +1,137 @@
+using Newtonsoft.Json;
+using System;
+using System.ComponentModel;
+
+namespace CUETools.Codecs
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class AudioEncoderSettingsViewModel : INotifyPropertyChanged
+    {
+        [JsonProperty]
+        public IAudioEncoderSettings Settings = null;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [JsonConstructor]
+        private AudioEncoderSettingsViewModel()
+        {
+        }
+
+        public AudioEncoderSettingsViewModel(IAudioEncoderSettings settings)
+        {
+            this.Settings = settings;
+        }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        public string FullName => Name + " [" + Extension + "]";
+
+        public string Path
+        {
+            get
+            {
+                if (Settings is CommandLine.EncoderSettings)
+                    return (Settings as CommandLine.EncoderSettings).Path;
+                return "";
+            }
+            set
+            {
+                var settings = this.Settings as CommandLine.EncoderSettings;
+                if (settings == null) throw new InvalidOperationException();
+                settings.Path = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Path"));
+            }
+        }
+
+        public string Parameters
+        {
+            get
+            {
+                if (Settings is CommandLine.EncoderSettings)
+                    return (Settings as CommandLine.EncoderSettings).Parameters;
+                return "";
+            }
+            set
+            {
+                var settings = this.Settings as CommandLine.EncoderSettings;
+                if (settings == null) throw new InvalidOperationException();
+                settings.Parameters = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Parameters"));
+            }
+        }
+
+        public bool Lossless
+        {
+            get => Settings.Lossless;
+            set
+            {
+                var settings = this.Settings as CommandLine.EncoderSettings;
+                if (settings == null) throw new InvalidOperationException();
+                settings.Lossless = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Lossless"));
+            }
+        }
+
+        
+        public string Name
+        {
+            get => Settings.Name;
+            set
+            {
+                var settings = this.Settings as CommandLine.EncoderSettings;
+                if (settings == null) throw new InvalidOperationException();
+                settings.Name = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Name"));
+            }
+        }
+
+        public string Extension
+        {
+            get => Settings.Extension;
+            set
+            {
+                var settings = this.Settings as CommandLine.EncoderSettings;
+                if (settings == null) throw new InvalidOperationException();
+                settings.Extension = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Extension"));
+            }
+        }
+
+        public string DotExtension => "." + Extension;
+
+        public string SupportedModes
+        {
+            get => Settings.SupportedModes;
+            set
+            {
+                var settings = this.Settings as CommandLine.EncoderSettings;
+                if (settings == null) throw new InvalidOperationException();
+                settings.SupportedModes = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SupportedModes"));
+            }
+        }
+
+        public int EncoderModeIndex
+        {
+            get
+            {
+                string[] modes = this.SupportedModes.Split(' ');
+                if (modes == null || modes.Length < 2)
+                    return -1;
+                for (int i = 0; i < modes.Length; i++)
+                    if (modes[i] == this.Settings.EncoderMode)
+                        return i;
+                return -1;
+            }
+        }
+
+        public bool CanBeDeleted => Settings is CommandLine.EncoderSettings;
+
+        public bool IsValid =>
+               (Settings != null)
+            && (Settings is CommandLine.EncoderSettings ? (Settings as CommandLine.EncoderSettings).Path != "" : true);
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/ViewModel/DecoderListViewModel.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace CUETools.Codecs
+{
+    public class DecoderListViewModel : BindingList<AudioDecoderSettingsViewModel>
+    {
+        private List<IAudioDecoderSettings> model;
+
+        public DecoderListViewModel(List<IAudioDecoderSettings> model)
+            : base()
+        {
+            this.model = model;
+            model.ForEach(item => Add(new AudioDecoderSettingsViewModel(item)));
+            AddingNew += OnAddingNew;
+        }
+
+        private void OnAddingNew(object sender, AddingNewEventArgs e)
+        {
+            var item = new CommandLine.DecoderSettings("new", "wav", "", "");
+            model.Add(item);
+            e.NewObject = new AudioDecoderSettingsViewModel(item);
+        }
+
+        public bool TryGetValue(string extension, string name, out AudioDecoderSettingsViewModel result)
+        {
+            foreach (AudioDecoderSettingsViewModel udc in this)
+            {
+                if (udc.Settings.Extension == extension && udc.Settings.Name == name)
+                {
+                    result = udc;
+                    return true;
+                }
+            }
+            result = null;
+            return false;
+        }
+
+        public AudioDecoderSettingsViewModel GetDefault(string extension)
+        {
+            AudioDecoderSettingsViewModel result = null;
+            foreach (AudioDecoderSettingsViewModel udc in this)
+            {
+                if (udc.Settings.Extension == extension && (result == null || result.Settings.Priority < udc.Settings.Priority))
+                {
+                    result = udc;
+                }
+            }
+            return result;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/ViewModel/EncoderListViewModel.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace CUETools.Codecs
+{
+    public class EncoderListViewModel : BindingList<AudioEncoderSettingsViewModel>
+    {
+        private List<IAudioEncoderSettings> model;
+
+        public EncoderListViewModel(List<IAudioEncoderSettings> model)
+            : base()
+        {
+            this.model = model;
+            model.ForEach(item => Add(new AudioEncoderSettingsViewModel(item)));
+            AddingNew += OnAddingNew;
+        }
+
+        private void OnAddingNew(object sender, AddingNewEventArgs e)
+        {
+            var item = new CommandLine.EncoderSettings("new", "wav", true, "", "", "", "");
+            model.Add(item);
+            e.NewObject = new AudioEncoderSettingsViewModel(item);
+        }
+
+        public bool TryGetValue(string extension, bool lossless, string name, out AudioEncoderSettingsViewModel result)
+        {
+            //result = this.Where(udc => udc.settings.Extension == extension && udc.settings.Lossless == lossless && udc.settings.Name == name).First();
+            foreach (AudioEncoderSettingsViewModel udc in this)
+            {
+                if (udc.Settings.Extension == extension && udc.Settings.Lossless == lossless && udc.Settings.Name == name)
+                {
+                    result = udc;
+                    return true;
+                }
+            }
+            result = null;
+            return false;
+        }
+
+        public AudioEncoderSettingsViewModel GetDefault(string extension, bool lossless)
+        {
+            AudioEncoderSettingsViewModel result = null;
+            foreach (AudioEncoderSettingsViewModel udc in this)
+            {
+                if (udc.Settings.Extension == extension && udc.Settings.Lossless == lossless && (result == null || result.Settings.Priority < udc.Settings.Priority))
+                {
+                    result = udc;
+                }
+            }
+            return result;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/WAV/AudioDecoder.cs

@@ -0,0 +1,271 @@
+using System;
+using System.IO;
+
+namespace CUETools.Codecs.WAV
+{
+    public class AudioDecoder : IAudioSource
+    {
+        Stream _IO;
+        BinaryReader _br;
+        long _dataOffset, _samplePos, _sampleLen;
+        private AudioPCMConfig pcm;
+        long _dataLen;
+        bool _largeFile;
+        string _path;
+
+        private DecoderSettings m_settings;
+        public IAudioDecoderSettings Settings => m_settings;
+
+        public long Position
+        {
+            get
+            {
+                return _samplePos;
+            }
+            set
+            {
+                long seekPos;
+
+                if (_samplePos == value)
+                {
+                    return;
+                }
+
+                var oldSamplePos = _samplePos;
+                if (_sampleLen >= 0 && value > _sampleLen)
+                    _samplePos = _sampleLen;
+                else
+                    _samplePos = value;
+
+                if (_IO.CanSeek || _samplePos < oldSamplePos)
+                {
+                    seekPos = _dataOffset + _samplePos * PCM.BlockAlign;
+                    _IO.Seek(seekPos, SeekOrigin.Begin);
+                }
+                else
+                {
+                    int offs = (int)(_samplePos - oldSamplePos) * PCM.BlockAlign;
+                    while (offs > 0)
+                    {
+                        int chunk = Math.Min(offs, 16536);
+                        _br.ReadBytes(chunk);
+                        offs -= chunk;
+                    }
+                }
+            }
+        }
+
+        public TimeSpan Duration => Length < 0 ? TimeSpan.Zero : TimeSpan.FromSeconds((double)Length / PCM.SampleRate);
+
+        public long Length
+        {
+            get
+            {
+                return _sampleLen;
+            }
+        }
+
+        public long Remaining
+        {
+            get
+            {
+                return _sampleLen - _samplePos;
+            }
+        }
+
+        public AudioPCMConfig PCM { get { return pcm; } }
+
+        public string Path { get { return _path; } }
+
+        public AudioDecoder(DecoderSettings settings, string path, Stream IO = null)
+        {
+            m_settings = settings;
+            _path = path;
+            _IO = IO ?? new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 0x10000, FileOptions.SequentialScan);
+            _br = new BinaryReader(_IO);
+
+            ParseHeaders();
+
+            if (_dataLen < 0 || m_settings.IgnoreChunkSizes)
+                _sampleLen = -1;
+            else
+                _sampleLen = _dataLen / pcm.BlockAlign;
+        }
+
+        public AudioDecoder(DecoderSettings settings, string path, Stream IO, AudioPCMConfig _pcm)
+        {
+            m_settings = settings;
+            _path = path;
+            _IO = IO != null ? IO : new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 0x10000, FileOptions.SequentialScan);
+            _br = new BinaryReader(_IO);
+
+            _largeFile = false;
+            _dataOffset = 0;
+            _samplePos = 0;
+            pcm = _pcm;
+            _dataLen = _IO.CanSeek ? _IO.Length : -1;
+            if (_dataLen < 0)
+                _sampleLen = -1;
+            else
+            {
+                _sampleLen = _dataLen / pcm.BlockAlign;
+                if ((_dataLen % pcm.BlockAlign) != 0)
+                    throw new Exception("odd file size");
+            }
+        }
+
+        public static AudioBuffer ReadAllSamples(DecoderSettings settings, string path, Stream IO = null)
+        {
+            AudioDecoder reader = new AudioDecoder(settings, path, IO);
+            AudioBuffer buff = new AudioBuffer(reader, (int)reader.Length);
+            reader.Read(buff, -1);
+            if (reader.Remaining != 0)
+                throw new Exception("couldn't read the whole file");
+            reader.Close();
+            return buff;
+        }
+
+        public void Close()
+        {
+            if (_br != null)
+            {
+                _br.Close();
+                _br = null;
+            }
+            _IO = null;
+        }
+
+        private void ParseHeaders()
+        {
+            const long maxFileSize = 0x7FFFFFFEL;
+            const uint fccRIFF = 0x46464952;
+            const uint fccWAVE = 0x45564157;
+            const uint fccFormat = 0x20746D66;
+            const uint fccData = 0x61746164;
+
+            uint lenRIFF;
+            bool foundFormat, foundData;
+
+            if (_br.ReadUInt32() != fccRIFF)
+            {
+                throw new Exception("Not a valid RIFF file.");
+            }
+
+            lenRIFF = _br.ReadUInt32();
+
+            if (_br.ReadUInt32() != fccWAVE)
+            {
+                throw new Exception("Not a valid WAVE file.");
+            }
+
+            _largeFile = false;
+            foundFormat = false;
+            foundData = false;
+            long pos = 12;
+            do
+            {
+                uint ckID, ckSize, ckSizePadded;
+                long ckEnd;
+
+                ckID = _br.ReadUInt32();
+                ckSize = _br.ReadUInt32();
+                ckSizePadded = (ckSize + 1U) & ~1U;
+                pos += 8;
+                ckEnd = pos + (long)ckSizePadded;
+
+                if (ckID == fccFormat)
+                {
+                    foundFormat = true;
+
+                    uint fmtTag = _br.ReadUInt16();
+                    int _channelCount = _br.ReadInt16();
+                    int _sampleRate = _br.ReadInt32();
+                    _br.ReadInt32(); // bytes per second
+                    int _blockAlign = _br.ReadInt16();
+                    int _bitsPerSample = _br.ReadInt16();
+                    int _channelMask = 0;
+                    pos += 16;
+
+                    if (fmtTag == 0xFFFEU && ckSize >= 34) // WAVE_FORMAT_EXTENSIBLE 
+                    {
+                        _br.ReadInt16(); // CbSize
+                        _br.ReadInt16(); // ValidBitsPerSample
+                        _channelMask = _br.ReadInt32();
+                        fmtTag = _br.ReadUInt16();
+                        pos += 10;
+                    }
+
+                    if (fmtTag != 1) // WAVE_FORMAT_PCM
+                        throw new Exception("WAVE format tag not WAVE_FORMAT_PCM.");
+
+                    pcm = new AudioPCMConfig(_bitsPerSample, _channelCount, _sampleRate, (AudioPCMConfig.SpeakerConfig)_channelMask);
+                    if (pcm.BlockAlign != _blockAlign)
+                        throw new Exception("WAVE has strange BlockAlign");
+                }
+                else if (ckID == fccData)
+                {
+                    foundData = true;
+
+                    _dataOffset = pos;
+                    if (!_IO.CanSeek || _IO.Length <= maxFileSize)
+                    {
+                        if (ckSize == 0 || ckSize >= 0x7fffffff)
+                            _dataLen = -1;
+                        else
+                            _dataLen = (long)ckSize;
+                    }
+                    else
+                    {
+                        _largeFile = true;
+                        _dataLen = _IO.Length - pos;
+                    }
+                }
+
+                if ((foundFormat & foundData) || _largeFile)
+                    break;
+                if (_IO.CanSeek)
+                    _IO.Seek(ckEnd, SeekOrigin.Begin);
+                else
+                    _br.ReadBytes((int)(ckEnd - pos));
+                pos = ckEnd;
+            } while (true);
+
+            if ((foundFormat & foundData) == false || pcm == null)
+                throw new Exception("Format or data chunk not found.");
+            if (pcm.ChannelCount <= 0)
+                throw new Exception("Channel count is invalid.");
+            if (pcm.SampleRate <= 0)
+                throw new Exception("Sample rate is invalid.");
+            if ((pcm.BitsPerSample <= 0) || (pcm.BitsPerSample > 32))
+                throw new Exception("Bits per sample is invalid.");
+            if (pos != _dataOffset)
+                Position = 0;
+        }
+
+        public int Read(AudioBuffer buff, int maxLength)
+        {
+            buff.Prepare(this, maxLength);
+
+            byte[] bytes = buff.Bytes;
+            int byteCount = (int)buff.ByteLength;
+            int pos = 0;
+
+            while (pos < byteCount)
+            {
+                int len = _IO.Read(bytes, pos, byteCount - pos);
+                if (len <= 0)
+                {
+                    if ((pos % PCM.BlockAlign) != 0 || _sampleLen >= 0)
+                        throw new Exception("Incomplete file read.");
+                    buff.Length = pos / PCM.BlockAlign;
+                    _samplePos += buff.Length;
+                    _sampleLen = _samplePos;
+                    return buff.Length;
+                }
+                pos += len;
+            }
+            _samplePos += buff.Length;
+            return buff.Length;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/WAV/AudioEncoder.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace CUETools.Codecs.WAV
+{
+    public class AudioEncoder : IAudioDest
+    {
+        private Stream _IO;
+        private BinaryWriter _bw;
+        private long _sampleLen;
+        private string _path;
+        private long hdrLen = 0;
+        private bool _headersWritten = false;
+        private long _finalSampleCount = -1;
+        private List<byte[]> _chunks = null;
+        private List<uint> _chunkFCCs = null;
+
+        public long Position
+        {
+            get
+            {
+                return _sampleLen;
+            }
+        }
+
+        public long FinalSampleCount
+        {
+            set { _finalSampleCount = value; }
+        }
+
+        private EncoderSettings m_settings;
+        public IAudioEncoderSettings Settings => m_settings;
+
+        public string Path { get { return _path; } }
+
+        public AudioEncoder(EncoderSettings settings, string path, Stream IO = null)
+        {
+            m_settings = settings;
+            _path = path;
+            _IO = IO ?? new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read);
+            _bw = new BinaryWriter(_IO);
+        }
+
+        public void WriteChunk(uint fcc, byte[] data)
+        {
+            if (_sampleLen > 0)
+                throw new Exception("data already written, no chunks allowed");
+            if (_chunks == null)
+            {
+                _chunks = new List<byte[]>();
+                _chunkFCCs = new List<uint>();
+            }
+            _chunkFCCs.Add(fcc);
+            _chunks.Add(data);
+            hdrLen += 8 + data.Length + (data.Length & 1);
+        }
+
+        private void WriteHeaders()
+        {
+            const uint fccRIFF = 0x46464952;
+            const uint fccWAVE = 0x45564157;
+            const uint fccFormat = 0x20746D66;
+            const uint fccData = 0x61746164;
+
+            bool wavex = (Settings.PCM.BitsPerSample != 16 && Settings.PCM.BitsPerSample != 24) || Settings.PCM.ChannelMask != AudioPCMConfig.GetDefaultChannelMask(Settings.PCM.ChannelCount);
+
+            hdrLen += 36 + (wavex ? 24 : 0) + 8;
+
+            uint dataLen = (uint)(_finalSampleCount * Settings.PCM.BlockAlign);
+            uint dataLenPadded = dataLen + (dataLen & 1);
+
+            _bw.Write(fccRIFF);
+            if (_finalSampleCount <= 0)
+                _bw.Write((uint)0xffffffff);
+            else
+                _bw.Write((uint)(dataLenPadded + hdrLen - 8));
+            _bw.Write(fccWAVE);
+            _bw.Write(fccFormat);
+            if (wavex)
+            {
+                _bw.Write((uint)40);
+                _bw.Write((ushort)0xfffe); // WAVEX follows
+            }
+            else
+            {
+                _bw.Write((uint)16);
+                _bw.Write((ushort)1); // PCM
+            }
+            _bw.Write((ushort)Settings.PCM.ChannelCount);
+            _bw.Write((uint)Settings.PCM.SampleRate);
+            _bw.Write((uint)(Settings.PCM.SampleRate * Settings.PCM.BlockAlign));
+            _bw.Write((ushort)Settings.PCM.BlockAlign);
+            _bw.Write((ushort)((Settings.PCM.BitsPerSample + 7) / 8 * 8));
+            if (wavex)
+            {
+                _bw.Write((ushort)22); // length of WAVEX structure
+                _bw.Write((ushort)Settings.PCM.BitsPerSample);
+                _bw.Write((uint)Settings.PCM.ChannelMask);
+                _bw.Write((ushort)1); // PCM Guid
+                _bw.Write((ushort)0);
+                _bw.Write((ushort)0);
+                _bw.Write((ushort)0x10);
+                _bw.Write((byte)0x80);
+                _bw.Write((byte)0x00);
+                _bw.Write((byte)0x00);
+                _bw.Write((byte)0xaa);
+                _bw.Write((byte)0x00);
+                _bw.Write((byte)0x38);
+                _bw.Write((byte)0x9b);
+                _bw.Write((byte)0x71);
+            }
+            if (_chunks != null)
+                for (int i = 0; i < _chunks.Count; i++)
+                {
+                    _bw.Write(_chunkFCCs[i]);
+                    _bw.Write((uint)_chunks[i].Length);
+                    _bw.Write(_chunks[i]);
+                    if ((_chunks[i].Length & 1) != 0)
+                        _bw.Write((byte)0);
+                }
+
+            _bw.Write(fccData);
+            if (_finalSampleCount <= 0)
+                _bw.Write((uint)0xffffffff);
+            else
+                _bw.Write(dataLen);
+
+            _headersWritten = true;
+        }
+
+        public void Close()
+        {
+            if (_finalSampleCount <= 0 && _IO.CanSeek)
+            {
+                long dataLen = _sampleLen * Settings.PCM.BlockAlign;
+                long dataLenPadded = dataLen + (dataLen & 1);
+                if (dataLenPadded + hdrLen - 8 < 0xffffffff)
+                {
+                    if ((dataLen & 1) == 1)
+                        _bw.Write((byte)0);
+
+                    _bw.Seek(4, SeekOrigin.Begin);
+                    _bw.Write((uint)(dataLenPadded + hdrLen - 8));
+
+                    _bw.Seek((int)hdrLen - 4, SeekOrigin.Begin);
+                    _bw.Write((uint)dataLen);
+                }
+            }
+
+            _bw.Close();
+
+            _bw = null;
+            _IO = null;
+
+            if (_finalSampleCount > 0 && _sampleLen != _finalSampleCount)
+                throw new Exception("Samples written differs from the expected sample count.");
+        }
+
+        public void Delete()
+        {
+            _bw.Close();
+            _bw = null;
+            _IO = null;
+            if (_path != "")
+                File.Delete(_path);
+        }
+
+        public void Write(AudioBuffer buff)
+        {
+            if (buff.Length == 0)
+                return;
+            buff.Prepare(this);
+            if (!_headersWritten)
+                WriteHeaders();
+            _IO.Write(buff.Bytes, 0, buff.ByteLength);
+            _sampleLen += buff.Length;
+        }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/WAV/DecoderSettings.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+using System;
+using System.ComponentModel;
+
+namespace CUETools.Codecs.WAV
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class DecoderSettings : IAudioDecoderSettings
+    {
+        #region IAudioDecoderSettings implementation
+        [Browsable(false)]
+        public string Extension => "wav";
+
+        [Browsable(false)]
+        public string Name => "cuetools";
+
+        [Browsable(false)]
+        public Type DecoderType => typeof(AudioDecoder);
+
+        [Browsable(false)]
+        public int Priority => 2;
+
+        public IAudioDecoderSettings Clone()
+        {
+            return MemberwiseClone() as IAudioDecoderSettings;
+        }
+        #endregion
+
+        public DecoderSettings()
+        {
+            this.Init();
+        }
+
+        public bool IgnoreChunkSizes { get; set; }
+    }
+}

Aaru.Compression/cuetools.net/CUETools.Codecs/WAV/EncoderSettings.cs

@@ -0,0 +1,64 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+
+namespace CUETools.Codecs.WAV
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class EncoderSettings : IAudioEncoderSettings
+    {
+        #region IAudioEncoderSettings implementation
+        [Browsable(false)]
+        public string Extension => "wav";
+
+        [Browsable(false)]
+        public string Name => "cuetools";
+
+        [Browsable(false)]
+        public Type EncoderType => typeof(WAV.AudioEncoder);
+
+        [Browsable(false)]
+        public bool Lossless => true;
+
+        [Browsable(false)]
+        public int Priority => 10;
+
+        [Browsable(false)]
+        public string SupportedModes => "";
+
+        [Browsable(false)]
+        public string DefaultMode => "";
+
+        [Browsable(false)]
+        [DefaultValue("")]
+        public string EncoderMode { get; set; }
+
+        [Browsable(false)]
+        public AudioPCMConfig PCM { get; set; }
+
+        [Browsable(false)]
+        public int BlockSize { get; set; }
+
+        [Browsable(false)]
+        [DefaultValue(4096)]
+        public int Padding { get; set; }
+
+        public IAudioEncoderSettings Clone()
+        {
+            return MemberwiseClone() as IAudioEncoderSettings;
+        }
+        #endregion
+
+        public EncoderSettings()
+        {
+            this.Init();
+        }
+
+        public EncoderSettings(AudioPCMConfig pcm)
+        {
+            this.Init(pcm);
+        }
+    }
+}