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);
}
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 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 void BytesTest()
{
AudioBuffer target = new AudioBuffer(AudioPCMConfig.RedBook, 1);
target.Prepare(testSamples, testSamples.GetLength(0));
CollectionAssert.AreEqual(testBytes, target.Bytes, "CUETools.Codecs.AudioBuffer.Bytes was not set correctly.");
target.Prepare(testSamples2, testSamples2.GetLength(0));
CollectionAssert.AreEqual(testBytes2, target.Bytes, "CUETools.Codecs.AudioBuffer.Bytes was not set correctly.");
}
public static void MyClassInitialize(TestContext testContext)
{
toc = new CDImageLayout(1, 1, 1, string.Format("0 {0}", (finalSampleCount / 588).ToString()));
ar = new AccurateRipVerify(toc, null);
ar2 = new AccurateRipVerify(toc, null);
ar3 = new AccurateRipVerify(toc, null);
new Random(2423).NextBytes(wav);
new Random(2423).NextBytes(wav2);
Random rnd = new Random(987);
for (int i = 0; i < stride / 4; i++ )
wav2[(int)(rnd.NextDouble() * (wav2.Length - 1))] = (byte)(rnd.NextDouble() * 255);
AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
CDRepairEncode encode = new CDRepairEncode(ar, stride, npar, false, true);
buff.Prepare(wav, finalSampleCount);
ar.Init(toc);
ar.Write(buff);
ar.Close();
parity = encode.Parity;
crc = encode.CRC;
decode = new CDRepairEncode(ar2, stride, npar, true, false);
buff.Prepare(wav2, finalSampleCount);
ar2.Init(toc);
ar2.Write(buff);
ar2.Close();
int actualOffset;
bool hasErrors;
decode.FindOffset(npar, parity, 0, crc, out actualOffset, out hasErrors);
fix = decode.VerifyParity(parity, actualOffset);
decode2 = new CDRepairEncode(ar3, stride, npar, true, false);
ar3.Init(toc);
buff.Prepare(new byte[offset * 4], offset);
ar3.Write(buff);
buff.Prepare(wav2, finalSampleCount - offset);
ar3.Write(buff);
ar3.Close();
decode2.FindOffset(npar, parity, 0, crc, out actualOffset, out hasErrors);
fix2 = decode2.VerifyParity(parity, actualOffset);
}
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);
}
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;
}
public int Read(AudioBuffer result, int maxLength)
{
if (maxLength > (BufferSize - mixoffs) || maxLength < 0)
maxLength = (BufferSize - mixoffs);
result.Prepare(maxLength);
if (mixbuff == null)
mixbuff = LockFilledBuffer();
float sumVolume = 0.0f;
for (int iSource = 0; iSource < mixbuff.source.Length; iSource++)
if (mixbuff.filled[iSource])
sumVolume += mixbuff.volume[iSource];
for (int iSource = 0; iSource < mixbuff.source.Length; iSource++)
volume[iSource] = mixbuff.filled[iSource] ? mixbuff.volume[iSource] / Math.Max(1.0f, sumVolume) : 0.0f;
for (int iSmp = 0; iSmp < result.Length; iSmp++)
{
for (int iChan = 0; iChan < result.PCM.ChannelCount; iChan++)
{
float sample = 0.0f;
for (int iSource = 0; iSource < mixbuff.source.Length; iSource++)
sample += mixbuff.source[iSource].Float[mixoffs + iSmp, iChan] * volume[iSource];
result.Float[iSmp, iChan] = sample;
}
}
mixoffs += result.Length;
if (mixoffs == BufferSize)
{
UnlockFilledBuffer(mixbuff);
mixbuff = null;
mixoffs = 0;
}
samplePos += result.Length;
if (AudioRead != null)
{
audioReadArgs.source = this;
audioReadArgs.buffer = result;
AudioRead(this, audioReadArgs);
}
return result.Length;
}
public void Flow(AudioBuffer input, AudioBuffer output)
{
if (input.PCM.SampleRate != inputPCM.SampleRate || output.PCM.SampleRate != outputPCM.SampleRate ||
input.PCM.ChannelCount != inputPCM.ChannelCount || output.PCM.ChannelCount != outputPCM.ChannelCount)
throw new NotSupportedException();
if (rateUp2 == null)
{
output.Prepare(-1);
int odone = output.Size;
for (int channel = 0; channel < inputPCM.ChannelCount; channel++)
{
rate[channel].input(input.Float, channel, input.Length);
rate[channel].process();
rate[channel].output(output.Float, channel, ref odone);
}
output.Length = odone;
}
else
throw new NotSupportedException();
}
public int Read(AudioBuffer buffer, int maxLength)
{
buffer.Prepare(this, maxLength);
int samplesCopied = 0;
int bytesCopied = 0;
Action copyBuffer = () =>
{
if (this.audioBuffer.Length > this.audioBufferOffset)
{
int samplesToCopy = Math.Min(maxLength, this.audioBuffer.Length - this.audioBufferOffset);
int bytesToCopy = samplesToCopy * this.pcm.BlockAlign;
Array.Copy(this.audioBuffer.Bytes, this.audioBufferOffset * this.pcm.BlockAlign, buffer.Bytes, bytesCopied, bytesToCopy);
this.audioBufferOffset += samplesToCopy;
maxLength -= samplesToCopy;
samplesCopied += samplesToCopy;
bytesCopied += bytesToCopy;
}
};
copyBuffer();
while (maxLength > 0)
{
if (FLAC__stream_decoder_get_state(this.handle) == FlacDecoderState.EndOfStream)
{
break;
}
if (!FLAC__stream_decoder_process_single(this.handle))
{
throw new FlacException("Error processing frame.");
}
copyBuffer();
}
return samplesCopied;
}
public unsafe int Read(AudioBuffer buff, int maxLength)
{
if (_toc == null)
throw new ReadCDException("Read: invalid TOC");
buff.Prepare(this, maxLength);
if (Position >= Length)
return 0;
if (_sampleOffset >= Length)
{
for (int i = 0; i < buff.ByteLength; i++)
buff.Bytes[i] = 0;
_sampleOffset += buff.Length;
return buff.Length; // == Remaining
}
if (_sampleOffset < 0)
{
buff.Length = Math.Min(buff.Length, -_sampleOffset);
for (int i = 0; i < buff.ByteLength; i++)
buff.Bytes[i] = 0;
_sampleOffset += buff.Length;
return buff.Length;
}
PrefetchSector(/*(int)_toc[_toc.FirstAudio][0].Start +*/ (_sampleOffset / 588));
buff.Length = Math.Min(buff.Length, (int)Length - _sampleOffset);
buff.Length = Math.Min(buff.Length, _currentEnd * 588 - _sampleOffset);
if ((_sampleOffset - _currentStart * 588) == 0 && (maxLength < 0 || (_currentEnd - _currentStart) * 588 <= buff.Length))
{
buff.Swap(currentData);
_currentStart = -1;
_currentEnd = -1;
}
else
fixed (byte* dest = buff.Bytes, src = ¤tData.Bytes[(_sampleOffset - _currentStart * 588) * 4])
AudioSamples.MemCpy(dest, src, buff.ByteLength);
_sampleOffset += buff.Length;
return buff.Length;
}
public void Write(AudioBuffer buff)
{
if (!inited)
{
if (!m_settings.IsValid())
throw new Exception("unsupported encoder settings");
inited = true;
int header_size = flake_encode_init();
_IO.Write(header, 0, header_size);
if (_IO.CanSeek)
first_frame_offset = _IO.Position;
}
buff.Prepare(this);
int pos = 0;
while (pos < buff.Length)
{
int block = Math.Min(buff.Length - pos, m_blockSize - samplesInBuffer);
copy_samples(buff.Samples, pos, block);
pos += block;
while (samplesInBuffer >= m_blockSize)
output_frame();
}
if (md5 != null)
md5.Append(buff.Bytes.AsBuffer(0, buff.ByteLength));
}
public void Write(AudioBuffer buffer)
{
if (this.closed)
{
throw new InvalidOperationException("Writer already closed.");
}
buffer.Prepare(this);
this.EnsureInitialized();
this.EnsureOutputBufferSize(buffer.Length * 5 / 4 + 7200);
byte[] bytes = buffer.Bytes;
int result;
unsafe
{
fixed (byte* bytesPtr = bytes)
{
fixed (byte* outputBufferPtr = this.outputBuffer)
{
result = lame_encode_buffer_interleaved(handle, (IntPtr)bytesPtr, buffer.Length, (IntPtr)outputBufferPtr, outputBuffer.Length);
}
}
}
if (result < 0)
{
switch (result)
{
case -1:
throw new LameException("Output buffer is too small");
case -2:
throw new LameException("malloc problem");
case -3:
throw new LameException("lame_init_params was not called");
case -4:
throw new LameException("Psycho acoustic problems");
default:
throw new LameException("Unknown error");
}
}
if (result > 0)
{
this.outputStream.Write(this.outputBuffer, 0, result);
}
}
public int Read(AudioBuffer buff, int maxLength)
{
InitTables();
buff.Prepare(this, maxLength);
int offset = 0;
int sampleCount = buff.Length;
while (_samplesInBuffer < sampleCount)
{
if (_samplesInBuffer > 0)
{
deinterlace(buff.Samples, offset, _samplesInBuffer);
sampleCount -= _samplesInBuffer;
offset += _samplesInBuffer;
_samplesInBuffer = 0;
_samplesBufferOffset = 0;
}
int sampleDuration;
int sampleSize;
if (_iSample >= _sample_byte_size.Length)
{
buff.Length = offset;
return offset;
}
get_sample_info(_iSample, out sampleDuration, out sampleSize);
_IO.Read(_framesBuffer, 0, sampleSize);
decodeFrame(sampleSize);
if (sampleDuration != _samplesInBuffer)
throw new Exception("sample count mismatch");
_samplesInBuffer -= _samplesBufferOffset;
_sampleOffset += _samplesInBuffer;
_iSample++;
}
deinterlace(buff.Samples, offset, sampleCount);
_samplesInBuffer -= sampleCount;
_samplesBufferOffset += sampleCount;
if (_samplesInBuffer == 0)
_samplesBufferOffset = 0;
return offset + sampleCount;
}
public int Read(AudioBuffer buff, int maxLength)
{
buff.Prepare(this, maxLength);
int buffOffs = 0;
while (buffOffs < buff.ByteLength)
{
if (tempOffs == temp.Length)
{
rnd.NextBytes(temp);
tempOffs = 0;
}
int chunk = Math.Min(buff.ByteLength - buffOffs, temp.Length - tempOffs);
Array.Copy(temp, tempOffs, buff.Bytes, buffOffs, chunk);
buffOffs += chunk;
tempOffs += chunk;
}
while (this.nextError < this.errors.Length && this.errors[this.nextError] < _sampleOffset + buff.Length)
{
for (int i = 0; i < PCM.BlockAlign; i++)
buff.Bytes[(this.errors[this.nextError] - _sampleOffset) * PCM.BlockAlign + i] ^= (byte)this.rnd2.Next(1, 255);
this.nextError++;
}
_sampleOffset += buff.Length;
return buff.Length;
}
public void Write(AudioBuffer buffer)
{
if (this.closed)
{
throw new InvalidOperationException("Writer already closed.");
}
buffer.Prepare(this);
this.EnsureInitialized();
if (!FLAC__stream_encoder_process_interleaved(this.handle, buffer.Samples, buffer.Length))
{
throw new FlacException("Error processing data");
}
}
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;
}
public void Write(AudioBuffer buff)
{
if (!inited)
{
if (!_pathGiven && sample_count <= 0)
throw new NotSupportedException("input and output are both pipes");
if (_IO == null)
_IO = new FileStream(_path, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
if (_IO != null && !_IO.CanSeek)
throw new NotSupportedException("stream doesn't support seeking");
encode_init();
inited = true;
}
buff.Prepare(this);
int pos = 0;
int len = buff.Length;
while (len > 0)
{
int block = Math.Min(len, eparams.block_size - samplesInBuffer);
copy_samples(buff.Samples, pos, block);
len -= block;
pos += block;
while (samplesInBuffer >= eparams.block_size)
output_frame(eparams.block_size);
}
}
public unsafe void Write(AudioBuffer buff)
{
InitTasks();
buff.Prepare(this);
int pos = 0;
while (pos < buff.Length)
{
int block = Math.Min(buff.Length - pos, eparams.block_size * framesPerTask - samplesInBuffer);
fixed (byte* buf = buff.Bytes)
AudioSamples.MemCpy(((byte*)task1.clSamplesBytesPtr) + samplesInBuffer * _pcm.BlockAlign, buf + pos * _pcm.BlockAlign, block * _pcm.BlockAlign);
samplesInBuffer += block;
pos += block;
int nFrames = samplesInBuffer / eparams.block_size;
if (nFrames >= framesPerTask)
do_output_frames(nFrames);
}
if (md5 != null)
md5.TransformBlock(buff.Bytes, 0, buff.ByteLength, null, 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 unsafe void Write(AudioBuffer sampleBuffer)
{
sampleBuffer.Prepare(this);
int pos = 0;
fixed (uint* t = Crc32.table)
fixed (ushort* pte = encodeTable)
fixed (byte* pSampleBuff = &sampleBuffer.Bytes[0], bpar = parity)
while (pos < sampleBuffer.Length)
{
// Process no more than there is in the buffer, no more than there is in this track, and no more than up to a sector boundary.
int copyCount = Math.Min(Math.Min(sampleBuffer.Length - pos, (int)_samplesRemTrack), 588 - (int)_sampleCount % 588);
uint* samples = ((uint*)pSampleBuff) + pos;
int currentSample = (int)_sampleCount - 588 * (int)this.TOC.Pregap;
int currentPart = currentSample < 0 ? 0 : (currentSample * 2) % stride;
//ushort* synptr = synptr1 + npar * currentPart;
ushort* wr = ((ushort*)bpar) + maxNpar * currentPart;
for (int i = Math.Max(0, - currentSample * 2); i < Math.Min(leadin.Length - currentSample * 2, copyCount * 2); i++)
leadin[currentSample * 2 + i] = ((ushort*)samples)[i];
for (int i = Math.Max(0, (int)(_finalSampleCount - _sampleCount) * 2 - leadout.Length); i < copyCount * 2; i++)
{
int remaining = (int)(_finalSampleCount - _sampleCount) * 2 - i - 1;
leadout[remaining] = ((ushort*)samples)[i];
}
int offset = _samplesDoneTrack < maxOffset ? _samplesDoneTrack
: _samplesRemTrack <= maxOffset ? 2 * maxOffset - _samplesRemTrack
: _samplesDoneTrack >= 445 * 588 && _samplesDoneTrack <= 455 * 588 ? 2 * maxOffset + 1 + _samplesDoneTrack - 445 * 588
: -1;
CalculateCRCs(t, wr, pte, samples, copyCount, offset);
// duplicate prefix to suffix
if (_samplesDoneTrack < maxOffset && _samplesRemTrack <= maxOffset)
{
Array.Copy(_CRC32, _currentTrack * 3 * maxOffset + _samplesDoneTrack,
_CRC32, _currentTrack * 3 * maxOffset + 2 * maxOffset - _samplesRemTrack,
copyCount);
Array.Copy(_CRCWN, _currentTrack * 3 * maxOffset + _samplesDoneTrack,
_CRCWN, _currentTrack * 3 * maxOffset + 2 * maxOffset - _samplesRemTrack,
copyCount);
Array.Copy(_CRCNL, _currentTrack * 3 * maxOffset + _samplesDoneTrack,
_CRCNL, _currentTrack * 3 * maxOffset + 2 * maxOffset - _samplesRemTrack,
copyCount);
}
// duplicate prefix to pregap
if (_sampleCount < maxOffset && _currentTrack == 1)
{
Array.Copy(_CRC32, _currentTrack * 3 * maxOffset + _samplesDoneTrack,
_CRC32, _sampleCount,
copyCount);
Array.Copy(_CRCWN, _currentTrack * 3 * maxOffset + _samplesDoneTrack,
_CRCWN, _sampleCount,
copyCount);
Array.Copy(_CRCNL, _currentTrack * 3 * maxOffset + _samplesDoneTrack,
_CRCNL, _sampleCount,
copyCount);
}
pos += copyCount;
_samplesRemTrack -= copyCount;
_samplesDoneTrack += copyCount;
_sampleCount += copyCount;
while (_samplesRemTrack <= 0)
{
if (++_currentTrack > _toc.AudioTracks)
return;
_samplesRemTrack = (int)_toc[_currentTrack + _toc.FirstAudio - 1].Length * 588;
_samplesDoneTrack = 0;
}
}
}
new public unsafe void Write(AudioBuffer sampleBuffer)
{
if (!verify && !encode)
return;
sampleBuffer.Prepare(this);
if ((sampleBuffer.ByteLength & 1) != 0 || sampleCount + sampleBuffer.Length > finalSampleCount)
throw new Exception("sampleCount > finalSampleCount");
fixed (byte* bytes = sampleBuffer.Bytes)
{
int offs = 0;
while (offs < sampleBuffer.Length)
{
int currentPart = (sampleCount * 2) % stride;
int currentStride = (sampleCount * 2) / stride;
// Process no more than there is in the buffer, and no more than up to a stride boundary.
int copyCount = Math.Min((sampleBuffer.Length - offs) * 2, stride - currentPart);
ushort* data = ((ushort*)bytes) + offs * 2;
if (currentStride < 2)
for (int pos = 0; pos < copyCount; pos++)
leadin[sampleCount * 2 + pos] = data[pos];
if (currentStride >= stridecount)
for (int pos = 0; pos < copyCount; pos++)
{
int remaining = (finalSampleCount - sampleCount) * 2 - pos - 1;
if (remaining < stride + laststride)
leadout[remaining] = data[pos];
}
if (currentStride >= 1 && currentStride <= stridecount)
{
if (npar == 16)
ProcessStride16(currentStride, currentPart, copyCount, data);
else if (npar != 8)
ProcessStride(currentStride, currentPart, copyCount, data);
}
sampleCount += copyCount >> 1;
offs += copyCount >> 1;
}
}
}
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;
}
new public unsafe void Write(AudioBuffer sampleBuffer)
{
sampleBuffer.Prepare(this);
if ((sampleBuffer.ByteLength & 1) != 0)
throw new Exception("never happens");
int firstPos = Math.Max(0, stride - sampleCount * 2 - ActualOffset * 2);
int lastPos = Math.Min(sampleBuffer.ByteLength >> 1, (finalSampleCount - sampleCount) * 2 - laststride - ActualOffset * 2);
SortErrors();
fixed (byte* bytes = sampleBuffer.Bytes)
fixed (uint* t = Crc32.table)
{
ushort* data = (ushort*)bytes;
for (int pos = firstPos; pos < lastPos; pos++)
{
if (sampleCount * 2 + pos == erroffsorted[nexterroff] && nexterroff < erroffsorted.Length)
data[pos] ^= forneysorted[nexterroff++];
ushort dd = data[pos];
crc = (crc >> 8) ^ t[(byte)(crc ^ dd)];
crc = (crc >> 8) ^ t[(byte)(crc ^ (dd >> 8))];
}
}
sampleCount += sampleBuffer.Length;
}
public void Write(AudioBuffer buffer)
{
if (this.closed)
{
throw new InvalidOperationException("Writer already closed.");
}
buffer.Prepare(this);
if (buffer.PCM.BitsPerSample != 16)
{
if (buffer.PCM.BitsPerSample == 24)
{
AudioBuffer newBuffer = new AudioBuffer(new AudioPCMConfig(16, buffer.PCM.ChannelCount, buffer.PCM.SampleRate), buffer.Size);
newBuffer.Length = buffer.Length;
int length0 = buffer.Samples.GetLength(0);
int length1 = buffer.Samples.GetLength(1);
for (int i = 0; i < length0; ++i)
{
for (int j = 0; j < length1; ++j)
{
newBuffer.Samples[i, j] = buffer.Samples[i, j] >> 8;
}
}
buffer = newBuffer;
}
else
{
throw new NotSupportedException("Unsupported bit depth");
}
}
this.EnsureInitialized();
this.EnsureOutputBufferSize(buffer.Length * 5 / 4 + 7200);
byte[] bytes = buffer.Bytes;
int result;
unsafe
{
fixed (byte* bytesPtr = bytes)
{
fixed (byte* outputBufferPtr = this.outputBuffer)
{
result = lame_encode_buffer_interleaved(handle, (IntPtr)bytesPtr, buffer.Length, (IntPtr)outputBufferPtr, outputBuffer.Length);
}
}
}
if (result < 0)
{
switch (result)
{
case -1:
throw new LameException("Output buffer is too small");
case -2:
throw new LameException("malloc problem");
case -3:
throw new LameException("lame_init_params was not called");
case -4:
throw new LameException("Psycho acoustic problems");
default:
throw new LameException("Unknown error");
}
}
if (result > 0)
{
this.outputStream.Write(this.outputBuffer, 0, result);
}
}
public void Write(AudioBuffer buff)
{
if (!inited)
{
if (_IO == null)
_IO = new FileStream(_path, FileMode.Create, FileAccess.Write, FileShare.Read);
int header_size = flake_encode_init();
_IO.Write(header, 0, header_size);
if (_IO.CanSeek)
first_frame_offset = _IO.Position;
inited = true;
}
buff.Prepare(this);
int pos = 0;
while (pos < buff.Length)
{
int block = Math.Min(buff.Length - pos, eparams.block_size - samplesInBuffer);
copy_samples(buff.Samples, pos, block);
pos += block;
while (samplesInBuffer >= eparams.block_size)
output_frame();
}
if (md5 != null)
md5.TransformBlock(buff.Bytes, 0, buff.ByteLength, null, 0);
}
public void Write(AudioBuffer buffer)
{
if (this.closed)
{
throw new InvalidOperationException("Writer already closed.");
}
buffer.Prepare(this);
this.EnsureInitialized();
this.networkStream.Write((int)NetworkMessageType.DataMessage);
this.networkStream.Write(buffer.ByteLength);
this.networkStream.Write(buffer.Bytes, 0, buffer.ByteLength);
}
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;
}
public void CDRepairFixWithOffsetTest()
{
Assert.IsTrue(fix2.HasErrors);
Assert.IsTrue(fix2.CanRecover);
Assert.AreEqual(-offset, fix2.ActualOffset, "wrong offset");
AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
buff.Prepare(new byte[offset * 4], offset);
fix2.Write(buff);
buff.Prepare(wav2, finalSampleCount - offset);
fix2.Write(buff);
fix2.Close();
Assert.AreEqual<uint>(crc, fix2.CRC);
}
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)
{
buff.Prepare(this, maxLength);
while (_samplePos >= nextPos)
{
currentSource++;
if (currentSource >= cueSheet._sources.Count)
{
buff.Length = 0;
return 0;
}
if (currentAudio != null)
currentAudio.Close();
currentAudio = cueSheet.GetAudioSource(currentSource, false);
int offset = (int)(_samplePos - nextPos);
if (offset != 0)
currentAudio.Position += offset;
nextPos += cueSheet._sources[currentSource].Length;
}
int count = (int)(nextPos - _samplePos);
if (maxLength >= 0)
count = Math.Min(count, maxLength);
count = currentAudio.Read(buff, count);
_samplePos += count;
return count;
}