public void Close()
{
bool needTag = !closed && _path != null && _path != "";
DeInit(true);
if (needTag)
{
bool utf8Required = Encoding.Default.GetString(Encoding.Default.GetBytes(_path)) != _path;
var tempDir = System.IO.Path.Combine(System.IO.Path.GetPathRoot(_path), "Temp");
var tempName = utf8Required ? System.IO.Path.Combine(tempDir, Guid.NewGuid().ToString()) : _path;
try
{
if (utf8Required && !Directory.Exists(tempDir))
{
Directory.CreateDirectory(tempDir);
}
if (utf8Required)
{
File.Move(_path, tempName);
}
Lame_encDll.beWriteInfoTag(m_hLameStream, tempName);
if (utf8Required)
{
File.Move(tempName, _path);
}
}
catch
{
if (utf8Required)
{
File.Move(tempName, _path);
}
}
}
}
private void Init()
{
if (inited)
{
return;
}
m_Mp3Config = MakeConfig();
uint LameResult = Lame_encDll.beInitStream(m_Mp3Config, ref m_InputSamples, ref m_OutBufferSize, ref m_hLameStream);
if (LameResult != Lame_encDll.BE_ERR_SUCCESSFUL)
{
throw new ApplicationException(string.Format("Lame_encDll.beInitStream failed with the error code {0}", LameResult));
}
m_InBuffer = new byte[m_InputSamples * 2]; //Input buffer is expected as short[]
m_OutBuffer = new byte[Math.Max(65536, m_OutBufferSize)];
if (_IO == null)
{
_IO = new FileStream(_path, FileMode.Create, FileAccess.Write, FileShare.Read);
}
inited = true;
}
public override void Close()
{
if (!closed)
{
try
{
uint EncodedSize = 0;
if (m_InBufferPos > 0)
{
if (Lame_encDll.EncodeChunk(m_hLameStream, m_InBuffer, 0, (uint)m_InBufferPos, m_OutBuffer, ref EncodedSize) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
if (EncodedSize > 0)
{
base.Write(m_OutBuffer, 0, (int)EncodedSize);
}
}
}
EncodedSize = 0;
if (Lame_encDll.beDeinitStream(m_hLameStream, m_OutBuffer, ref EncodedSize) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
if (EncodedSize > 0)
{
base.Write(m_OutBuffer, 0, (int)EncodedSize);
}
}
}
finally
{
Lame_encDll.beCloseStream(m_hLameStream);
}
}
closed = true;
base.Close();
}
/// <summary>
/// Send to the compressor an array of bytes.
/// </summary>
/// <param name="buffer">Input buffer</param>
/// <param name="index">Start position</param>
/// <param name="count">Bytes to process. The optimal size, to avoid buffer copy, is a multiple of <see cref="KAVE.mmedia.utils.AudioFileWriter.OptimalBufferSize"/></param>
public override void Write(byte[] buffer, int index, int count)
{
int ToCopy = 0;
uint EncodedSize = 0;
uint LameResult;
while (count > 0)
{
if (m_InBufferPos > 0)
{
ToCopy = Math.Min(count, m_InBuffer.Length - m_InBufferPos);
Buffer.BlockCopy(buffer, index, m_InBuffer, m_InBufferPos, ToCopy);
m_InBufferPos += ToCopy;
index += ToCopy;
count -= ToCopy;
if (m_InBufferPos >= m_InBuffer.Length)
{
m_InBufferPos = 0;
if ((LameResult = Lame_encDll.EncodeChunk(m_hLameStream, m_InBuffer, m_OutBuffer, ref EncodedSize)) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
if (EncodedSize > 0)
{
base.Write(m_OutBuffer, 0, (int)EncodedSize);
}
}
else
{
throw new ApplicationException(string.Format("Lame_encDll.EncodeChunk failed with the error code {0}", LameResult));
}
}
}
else
{
if (count >= m_InBuffer.Length)
{
if ((LameResult = Lame_encDll.EncodeChunk(m_hLameStream, buffer, index, (uint)m_InBuffer.Length, m_OutBuffer, ref EncodedSize)) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
if (EncodedSize > 0)
{
base.Write(m_OutBuffer, 0, (int)EncodedSize);
}
}
else
{
throw new ApplicationException(string.Format("Lame_encDll.EncodeChunk failed with the error code {0}", LameResult));
}
count -= m_InBuffer.Length;
index += m_InBuffer.Length;
}
else
{
Buffer.BlockCopy(buffer, index, m_InBuffer, 0, count);
m_InBufferPos = count;
index += count;
count = 0;
}
}
}
}
private void About_Load(object sender, System.EventArgs e)
{
BE_VERSION ver = new BE_VERSION();
Lame_encDll.beVersion(ver);
labelDllVer.Text = string.Format("{0}.{1}", ver.byDLLMajorVersion, ver.byDLLMinorVersion);
labelEngVer.Text = string.Format("{0}.{1}", ver.byMajorVersion, ver.byMinorVersion);
DateTime date = new DateTime(ver.wYear, ver.byMonth, ver.byDay);
labelDate.Text = date.ToShortDateString();
linkLabel.Text = ver.zHomepage;
linkLabel.LinkArea = new LinkArea(0, linkLabel.Text.Length);
linkLabel.Links[0].LinkData = linkLabel.Text;
}
/// <summary>
/// Create a Mp3Writer with specific MP3 format
/// </summary>
/// <param name="Output">Stream that will hold the MP3 resulting data</param>
/// <param name="InputDataFormat">PCM format of input data</param>
/// <param name="Mp3Config">Desired MP3 config</param>
public Mp3Writer(Stream Output, WaveFormat InputDataFormat, BE_CONFIG Mp3Config)
: base(Output, InputDataFormat)
{
try
{
m_Mp3Config = Mp3Config;
uint LameResult = Lame_encDll.beInitStream(m_Mp3Config, ref m_InputSamples, ref m_OutBufferSize, ref m_hLameStream);
if (LameResult != Lame_encDll.BE_ERR_SUCCESSFUL)
{
throw new ApplicationException(string.Format("Lame_encDll.beInitStream failed with the error code {0}", LameResult));
}
m_InBuffer = new byte[m_InputSamples * 2]; //Input buffer is expected as short[]
m_OutBuffer = new byte[m_OutBufferSize];
}
catch
{
base.Close();
throw;
}
}
public void DeInit(bool flush)
{
if (!inited || closed)
{
return;
}
try
{
if (flush)
{
uint EncodedSize = 0;
if (m_InBufferPos > 0)
{
if (Lame_encDll.EncodeChunk(m_hLameStream, m_InBuffer, 0, (uint)m_InBufferPos, m_OutBuffer, ref EncodedSize) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
if (EncodedSize > 0)
{
_IO.Write(m_OutBuffer, 0, (int)EncodedSize);
bytesWritten += EncodedSize;
}
}
}
EncodedSize = 0;
if (Lame_encDll.beDeinitStream(m_hLameStream, m_OutBuffer, ref EncodedSize) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
if (EncodedSize > 0)
{
_IO.Write(m_OutBuffer, 0, (int)EncodedSize);
bytesWritten += EncodedSize;
}
}
}
}
finally
{
Lame_encDll.beCloseStream(m_hLameStream);
_IO.Close();
closed = true;
}
}
public unsafe void Write(AudioBuffer buff)
{
buff.Prepare(this);
Init();
byte[] buffer = buff.Bytes;
int index = 0;
int count = buff.ByteLength;
int ToCopy = 0;
uint EncodedSize = 0;
uint LameResult;
uint outBufferIndex = 0;
fixed(byte *pBuffer = buffer, pOutBuffer = m_OutBuffer)
{
while (count > 0)
{
if (m_InBufferPos > 0)
{
ToCopy = Math.Min(count, m_InBuffer.Length - m_InBufferPos);
Buffer.BlockCopy(buffer, index, m_InBuffer, m_InBufferPos, ToCopy);
m_InBufferPos += ToCopy;
index += ToCopy;
count -= ToCopy;
if (m_InBufferPos >= m_InBuffer.Length)
{
m_InBufferPos = 0;
if (outBufferIndex > 0)
{
_IO.Write(m_OutBuffer, 0, (int)outBufferIndex);
bytesWritten += outBufferIndex;
outBufferIndex = 0;
}
if ((LameResult = Lame_encDll.EncodeChunk(m_hLameStream, m_InBuffer, m_OutBuffer, ref EncodedSize)) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
outBufferIndex += EncodedSize;
}
else
{
throw new ApplicationException(string.Format("Lame_encDll.EncodeChunk failed with the error code {0}", LameResult));
}
}
}
else
{
if (count >= m_InBuffer.Length)
{
if (outBufferIndex + m_OutBufferSize > m_OutBuffer.Length)
{
_IO.Write(m_OutBuffer, 0, (int)outBufferIndex);
bytesWritten += outBufferIndex;
outBufferIndex = 0;
}
if ((LameResult = Lame_encDll.EncodeChunk(m_hLameStream, pBuffer + index, (uint)m_InBuffer.Length, pOutBuffer + outBufferIndex, ref EncodedSize)) == Lame_encDll.BE_ERR_SUCCESSFUL)
{
outBufferIndex += EncodedSize;
}
else
{
throw new ApplicationException(string.Format("Lame_encDll.EncodeChunk failed with the error code {0}", LameResult));
}
count -= m_InBuffer.Length;
index += m_InBuffer.Length;
}
else
{
Buffer.BlockCopy(buffer, index, m_InBuffer, 0, count);
m_InBufferPos = count;
index += count;
count = 0;
}
}
}
}
if (outBufferIndex > 0)
{
_IO.Write(m_OutBuffer, 0, (int)outBufferIndex);
bytesWritten += outBufferIndex;
}
}
private static void SaveTrack(TrackInfo trackInfo)
{
string targetFileName = trackInfo.MusicTag.Title;
if (m_Drive.Open(trackInfo.Item.Path[0]))
{
char[] Drives = CDDrive.GetCDDriveLetters();
if ((Array.IndexOf(Drives, trackInfo.Item.Path[0]) > -1) && (m_Drive.IsCDReady()) && (m_Drive.Refresh()))
{
try
{
m_Drive.LockCD();
if (dlgProgress.IsCanceled)
{
m_CancelRipping = true;
}
if (!m_CancelRipping)
{
try
{
try
{
WaveFormat Format = new WaveFormat(44100, 16, 2);
BE_CONFIG mp3Config = new BE_CONFIG(Format);
if (mp3VBR)
{
mp3Config.format.lhv1.bEnableVBR = 1;
if (mp3FastMode)
{
mp3Config.format.lhv1.nVbrMethod = VBRMETHOD.VBR_METHOD_NEW;
}
else
{
mp3Config.format.lhv1.nVbrMethod = VBRMETHOD.VBR_METHOD_DEFAULT;
}
mp3Config.format.lhv1.nVBRQuality = mp3Quality;
}
else if (mp3CBR)
{
mp3Config.format.lhv1.bEnableVBR = 0;
mp3Config.format.lhv1.nVbrMethod = VBRMETHOD.VBR_METHOD_NONE;
mp3Config.format.lhv1.dwBitrate = Convert.ToUInt16(Rates[mp3BitRate]);
}
else
{
mp3Config.format.lhv1.bEnableVBR = 1;
mp3Config.format.lhv1.nVbrMethod = VBRMETHOD.VBR_METHOD_ABR;
uint ConToKbwVbrAbr_bps = Convert.ToUInt16(Rates[mp3BitRate]);
mp3Config.format.lhv1.dwVbrAbr_bps = ConToKbwVbrAbr_bps * 1000;
}
if (mp3MONO)
{
mp3Config.format.lhv1.nMode = MpegMode.MONO;
}
mp3Config.format.lhv1.bWriteVBRHeader = 1;
Stream WaveFile = new FileStream(trackInfo.TempFileName, FileMode.Create, FileAccess.Write);
m_Writer = new Mp3Writer(WaveFile, Format, mp3Config);
if (!m_CancelRipping)
{
try
{
Log.Info("CDIMP: Processing track {0}", trackInfo.MusicTag.Track);
DateTime InitTime = DateTime.Now;
if (
m_Drive.ReadTrack(trackInfo.MusicTag.Track, new CdDataReadEventHandler(WriteWaveData),
new CdReadProgressEventHandler(CdReadProgress)) > 0)
{
if (dlgProgress.IsCanceled)
{
m_CancelRipping = true;
}
if (!m_CancelRipping)
{
TimeSpan Duration = DateTime.Now - InitTime;
double Speed = m_Drive.TrackSize(trackInfo.MusicTag.Track) / Duration.TotalSeconds /
Format.nAvgBytesPerSec;
Log.Info("CDIMP: Done reading track {0} at {1:0.00}x speed", trackInfo.MusicTag.Track, Speed);
}
}
else
{
Log.Info("CDIMP: Error reading track {0}", trackInfo.MusicTag.Track);
m_Writer.Close();
WaveFile.Close();
if (File.Exists(trackInfo.TempFileName))
{
try
{
File.Delete(trackInfo.TempFileName);
}
catch {}
}
//progressBar1.Value = 0;
}
}
finally
{
m_Writer.Close();
m_Writer = null;
WaveFile.Close();
Lame_encDll.beWriteVBRHeader(trackInfo.TempFileName);
}
}
}
finally {}
}
finally
{
m_Drive.Close();
}
}
}
finally
{
//progressBar1.Value = 0;
}
}
if (dlgProgress.IsCanceled)
{
m_CancelRipping = true;
}
if (m_CancelRipping)
{
if (File.Exists(trackInfo.TempFileName))
{
File.Delete(trackInfo.TempFileName);
}
m_Drive.Close();
}
}
}
