/// <summary>
/// Read Gaussian distribution.
/// </summary>
/// <param name="reader">Binary reader to read Gaussian distributions.</param>
/// <param name="dimension">Dimension of the Gaussian distribution to read.</param>
/// <param name="streamOrder">The dynamic order of current Gaussian distribution to read.</param>
/// <returns>Gaussian distribution.</returns>
protected virtual Gaussian ReadGaussian(BinaryReader reader, int dimension, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(reader);
Gaussian gaussian = new Gaussian();
gaussian.Length = dimension;
gaussian.Weight = Config.HasWeight ? reader.ReadSingle() : float.NaN;
if (Config.HasMean)
{
if (!Config.HasVariance)
{
throw new InvalidDataException(Helper.NeutralFormat("Variance is needed as Mean depends on that."));
}
Debug.Assert(Config.MeanBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
gaussian.Mean = new double[gaussian.Length];
for (int i = 0; i < gaussian.Length; i++)
{
gaussian.Mean[i] = reader.ReadSingle();
}
}
if (Config.HasVariance)
{
Debug.Assert(Config.VarianceBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
gaussian.Variance = new double[gaussian.Length];
for (int i = 0; i < gaussian.Length; i++)
{
gaussian.Variance[i] = reader.ReadSingle();
gaussian.Variance[i] = 1.0f / gaussian.Variance[i]; // Revert back
}
}
if (Config.HasMean)
{
for (int i = 0; i < gaussian.Length; i++)
{
gaussian.Mean[i] *= gaussian.Variance[i]; // Revert back
}
}
return gaussian;
}
/// <summary>
/// Write out one Gaussian distribution to be 4-byte aligned.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="gaussian">Gaussian distribution to write out.</param>
/// <param name="streamOrder">Dynamic order of the stream of current Gaussian distribution.</param>
/// <returns>Number of bytes written out.</returns>
protected uint WriteFourBytesAlignedGaussian(DataWriter writer, Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussian);
uint size = Write(writer, gaussian, streamOrder);
if (size == 0)
{
throw new InvalidDataException(Helper.NeutralFormat("Zero length of Gaussian is not allowed."));
}
// Pad zero bytes if needed to align with 4-bytes
if (size % sizeof(uint) > 0)
{
size += writer.Write(new byte[sizeof(uint) - (size % sizeof(uint))]);
}
Debug.Assert(size % sizeof(uint) == 0, "Data should be 4-byte aligned.");
return size;
}
/// <summary>
/// Read linear transform.
/// </summary>
/// <param name="reader">Binary reader to read linear transforms.</param>
/// <param name="dimension">Dimension of the linear transform to read.</param>
/// <param name="blockSizes">Size of each linear transform sub matrix to read.</param>
/// <param name="streamOrder">The dynamic order of current linear transform to read.</param>
/// <param name="meanXform">Transform for Gaussian mean.</param>
/// <param name="varXform">Transform for Gaussian variance.</param>
public virtual void ReadLinXform(BinaryReader reader, int dimension, List<int> blockSizes, DynamicOrder streamOrder, out LinXForm meanXform, out LinXForm varXform)
{
Helper.ThrowIfNull(reader);
long orgPos = reader.BaseStream.Position;
meanXform = null;
varXform = null;
if (Config.HasMeanXform)
{
meanXform = ReadFourBytesAlignedLinXform(reader, dimension, blockSizes, streamOrder, Config.HasMeanBias, Config.MeanBandWidth);
}
if (Config.HasVarXform)
{
varXform = ReadFourBytesAlignedLinXform(reader, dimension, blockSizes, streamOrder, Config.HasVarBias);
}
if (Encoder != null)
{
// ramp up the encoder
long size = reader.BaseStream.Position - orgPos;
reader.BaseStream.Position = orgPos;
Encoder.WarmUpData(reader.ReadBytes((int)size), 1);
}
}
/// <summary>
/// Write out Gaussian distribution.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="gaussian">Gaussian.</param>
/// <param name="streamOrder">The dynamic order of stream, to which the Gaussian belongs.</param>
/// <returns>Size of bytes written.</returns>
protected virtual uint Write(DataWriter writer, Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussian);
uint size = 0;
if (Config.HasWeight)
{
size += writer.Write((float)gaussian.Weight);
}
Debug.Assert(Config.MeanBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
Debug.Assert(Config.VarianceBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
for (int i = 0; Config.HasMean && i < gaussian.Length; i++)
{
Debug.Assert(Config.HasVariance, "Variance is needed to encode mean for runtime.");
double invVar = CalculateInvertedVariance(gaussian.Variance[i], DefaultVarianceFloor);
double mean = gaussian.Mean[i] * invVar;
size += writer.Write((float)mean);
}
for (int i = 0; Config.HasVariance && i < gaussian.Length; i++)
{
double invVar = CalculateInvertedVariance(gaussian.Variance[i], DefaultVarianceFloor);
size += writer.Write((float)invVar);
}
return size;
}
/// <summary>
/// Quantize means and variances in Gaussian distribution into value range of fixed point numerical representation.
/// </summary>
/// <param name="gaussian">Gaussian distribution to quantize.</param>
/// <param name="streamOrder">Stream order of current Gaussian distribution to quantize.</param>
/// <returns>Quantized Gaussian distribution.</returns>
private Gaussian Quantize(Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(gaussian);
Gaussian quantized = new Gaussian(gaussian.Weight, gaussian.Length);
for (int i = 0; Config.HasMean && i < gaussian.Length; i++)
{
double mean = (double)gaussian.Mean[i] / MaxLogF0DownScaleFactor * MeanUpScaleAsShortFactor;
quantized.Mean[i] = (short)Clip(short.MinValue, Math.Round(mean), short.MaxValue);
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
for (int i = 0; Config.HasVariance && i < gaussian.Length; i++)
{
double invVar = CalculateInvertedVariance(gaussian.Variance[i], DefaultVarianceFloor);
if (streamOrder != DynamicOrder.Static && i >= Config.StaticVectorSize)
{
// Treat non-static features differently as it has bigger range
invVar /= byte.MaxValue;
}
else
{
invVar *= StaticVarianceUpscaleFactor;
}
invVar = Math.Sqrt(invVar);
quantized.Variance[i] = (byte)Clip(1, Math.Round(invVar), byte.MaxValue);
Debug.Assert(quantized.Variance[i] >= 1);
}
return quantized;
}
/// <summary>
/// Write out Gaussian.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="gaussian">Gaussian.</param>
/// <param name="streamOrder">The dynamic order of stream, to which the Gaussian belongs.</param>
/// <returns>Size of bytes written.</returns>
protected override uint Write(DataWriter writer, Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussian);
uint size = 0;
Gaussian quantized = gaussian;
if (IsNeedQuantize)
{
quantized = Quantize(gaussian);
QuantizedStatistic.Put(quantized, streamOrder);
}
if (Config.HasWeight)
{
size += writer.Write((float)quantized.Weight);
}
if (!Config.HasMean || !Config.HasVariance)
{
throw new InvalidDataException("Needs both mean and variance.");
}
for (int i = 0; i < quantized.Length; i++)
{
if ((i + 1) % Config.StaticVectorSize == 0)
{
size += writer.Write((short)quantized.Mean[i]);
}
else if (i < Config.StaticVectorSize)
{
size += writer.Write((byte)quantized.Mean[i]);
}
else
{
size += writer.Write((sbyte)quantized.Mean[i]);
}
}
for (int i = 0; i < gaussian.Length; i++)
{
size += writer.Write((byte)quantized.Variance[i]);
}
return size;
}
/// <summary>
/// De-quantize Gaussian distribution of LSP model.
/// </summary>
/// <param name="gaussian">Gaussian distribution to de-quantize.</param>
/// <param name="streamOrder">The dynamic order of current Gaussian distribution to read.</param>
/// <returns>De-quantized Gaussian distribution.</returns>
private Gaussian Dequantize(Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(gaussian);
Gaussian result = new Gaussian();
result.Length = gaussian.Length;
result.Weight = gaussian.Weight;
result.Mean = new double[gaussian.Length];
result.Variance = new double[gaussian.Length];
Debug.Assert(Config.MeanBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
double accumulatedMean = 0.0f;
for (int i = 0; i < gaussian.Length; i++)
{
if ((i + 1) % Config.StaticVectorSize == 0)
{
// Gain
result.Mean[i] = (double)(gaussian.Mean[i] * GainMaximumMean) / short.MaxValue;
}
else if (i < Config.StaticVectorSize)
{
accumulatedMean += (double)(gaussian.Mean[i] * _staticLsfMeanDownScaleTo256Factor) / short.MaxValue;
result.Mean[i] = accumulatedMean;
}
else
{
result.Mean[i] = (double)(gaussian.Mean[i] * _nonStaticLsfMeanDownScaleFactor) / short.MaxValue;
}
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
for (int i = 0; i < gaussian.Length; i++)
{
double value = (int)gaussian.Variance[i];
value = (double)(value * value);
if (i >= Config.StaticVectorSize)
{
value *= byte.MaxValue;
}
if ((i + 1) % Config.StaticVectorSize == 0)
{
// Gain
value /= GainUpScaleFactor;
}
else
{
value *= LsfDownScaleFactor;
}
result.Variance[i] = 1.0f / value;
}
return result;
}
/// <summary>
/// Write out Gaussians of one stream.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="gaussians">Gaussians.</param>
/// <param name="streamOrder">The dynamic order of stream, to which the Gaussian belongs.</param>
/// <returns>Size of bytes written.</returns>
public override uint Write(DataWriter writer, Gaussian[] gaussians, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussians);
if (gaussians.Count(g => g.Length > 0) != 1)
{
string message = string.Format(CultureInfo.InvariantCulture,
"Multi-space distribution with [{0}] non-zero-length mixtures is not supported",
gaussians.Count(g => g.Length > 0));
throw new InvalidDataException(message);
}
// Maximum dimension among Gaussian models in this stream
int maxDimension = gaussians.Max(g => g.Length);
uint size = 0;
Debug.Assert(gaussians.Count(g => g.Length == maxDimension) == 1,
"The number of meaningful MSD mixture number should be 1");
for (int i = 0; i < gaussians.Length; i++)
{
if (gaussians[i].Length == maxDimension)
{
Statistic.Put(gaussians[i], streamOrder);
size += WriteFourBytesAlignedGaussian(writer, gaussians[i], streamOrder);
}
}
return size;
}
/// <summary>
/// Read one linear transform from binary reader, which is to be 4-bytes aligned.
/// </summary>
/// <param name="reader">Binary reader.</param>
/// <param name="dimension">The number of dimension of the linear transform to read.</param>
/// <param name="blockSizes">The size of each linear transform sub matrix to read.</param>
/// <param name="streamOrder">Dynamic stream order of the linear transform belonging to.</param>
/// <param name="hasBias">Indicate transform whether has bias info.</param>
/// <param name="bandWidth">Band width of linear transform matrix.</param>
/// <returns>Retrieved linear transform.</returns>
protected LinXForm ReadFourBytesAlignedLinXform(BinaryReader reader, int dimension, List<int> blockSizes, DynamicOrder streamOrder, bool hasBias, uint bandWidth = 0)
{
Helper.ThrowIfNull(reader);
long basePosition = reader.BaseStream.Position;
LinXForm linXform = ReadOneLinXform(reader, dimension, blockSizes, streamOrder, hasBias, bandWidth);
// Skip padding bytes for 4-byte alignment
int readSize = (int)(reader.BaseStream.Position - basePosition);
if (readSize % sizeof(uint) > 0)
{
int padByteCount = sizeof(uint) - (readSize % sizeof(uint));
reader.ReadBytes(padByteCount);
}
return linXform;
}
/// <summary>
/// Puts a sample into this list.
/// </summary>
/// <param name="linXform">Linear transform.</param>
/// <param name="streamOrder">Dynamic stream order.</param>
public void Put(LinXForm linXform, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(linXform);
if (!_linXformStatistics.ContainsKey(streamOrder))
{
_linXformStatistics.Add(streamOrder, new LinXformStatistic(linXform));
}
_linXformStatistics[streamOrder].Put(linXform);
}
/// <summary>
/// Write out one linear transform to be 4-byte aligned.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="linXform">Linear transform to write out.</param>
/// <param name="streamOrder">Dynamic order of the stream of current linear transform.</param>
/// <param name="hasBias">Indicate transform whether has bias info.</param>
/// <param name="bandWidth">Band width of linear transform matrix.</param>
/// <returns>Number of bytes written out.</returns>
protected uint WriteFourBytesAlignedLinXform(DataWriter writer, LinXForm linXform, DynamicOrder streamOrder, bool hasBias, uint bandWidth = 0)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(linXform);
uint size = Write(writer, linXform, streamOrder, hasBias, bandWidth);
if (size == 0)
{
throw new InvalidDataException(Helper.NeutralFormat("Zero length of linXform is not allowed."));
}
// Pad zero bytes if needed to align with 4-bytes
if (size % sizeof(uint) > 0)
{
size += writer.Write(new byte[sizeof(uint) - (size % sizeof(uint))]);
}
Debug.Assert(size % sizeof(uint) == 0, "Data should be 4-byte aligned.");
return size;
}
/// <summary>
/// Read linear transform.
/// </summary>
/// <param name="reader">Binary reader to read linear transform.</param>
/// <param name="dimension">Dimension of the linear transform to read.</param>
/// <param name="blockSizes">Size of each linear transform sub matrix to read.</param>
/// <param name="streamOrder">The dynamic order of current linear transform to read.</param>
/// <param name="hasBias">Indicate transform whether has bias info.</param>
/// <param name="bandWidth">Band width of linear transform matrix.</param>
/// <returns>Linear transform.</returns>
protected virtual LinXForm ReadOneLinXform(BinaryReader reader, int dimension, List<int> blockSizes, DynamicOrder streamOrder, bool hasBias, uint bandWidth)
{
Helper.ThrowIfNull(reader);
LinXForm linXform = new LinXForm();
linXform.VecSize = dimension;
if (hasBias)
{
Debug.Assert(Config.BiasBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
linXform.Bias = new float[dimension];
for (int i = 0; i < linXform.VecSize; i++)
{
linXform.Bias[i] = reader.ReadSingle();
}
}
Debug.Assert(Config.MatrixBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
for (int i = 0; i < blockSizes.Count; i++)
{
float[,] block = new float[blockSizes[i], blockSizes[i]];
for (int j = 0; j < blockSizes[i]; j++)
{
for (int k = 0; k < blockSizes[i]; k++)
{
if (k < j - bandWidth || k > j + bandWidth)
{
block[j, k] = 0;
}
else
{
block[j, k] = reader.ReadSingle();
}
}
}
linXform.Blocks.Add(block);
}
return linXform;
}
/// <summary>
/// Write out linear transform.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="linXform">Linear transform.</param>
/// <param name="streamOrder">The dynamic order of stream, to which the linear transform belongs.</param>
/// <param name="hasBias">Indicate transform whether has bias info.</param>
/// <param name="bandWidth">Band width of linear transform matrix.</param>
/// <returns>Size of bytes written.</returns>
protected virtual uint Write(DataWriter writer, LinXForm linXform, DynamicOrder streamOrder, bool hasBias, uint bandWidth)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(linXform);
uint size = 0;
Debug.Assert(Config.BiasBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
Debug.Assert(Config.MatrixBits == sizeof(float) * 8, "Only 32-bit float value is supported here");
for (int i = 0; hasBias && i < linXform.VecSize; i++)
{
size += writer.Write(linXform.Bias[i]);
}
for (int i = 0; i < linXform.Blocks.Count; i++)
{
for (int j = 0; j < linXform.Blocks[i].GetLength(0); j++)
{
for (int k = 0; k < linXform.Blocks[i].GetLength(1); k++)
{
if (k >= j - bandWidth && k <= j + bandWidth)
{
size += writer.Write(linXform.Blocks[i][j, k]);
}
}
}
}
return size;
}
/// <summary>
/// Read one Gaussian distribution from binary reader, which is to be 4-bytes aligned.
/// </summary>
/// <param name="reader">Binary reader.</param>
/// <param name="dimension">The number of dimension of the Gaussian distribution to read.</param>
/// <param name="streamOrder">Dynamic stream order of the Gaussian distribution belonging to.</param>
/// <returns>Retrieved Gaussian distribution.</returns>
protected Gaussian ReadFourBytesAlignedGaussian(BinaryReader reader, int dimension, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(reader);
long basePosition = reader.BaseStream.Position;
Gaussian gaussian = ReadGaussian(reader, dimension, streamOrder);
// Skip padding bytes for 4-byte alignment
int readSize = (int)(reader.BaseStream.Position - basePosition);
if (readSize % sizeof(uint) > 0)
{
int padByteCount = sizeof(uint) - (readSize % sizeof(uint));
reader.ReadBytes(padByteCount);
}
return gaussian;
}
/// <summary>
/// Write out Gaussian.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="gaussian">Gaussian.</param>
/// <param name="streamOrder">The dynamic order of stream, to which the Gaussian belongs.</param>
/// <returns>Size of bytes written.</returns>
protected override uint Write(DataWriter writer, Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussian);
uint size = 0;
Gaussian quantized = gaussian;
if (IsNeedQuantize)
{
quantized = Quantize(gaussian, streamOrder);
QuantizedStatistic.Put(quantized, streamOrder);
}
Debug.Assert(Config.MeanBits == sizeof(short) * 8, "Only 16-bit short value is supported here");
for (int i = 0; Config.HasMean && i < gaussian.Length; i++)
{
size += writer.Write((short)quantized.Mean[i]);
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
for (int i = 0; Config.HasVariance && i < gaussian.Length; i++)
{
size += writer.Write((byte)quantized.Variance[i]);
}
return size;
}
/// <summary>
/// Puts a sample into this list.
/// </summary>
/// <param name="gaussian">Gaussian distribution.</param>
/// <param name="streamOrder">Dynamic stream order.</param>
public void Put(Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(gaussian);
if (!GuassianStatistics.ContainsKey(streamOrder))
{
GuassianStatistics.Add(streamOrder, new GaussianStatistic(gaussian.Length));
}
GuassianStatistics[streamOrder].Put(gaussian);
}
/// <summary>
/// Read Gaussian distribution.
/// </summary>
/// <param name="reader">Binary reader to read Gaussian distributions.</param>
/// <param name="dimension">Dimension of the Gaussian distribution to read.</param>
/// <param name="streamOrder">The dynamic order of current Gaussian distribution to read.</param>
/// <returns>Gaussian distribution.</returns>
protected override Gaussian ReadGaussian(BinaryReader reader, int dimension, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(reader);
Gaussian gaussian = new Gaussian();
gaussian.Length = dimension;
Debug.Assert(Config.MeanBits == sizeof(short) * 8, "Only 16-bit short value is supported here");
gaussian.Mean = new double[gaussian.Length];
for (int i = 0; i < gaussian.Length; i++)
{
gaussian.Mean[i] = reader.ReadInt16();
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
gaussian.Variance = new double[gaussian.Length];
for (int i = 0; Config.HasVariance && i < gaussian.Length; i++)
{
gaussian.Variance[i] = (int)reader.ReadByte();
}
if (IsNeedQuantize)
{
gaussian = Dequantize(gaussian, streamOrder);
}
return gaussian;
}
/// <summary>
/// Write out Gaussian.
/// </summary>
/// <param name="writer">Binary writer.</param>
/// <param name="gaussian">Gaussian.</param>
/// <param name="streamOrder">The dynamic order of stream, to which the Gaussian belongs.</param>
/// <returns>Size of bytes written.</returns>
protected override uint Write(DataWriter writer, Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussian);
uint size = 0;
Gaussian quantized = gaussian;
if (IsNeedQuantize)
{
quantized = Quantize(gaussian, streamOrder);
QuantizedStatistic.Put(quantized, streamOrder);
}
if (Config.HasWeight)
{
if (quantized.Weight == 0.0f)
{
throw new InvalidDataException(Helper.NeutralFormat("Zero weight of LogF0 is found."));
}
size += writer.Write((float)quantized.Weight);
}
Debug.Assert(Config.MeanBits == sizeof(short) * 8, "Only 16-bit short value is supported here");
for (int i = 0; Config.HasMean && i < gaussian.Length; i++)
{
size += writer.Write((short)quantized.Mean[i]);
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
for (int i = 0; Config.HasVariance && i < gaussian.Length; i++)
{
size += writer.Write((byte)quantized.Variance[i]);
}
return size;
}
public virtual uint Write(DataWriter writer, Gaussian[] gaussians, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(gaussians);
DataWriter orgWriter = writer;
MemoryStream gaussiansBuf = null;
if (EnableCompress)
{
gaussiansBuf = new MemoryStream();
writer = new DataWriter(gaussiansBuf);
}
uint size = 0;
for (int i = 0; i < gaussians.Length; i++)
{
Statistic.Put(gaussians[i], streamOrder);
size += WriteFourBytesAlignedGaussian(writer, gaussians[i], streamOrder);
}
if (EnableCompress)
{
size = orgWriter.Write(Encoder.Encode(gaussiansBuf.ToArray()));
if (size % sizeof(uint) != 0)
{
size += orgWriter.Write(new byte[sizeof(uint) - (size % sizeof(uint))]);
}
writer = orgWriter;
}
return size;
}
/// <summary>
/// De-quantize Gaussian distribution of LogF0 model.
/// </summary>
/// <param name="gaussian">Gaussian distribution to de-quantize.</param>
/// <param name="streamOrder">The dynamic order of current Gaussian distribution to read.</param>
/// <returns>De-quantized Gaussian distribution.</returns>
private Gaussian Dequantize(Gaussian gaussian, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(gaussian);
Gaussian result = new Gaussian(gaussian.Weight, gaussian.Length);
Debug.Assert(Config.MeanBits == sizeof(short) * 8, "Only 16-bit short value is supported here");
for (int i = 0; i < gaussian.Length; i++)
{
result.Mean[i] = (double)(gaussian.Mean[i] * MaxLogF0DownScaleFactor) / MeanUpScaleAsShortFactor;
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
for (int i = 0; Config.HasVariance && i < gaussian.Length; i++)
{
double value = (int)gaussian.Variance[i];
if (i >= Config.StaticVectorSize && streamOrder != DynamicOrder.Static)
{
value = (double)(value * value);
value *= byte.MaxValue;
}
result.Variance[i] = 1.0f / value;
}
return result;
}
/// <summary>
/// Read Gaussian distributions.
/// </summary>
/// <param name="reader">Binary reader to read Gaussian distributions.</param>
/// <param name="dimension">Dimension of the Gaussian distribution to read.</param>
/// <param name="streamOrder">The dynamic order of current Gaussian distribution to read.</param>
/// <returns>Gaussian distributions.</returns>
public virtual Gaussian[] ReadGaussians(BinaryReader reader, int dimension, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(reader);
long orgPos = reader.BaseStream.Position;
Gaussian[] gaussians = new Gaussian[Config.MixtureCount];
for (uint i = 0; i < Config.MixtureCount; i++)
{
gaussians[i] = ReadFourBytesAlignedGaussian(reader, dimension, streamOrder);
}
if (Encoder != null)
{
// ramp up the encoder
long size = reader.BaseStream.Position - orgPos;
reader.BaseStream.Position = orgPos;
Encoder.WarmUpData(reader.ReadBytes((int)size), 1);
}
return gaussians;
}
/// <summary>
/// Read Gaussian distribution.
/// </summary>
/// <param name="reader">Binary reader to read Gaussian distributions.</param>
/// <param name="dimension">Dimension of the Gaussian distribution to read.</param>
/// <param name="streamOrder">The dynamic order of current Gaussian distribution to read.</param>
/// <returns>Gaussian distribution.</returns>
protected override Gaussian ReadGaussian(BinaryReader reader, int dimension, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(reader);
Gaussian gaussian = new Gaussian();
gaussian.Length = dimension;
gaussian.Weight = Config.HasWeight ? reader.ReadSingle() : float.NaN;
Debug.Assert(Config.MeanBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
gaussian.Mean = new double[gaussian.Length];
for (int i = 0; i < gaussian.Length; i++)
{
if ((i + 1) % Config.StaticVectorSize == 0)
{
// Gain
gaussian.Mean[i] = reader.ReadInt16();
}
else if (i < Config.StaticVectorSize)
{
gaussian.Mean[i] = reader.ReadByte();
}
else
{
gaussian.Mean[i] = reader.ReadSByte();
}
}
Debug.Assert(Config.VarianceBits == sizeof(byte) * 8, "Only 8-bit byte value is supported here");
gaussian.Variance = new double[gaussian.Length];
for (int i = 0; i < gaussian.Length; i++)
{
gaussian.Variance[i] = reader.ReadByte();
}
if (IsNeedQuantize)
{
gaussian = Dequantize(gaussian, streamOrder);
}
return gaussian;
}
public virtual uint Write(DataWriter writer, LinXForm meanXform, LinXForm varXform, DynamicOrder streamOrder)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(meanXform);
Helper.ThrowIfNull(varXform);
DataWriter orgWriter = writer;
MemoryStream linXformsBuf = null;
if (EnableCompress)
{
linXformsBuf = new MemoryStream();
writer = new DataWriter(linXformsBuf);
}
uint size = 0;
if (Config.HasMeanXform)
{
MeanStatistic.Put(meanXform, streamOrder);
size += WriteFourBytesAlignedLinXform(writer, meanXform, streamOrder, Config.HasMeanBias, Config.MeanBandWidth);
}
if (Config.HasVarXform)
{
VarStatistic.Put(varXform, streamOrder);
size += WriteFourBytesAlignedLinXform(writer, varXform, streamOrder, Config.HasVarBias);
}
if (EnableCompress)
{
size = orgWriter.Write(Encoder.Encode(linXformsBuf.ToArray()));
if (size % sizeof(uint) != 0)
{
size += orgWriter.Write(new byte[sizeof(uint) - (size % sizeof(uint))]);
}
writer = orgWriter;
}
return size;
}
