public SOXResampler(AudioPCMConfig inputPCM, AudioPCMConfig outputPCM, SOXResamplerConfig config)
{
this.inputPCM = inputPCM;
this.outputPCM = outputPCM;
if (inputPCM.ChannelCount != outputPCM.ChannelCount)
throw new NotSupportedException();
if (outputPCM.SampleRate == inputPCM.SampleRate * 4 && config.Quality >= SOXResamplerQuality.Medium)
{
this.rate = new rate_t[inputPCM.ChannelCount];
this.shared = new rate_shared_t();
this.rateUp2 = new rate_t[inputPCM.ChannelCount];
this.sharedUp2 = new rate_shared_t();
for (int i = 0; i < inputPCM.ChannelCount; i++)
{
rateUp2[i] = new rate_t(inputPCM.SampleRate, inputPCM.SampleRate * 2, sharedUp2, 0.5,
config.Quality, -1, config.Phase, config.Bandwidth, config.AllowAliasing);
rate[i] = new rate_t(inputPCM.SampleRate * 2, inputPCM.SampleRate * 4, shared, 0.5,
config.Quality, -1, 50, 90, true);
}
}
else
{
this.rate = new rate_t[inputPCM.ChannelCount];
this.shared = new rate_shared_t();
for (int i = 0; i < inputPCM.ChannelCount; i++)
{
rate[i] = new rate_t(inputPCM.SampleRate, outputPCM.SampleRate, shared, (double)inputPCM.SampleRate / outputPCM.SampleRate,
config.Quality, -1, config.Phase, config.Bandwidth, config.AllowAliasing);
}
}
}
public void SOXResamplerConstructorTest()
{
AudioPCMConfig inputPCM = new AudioPCMConfig(32, 1, 44100);
AudioPCMConfig outputPCM = new AudioPCMConfig(32, 1, 48000);
SOXResamplerConfig cfg;
cfg.Quality = SOXResamplerQuality.Very;
cfg.Phase = 50;
cfg.AllowAliasing = false;
cfg.Bandwidth = 0;
SOXResampler resampler = new SOXResampler(inputPCM, outputPCM, cfg);
AudioBuffer src = new AudioBuffer(inputPCM, 400 * inputPCM.SampleRate / 1000);
AudioBuffer dst = new AudioBuffer(outputPCM, src.Size * 3);
int offs = 0;
double delta = 0;
for (int i = 0; i < 100; i++)
{
src.Prepare(-1);
for (int j = 0; j < src.Size; j++)
src.Float[j, 0] = (float)Math.Sin((i * src.Size + j) * Math.PI / 44100);
src.Length = src.Size;
resampler.Flow(src, dst);
for (int j = 0; j < dst.Length; j++)
delta += dst.Float[j, 0] - Math.Sin((offs + j) * Math.PI / 48000);
offs += dst.Length;
}
Assert.IsTrue(Math.Abs(delta) < 0.00001, "Error too large");
}
public static IAudioDest GetAudioDest(AudioEncoderType audioEncoderType, string path, AudioPCMConfig pcm, long finalSampleCount, int padding, string extension, CUEConfig config)
{
IAudioDest dest;
if (audioEncoderType == AudioEncoderType.NoAudio || extension == ".dummy")
{
dest = new DummyWriter(path, pcm);
dest.FinalSampleCount = finalSampleCount;
return dest;
}
CUEToolsFormat fmt;
if (!extension.StartsWith(".") || !config.formats.TryGetValue(extension.Substring(1), out fmt))
throw new Exception("Unsupported audio type: " + path);
CUEToolsUDC encoder = audioEncoderType == AudioEncoderType.Lossless ? fmt.encoderLossless :
audioEncoderType == AudioEncoderType.Lossy ? fmt.encoderLossy :
null;
if (encoder == null)
throw new Exception("Unsupported audio type: " + path);
if (encoder.path != null)
dest = new UserDefinedWriter(path, null, pcm, encoder.path, encoder.parameters, encoder.default_mode, padding);
else if (encoder.type != null)
{
object o = Activator.CreateInstance(encoder.type, path, pcm);
if (o == null || !(o is IAudioDest))
throw new Exception("Unsupported audio type: " + path + ": " + encoder.type.FullName);
dest = o as IAudioDest;
}
else
throw new Exception("Unsupported audio type: " + path);
dest.CompressionLevel = encoder.DefaultModeIndex;
dest.FinalSampleCount = finalSampleCount;
dest.Padding = padding;
dest.Settings = encoder.settings;
return dest;
}
private void CheckPCMConfig(AudioPCMConfig pcm)
{
if (pcm.BitsPerSample != 16 && pcm.BitsPerSample != 24)
{
throw new UnsupportedBitsPerSampleException("LAME only supports 16 bits/sample. 24 bits are supported through conversion.");
}
}
public NativeFlacWriter(Stream outputStream, AudioPCMConfig pcm)
{
this.compressionLevel = 5;
this.pcm = pcm;
this.outputStream = outputStream;
}
public NoiseAndErrorsGenerator(AudioPCMConfig pcm, long sampleCount, int seed, int offset, int errors, int maxStrideErrors = 0)
{
if (offset < 0)
throw new ArgumentOutOfRangeException("offset", "offset cannot be negative");
if (errors < 0)
throw new ArgumentOutOfRangeException("offset", "errors cannot be negative");
this._sampleOffset = 0;
this._sampleCount = sampleCount;
this.pcm = pcm;
this.rnd = new Random(seed);
this.temp = new byte[8192 * pcm.BlockAlign];
this.tempOffs = temp.Length;
int byteOff = offset * pcm.BlockAlign;
for (int k = 0; k < byteOff / temp.Length; k++)
rnd.NextBytes(temp);
if (byteOff % temp.Length > 0)
rnd.NextBytes(new byte[byteOff % temp.Length]);
this.errors = new int[errors];
this.rnd2 = new Random(seed);
var strideErrors = new int[10 * 588];
for (int i = 0; i < errors; i++)
{
do
{
this.errors[i] = this.rnd2.Next(0, (int)sampleCount);
} while (maxStrideErrors > 0 && strideErrors[this.errors[i] % (10 * 588)] >= maxStrideErrors);
strideErrors[this.errors[i] % (10 * 588)]++;
}
this.rnd2 = new Random(seed);
Array.Sort(this.errors);
this.nextError = 0;
}
public WAVWriter(string path, Stream IO, AudioPCMConfig pcm)
{
_pcm = pcm;
_path = path;
_IO = IO != null ? IO : new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read);
_bw = new BinaryWriter(_IO);
}
public LameWriter(Stream output, AudioPCMConfig pcm)
{
this.CheckPCMConfig(pcm);
this.outputStream = output;
this.pcm = pcm;
this.settings = new LameWriterSettings();
}
public RemoteWriterBase(IPAddress remoteAddress, string path, AudioPCMConfig pcm)
{
this.remoteEndpoint = new IPEndPoint(remoteAddress, EncodingServer.Port);
this.pcm = pcm;
this.outputPath = path;
this.outputStream = File.Create(path);
}
public NativeFlacWriter(string path, AudioPCMConfig pcm)
{
this.compressionLevel = 5;
this.pcm = pcm;
this.outputPath = path;
this.outputStream = File.Create(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 LameWriter(string path, AudioPCMConfig pcm)
{
this.CheckPCMConfig(pcm);
this.pcm = pcm;
this.outputPath = path;
this.outputStream = File.Create(path);
this.settings = new LameWriterSettings();
}
public MixingBuffer(AudioPCMConfig pcm, int size, int sources)
{
source = new AudioBuffer[sources];
volume = new float[sources];
filled = new bool[sources];
for (int i = 0; i < sources; i++)
{
source[i] = new AudioBuffer(pcm, size);
}
}
public MixingSource(AudioPCMConfig pcm, int delay, int sources)
{
if (pcm.BitsPerSample != 32)
throw new NotSupportedException("please use 32 bits per sample (float)");
this.pcm = pcm;
this.size = delay * pcm.SampleRate / 1000;
this.buf = new MixingBuffer[2];
this.buf[0] = new MixingBuffer(pcm, size, sources);
this.buf[1] = new MixingBuffer(pcm, size, sources);
this.playing = new bool[sources];
this.volume = new float[sources];
this.samplePos = 0;
}
public ALACReader(AudioPCMConfig _pcm, int rice_historymult, int rice_initialhistory, int rice_kmodifier, int blocksize)
{
pcm = _pcm;
setinfo_max_samples_per_frame = blocksize;
setinfo_rice_historymult = (byte)rice_historymult;
setinfo_rice_initialhistory = (byte)rice_initialhistory;
setinfo_rice_kmodifier = (byte)rice_kmodifier;
_predicterror_buffer_a = new int[setinfo_max_samples_per_frame];
_predicterror_buffer_b = new int[setinfo_max_samples_per_frame];
_outputsamples_buffer_a = new int[setinfo_max_samples_per_frame];
_outputsamples_buffer_b = new int[setinfo_max_samples_per_frame];
_framesBuffer = new byte[65536];
}
public UserDefinedWriter(string path, Stream IO, AudioPCMConfig pcm, string encoder, string encoderParams, string encoderMode, int padding)
{
_path = path;
_encoder = encoder;
_encoderParams = encoderParams;
_encoderMode = encoderMode;
useTempFile = _encoderParams.Contains("%I");
tempFile = path + ".tmp.wav";
_encoderProcess = new Process();
_encoderProcess.StartInfo.FileName = _encoder;
_encoderProcess.StartInfo.Arguments = _encoderParams.Replace("%O", "\"" + path + "\"").Replace("%M", encoderMode).Replace("%P", padding.ToString()).Replace("%I", "\"" + tempFile + "\"");
_encoderProcess.StartInfo.CreateNoWindow = true;
if (!useTempFile)
_encoderProcess.StartInfo.RedirectStandardInput = true;
_encoderProcess.StartInfo.UseShellExecute = false;
if (!_encoderParams.Contains("%O"))
_encoderProcess.StartInfo.RedirectStandardOutput = true;
if (useTempFile)
{
wrt = new WAVWriter(tempFile, null, pcm);
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(_encoder + ": " + (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 WAVWriter(path, inputStream, pcm);
}
/// <summary>
/// Creates a new WASAPI Output
/// </summary>
/// <param name="device">Device to use</param>
/// <param name="shareMode"></param>
/// <param name="useEventSync">true if sync is done with event. false use sleep.</param>
/// <param name="latency"></param>
public WasapiOut(MMDevice device, AudioClientShareMode shareMode, bool useEventSync, int latency, AudioPCMConfig pcm)
{
this.audioClient = device.AudioClient;
this.shareMode = shareMode;
this.isUsingEventSync = useEventSync;
this.latencyMilliseconds = latency;
this.pcm = pcm;
this.outputFormat = new NAudio.Wave.WaveFormatExtensible(pcm.SampleRate, pcm.BitsPerSample, pcm.ChannelCount);
NAudio.Wave.WaveFormatExtensible closestSampleRateFormat;
if (!audioClient.IsFormatSupported(shareMode, outputFormat, out closestSampleRateFormat))
throw new NotSupportedException("PCM format mismatch");
Init();
bufferFrameCount = audioClient.BufferSize;
readBuffers = new AudioBuffer[2];
readBuffers[0] = new AudioBuffer(pcm, bufferFrameCount);
readBuffers[1] = new AudioBuffer(pcm, bufferFrameCount);
//if (this.shareMode == AudioClientShareMode.Exclusive)
// this.latencyMilliseconds = (int)(this.audioClient.DefaultDevicePeriod / 10000);
}
public WAVReader(string path, Stream IO, AudioPCMConfig _pcm)
{
_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");
}
}
private byte[] Wav2FlacBuffConverter(byte[] Buffer)
{
Stream OutWavStream = new MemoryStream();
Stream OutFlacStream = new MemoryStream();
AudioPCMConfig pcmconf = new AudioPCMConfig(16, 1, 16000);
WAVWriter wr = new WAVWriter(null, OutWavStream, pcmconf);
wr.Write(new AudioBuffer(pcmconf, Buffer, Buffer.Length / 2));
OutWavStream.Seek(0, SeekOrigin.Begin);
WAVReader audioSource = new WAVReader(null, OutWavStream);
if (audioSource.PCM.SampleRate != 16000)
return null;
AudioBuffer buff = new AudioBuffer(audioSource, 0x10000);
FlakeWriter flakeWriter = new FlakeWriter(null, OutFlacStream, audioSource.PCM);
flakeWriter.CompressionLevel = 8;
while (audioSource.Read(buff, -1) != 0)
{
flakeWriter.Write(buff);
}
OutFlacStream.Seek(0, SeekOrigin.Begin);
byte[] barr = new byte[OutFlacStream.Length];
OutFlacStream.Read(barr, 0, (int)OutFlacStream.Length);
return barr;
}
public WAVReader(Stream IO, AudioPCMConfig _pcm)
{
if (IO == null)
{
throw new ArgumentNullException("IO");
}
_IO = IO;
_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");
}
}
private void CheckPCMConfig(AudioPCMConfig pcm)
{
if (pcm.BitsPerSample != 16)
{
throw new ArgumentException("LAME only supports 16 bits/sample.");
}
}
public AudioEncoderSettings(AudioPCMConfig pcm)
: this("", "")
{
this.PCM = pcm;
}
public AudioBuffer(AudioPCMConfig _pcm, int _size)
{
pcm = _pcm;
size = _size;
length = 0;
}
public LameWriter(Stream output, AudioPCMConfig pcm)
{
this.CheckPCMConfig(pcm);
this.outputStream = output;
this.pcm = pcm;
}
public WAVWriterSettings(AudioPCMConfig pcm)
: base(pcm)
{
}
public AudioBuffer(AudioPCMConfig _pcm, int[,] _samples, int _length)
{
PCM = _pcm;
// assert _samples.GetLength(1) == pcm.ChannelCount
Prepare(_samples, _length);
}
public RemoteMp3VbrWriter(IPAddress remoteAddress, Stream output, AudioPCMConfig pcm)
: base(remoteAddress, output, pcm)
{
this.CheckPCMConfig(pcm);
}
public FlakeWriter(string path, AudioPCMConfig pcm)
: this(path, null, pcm)
{
}
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();
pos += 16;
if (fmtTag == 0xFFFEU && ckSize >= 34) // WAVE_FORMAT_EXTENSIBLE
{
_br.ReadInt16(); // CbSize
_br.ReadInt16(); // ValidBitsPerSample
int 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);
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 >= 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 RemoteMp3VbrWriter(IPAddress remoteAddress, string outputPath, AudioPCMConfig pcm)
: base(remoteAddress, outputPath, pcm)
{
this.CheckPCMConfig(pcm);
}
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 AudioEncoderSettings(AudioPCMConfig pcm)
: this("", "")
{
this.PCM = pcm;
}
public AudioBuffer(AudioPCMConfig _pcm, byte[] _bytes, int _length)
{
PCM = _pcm;
Prepare(_bytes, _length);
}
public WAVWriter(string path, AudioPCMConfig pcm)
: this(path, null, pcm)
{
}
public DummyWriter(string path, AudioPCMConfig pcm)
{
_pcm = pcm;
}
public FlakeWriter(string path, Stream IO, AudioPCMConfig pcm)
{
_pcm = pcm;
//if (_pcm.BitsPerSample != 16)
// throw new Exception("Bits per sample must be 16.");
if (_pcm.ChannelCount != 2)
throw new Exception("ChannelCount must be 2.");
channels = pcm.ChannelCount;
// flake_validate_params
_path = path;
_IO = IO;
samplesBuffer = new int[Flake.MAX_BLOCKSIZE * (channels == 2 ? 4 : channels)];
residualBuffer = new int[Flake.MAX_BLOCKSIZE * (channels == 2 ? 10 : channels + 1)];
windowBuffer = new float[Flake.MAX_BLOCKSIZE * 2 * lpc.MAX_LPC_WINDOWS];
windowScale = new double[lpc.MAX_LPC_WINDOWS];
eparams.flake_set_defaults(_compressionLevel);
eparams.padding_size = 8192;
crc8 = new Crc8();
crc16 = new Crc16();
frame = new FlacFrame(channels * 2);
}
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 static IAudioDest GetAudioDest(AudioEncoderType audioEncoderType, string path, long finalSampleCount, int bitsPerSample, int sampleRate, int padding, CUEConfig config)
{
string extension = Path.GetExtension(path).ToLower();
string filename = Path.GetFileNameWithoutExtension(path);
AudioPCMConfig pcm = new AudioPCMConfig(bitsPerSample, 2, sampleRate);
if (audioEncoderType == AudioEncoderType.NoAudio || audioEncoderType == AudioEncoderType.Lossless || Path.GetExtension(filename).ToLower() != ".lossy")
return GetAudioDest(audioEncoderType, path, pcm, finalSampleCount, padding, extension, config);
string lwcdfPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(filename) + ".lwcdf" + extension);
AudioPCMConfig lossypcm = new AudioPCMConfig((config.detectHDCD && config.decodeHDCD && !config.decodeHDCDtoLW16) ? 24 : 16, 2, sampleRate);
IAudioDest lossyDest = GetAudioDest(AudioEncoderType.Lossless, path, lossypcm, finalSampleCount, padding, extension, config);
IAudioDest lwcdfDest = audioEncoderType == AudioEncoderType.Hybrid ? GetAudioDest(AudioEncoderType.Lossless, lwcdfPath, lossypcm, finalSampleCount, padding, extension, config) : null;
return new LossyWAVWriter(lossyDest, lwcdfDest, config.lossyWAVQuality, pcm);
}
public AudioBuffer(IAudioSource source, int _size)
{
pcm = source.PCM;
size = _size;
}
public AudioBuffer(AudioPCMConfig _pcm, int _size)
{
PCM = _pcm;
Size = _size;
Length = 0;
}
public AudioBuffer(IAudioSource source, int _size)
{
pcm = source.PCM;
size = _size;
}
