public static Stream ConvertAiffToMp3(Stream aiffStream, string directory)
{
_uniqueTempFileCounter += 1;
var tempFile = Path.GetTempFileName();
using (var rdr = new AiffFileReader(aiffStream))
{
//can't go from 24 bits aif to mp3 directly, create temporary 16 bit wav
if (rdr.WaveFormat.BitsPerSample == 24)
{
ISampleProvider sampleprovider = new Pcm24BitToSampleProvider(rdr); //24 bit to sample
var resampler = new WdlResamplingSampleProvider(sampleprovider, SampleRate); //sample to new sample rate
WaveFileWriter.CreateWaveFile16(tempFile, resampler); //sample to actual wave file
return(ConvertWavFileToMp3MemoryStream(tempFile, true)); //file to mp3 bytes
}
else
{
var retMs = FilesystemUtils.recyclableMemoryStreamManager.GetStream();
using (var wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, BitRate))
{
rdr.CopyTo(wtr);
return(retMs);
}
}
}
}
private static WaveStream CreateReaderStream(string fileName)
{
WaveStream readerStream = null;
if (fileName.EndsWith(".wav", StringComparison.OrdinalIgnoreCase))
{
readerStream = new WaveFileReader(fileName);
if (readerStream.WaveFormat.Encoding == WaveFormatEncoding.Pcm ||
readerStream.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
return(readerStream);
}
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
else if (fileName.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase))
{
readerStream = new Mp3FileReader(fileName);
}
else if (fileName.EndsWith(".aiff"))
{
readerStream = new AiffFileReader(fileName);
}
return(readerStream);
}
public void Play(string path)
{
Dispose();
_path = path;
if (System.IO.Path.GetExtension(_path) == ".mp3")
{
pcm = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(_path));
blockAlignStream = new BlockAlignReductionStream(pcm);
output.Init(blockAlignStream);
}
else if (System.IO.Path.GetExtension(_path) == ".wav")
{
wavereader = new WaveFileReader(_path);
output.Init(new WaveChannel32(wavereader));
}
else if (System.IO.Path.GetExtension(_path) == ".aif")
{
aiffreader = new AiffFileReader(_path);
output.Init(new WaveChannel32(aiffreader));
}
else
{
audioreader = new AudioFileReader(_path);
output.Init(new WaveChannel32(audioreader));
}
output.Play();
}
public WaveStream GetStream(string path)
{
WaveStream ret = null;
string lp = path.ToLower();
if (lp.EndsWith(".wav"))
{
ret = new WaveFileReader(path);
if (ret.WaveFormat.Encoding != WaveFormatEncoding.Pcm && ret.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
{
ret = WaveFormatConversionStream.CreatePcmStream(ret);
ret = new BlockAlignReductionStream(ret);
}
}
else if (lp.EndsWith(".mp3"))
{
ret = new Mp3FileReader(path);
}
else if (lp.EndsWith(".aiff"))
{
ret = new AiffFileReader(path);
}
else if (lp.EndsWith(".wma"))
{
ret = new NAudio.WindowsMediaFormat.WMAFileReader(path);
}
return(ret);
}
static WaveStream GetWaveStream(string file)
{
WaveChannel32 inputStream = null;
WaveStream reader = null;
WaveStream work = null;
try
{
if (file.EndsWith(".ogg", StringComparison.OrdinalIgnoreCase))
{
work = new NVorbis.NAudioSupport.VorbisWaveReader(file);
//TODO: Switch to memory stream and test.
//work = new NVorbis.NAudioSupport.VorbisWaveReader(
}
else if (file.EndsWith(".aiff", StringComparison.OrdinalIgnoreCase))
{
work = new AiffFileReader(file);
}
else if (file.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase))
{
work = new Mp3FileReader(file);
}
else if (file.EndsWith(".wma", StringComparison.OrdinalIgnoreCase))
{
work = new NAudio.WindowsMediaFormat.WMAFileReader(file);
}
reader = work;
work = null;
}
catch (Exception ex)
{
if (_log.IsWarnEnabled)
{
_log.Warn("Unable to get audio stream", ex);
}
}
finally
{
if (work != null)
{
work.Dispose();
}
}
try
{
if (reader != null)
{
inputStream = new WaveChannel32(reader);
}
}
catch (Exception ex)
{
if (_log.IsWarnEnabled)
{
_log.Warn("Error trying to set up inputStream", ex);
}
}
return(inputStream);
}
private void showAiffHeader(AiffFileReader aiffFileReader, OpenFileDialog ofd)
{
listView.Clear();
Dictionary <string, string> locationData = new Dictionary <string, string>();
Dictionary <string, string> generalData = new Dictionary <string, string>();
ColumnHeader columnHeaderName = new ColumnHeader();
columnHeaderName.Text = "Name";
columnHeaderName.Width = 100;
ColumnHeader columnHeaderValue = new ColumnHeader();
columnHeaderValue.Text = "Value";
columnHeaderValue.Width = 300;
listView.Columns.AddRange(new ColumnHeader[] { columnHeaderName, columnHeaderValue });
ListViewGroup listViewGroupLocation = new ListViewGroup("Location");
ListViewGroup listViewGroupGeneral = new ListViewGroup("General");
listView.Groups.Add(listViewGroupLocation);
listView.Groups.Add(listViewGroupGeneral);
//locationData
locationData.Add("File name", ofd.SafeFileName);
locationData.Add("Folder name", ofd.FileName);
locationData.Add("File size", aiffFileReader.Length + " (bytes)");
locationData.Add("Last modified", File.GetLastWriteTime(ofd.FileName).ToString());
locationData.Add("Created", File.GetCreationTime(ofd.FileName).ToString());
foreach (var item in locationData)
{
ListViewItem listViewItem = new ListViewItem(item.Key, listViewGroupLocation);
listViewItem.SubItems.Add(item.Value);
listView.Items.Add(listViewItem);
}
//generalData
generalData.Add("Duration", aiffFileReader.TotalTime.ToString());
generalData.Add("Sample Rate", aiffFileReader.WaveFormat.SampleRate.ToString() + " Hz");
generalData.Add("Channels", aiffFileReader.WaveFormat.Channels.ToString());
generalData.Add("Bits per sample", aiffFileReader.WaveFormat.BitsPerSample.ToString());
generalData.Add("Average bytes per second", aiffFileReader.WaveFormat.AverageBytesPerSecond.ToString());
generalData.Add("Block Align", aiffFileReader.WaveFormat.BlockAlign.ToString());
foreach (var item in generalData)
{
ListViewItem listViewItem = new ListViewItem(item.Key, listViewGroupGeneral);
listViewItem.SubItems.Add(item.Value);
listView.Items.Add(listViewItem);
}
}
public AiffInput(Stream file) : base(file)
{
m_reader = new AiffFileReader(file);
var format = new GameRes.WaveFormat {
FormatTag = (ushort)m_reader.WaveFormat.Encoding,
Channels = (ushort)m_reader.WaveFormat.Channels,
SamplesPerSecond = (uint)m_reader.WaveFormat.SampleRate,
BitsPerSample = (ushort)m_reader.WaveFormat.BitsPerSample,
BlockAlign = (ushort)m_reader.BlockAlign,
AverageBytesPerSecond = (uint)m_reader.WaveFormat.AverageBytesPerSecond,
};
this.Format = format;
this.PcmSize = m_reader.Length;
}
private static void ConvertAiffToWav(string aiffFile, string wavFile)
{
using (AiffFileReader reader = new AiffFileReader(aiffFile))
{
using (WaveFileWriter writer = new WaveFileWriter(wavFile, reader.WaveFormat))
{
byte[] buffer = new byte[4096];
int bytesRead = 0;
do
{
bytesRead = reader.Read(buffer, 0, buffer.Length);
writer.Write(buffer, 0, bytesRead);
} while (bytesRead > 0);
}
}
}
private void openAudioFile()
{
using (ofd = new OpenFileDialog()
{
Filter = "All files|*.*|WAV|*.wav|AIFF|*.aiff"
})
{
if (ofd.ShowDialog() == DialogResult.OK)
{
inputAudioFile = ofd.FileName;
fileStreamInput = new FileStream(inputAudioFile, FileMode.Open, FileAccess.Read);
string[] safeAudioFileName = ofd.SafeFileName.Split(new char[] { '.' });
switch (safeAudioFileName[safeAudioFileName.Length - 1])
{
case "wav":
currentAudioFormat = "wav";
WaveFileReader waveFileReader = new WaveFileReader(fileStreamInput);
showWavHeader(waveFileReader, ofd);
convertToolStripMenuItem.Enabled = comboBoxFormats.Enabled = buttonConvert.Enabled = true;
comboBoxFormats.SelectedIndex = 0;
printAudioWave();
break;
case "aiff":
currentAudioFormat = "aiff";
AiffFileReader aiffFileReader = new AiffFileReader(fileStreamInput);
showAiffHeader(aiffFileReader, ofd);
convertToolStripMenuItem.Enabled = comboBoxFormats.Enabled = buttonConvert.Enabled = true;
comboBoxFormats.SelectedIndex = 0;
printAudioWave();
break;
default:
currentAudioFormat = null;
break;
}
}
}
}
public static bool ConvertAiffToMp3(byte[] aiffFile, string directory, out byte[] mp3Bytes)
{
mp3Bytes = null;
try
{
_uniqueTempFileCounter += 1;
var tempFile = Path.Combine(directory, "tempdata" + _uniqueTempFileCounter + ".wav");
using (var ms = new MemoryStream(aiffFile))
using (var rdr = new AiffFileReader(ms))
{
if (rdr.WaveFormat.BitsPerSample == 24)
//can't go from 24 bits aif to mp3 directly, create temporary 16 bit wav
{
ISampleProvider sampleprovider = new Pcm24BitToSampleProvider(rdr); //24 bit to sample
var resampler = new WdlResamplingSampleProvider(sampleprovider, SampleRate);
//sample to new sample rate
WaveFileWriter.CreateWaveFile16(tempFile, resampler); //sample to actual wave file
mp3Bytes = ConvertWavToMp3(tempFile, true); //file to mp3 bytes
}
else
{
using (var retMs = new MemoryStream())
using (var wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, BitRate))
{
rdr.CopyTo(wtr);
mp3Bytes = retMs.ToArray();
}
}
}
return(true);
}
catch (Exception)
{
// ignored
}
return(false);
}
public static byte[] Aiff_to_wav(string fil_n, byte ch, out byte[] mono)
{
byte[] mono2 = null;
Task a = Task.Run(() =>
{
WaveFormat format = new WaveFormat(48000, 16, 1);
try
{
using (AiffFileReader reader = new AiffFileReader(fil_n))
{
using (WaveFormatConversionStream stream = new WaveFormatConversionStream(format, reader))
{
mono2 = new byte[stream.Length];
stream.Read(mono2, 0, mono2.Length);
}
}
}
catch (Exception) { }
});
byte[] buffer = null;
try
{
WaveFormat format = new WaveFormat(48000, 16, ch);
using (AiffFileReader reader = new AiffFileReader(fil_n))
{
using (WaveFormatConversionStream stream = new WaveFormatConversionStream(format, reader))
{
buffer = new byte[stream.Length];
stream.Read(buffer, 0, buffer.Length);
}
}
}
catch (Exception) { }
a.Wait();
mono = mono2;
return(buffer);
}
private static WaveStream ReaderForAudioFormat
(
Stream fileInputStream,
AudioFormat audioFormat,
int?maxSeconds,
out int seconds
)
{
WaveStream readerStream;
switch (audioFormat)
{
case AudioFormat.Mp3:
readerStream = new Mp3FileReader(fileInputStream);
break;
case AudioFormat.Wave:
readerStream = new WaveFileReader(fileInputStream);
break;
case AudioFormat.Aiff:
readerStream = new AiffFileReader(fileInputStream);
break;
case AudioFormat.Flac:
readerStream = new FlacReader(fileInputStream);
break;
case AudioFormat.OggVorbis:
readerStream = new VorbisWaveReader(fileInputStream);
break;
case AudioFormat.Other:
default:
var tempPath = Path.GetTempFileName();
AppDomain.CurrentDomain.ProcessExit += (o, e) =>
{
File.Delete(tempPath);
};
var tempFileStream = File.OpenWrite(tempPath);
fileInputStream.CopyTo(tempFileStream);
tempFileStream.Close();
Console.Error.WriteLine($"Creating MediaFoundationReader with file = {tempPath}");
readerStream = new MediaFoundationReader(tempPath);
break;
}
if (maxSeconds.HasValue)
{
readerStream = new CapSecondsByAverageStream(readerStream, maxSeconds.Value);
seconds = Math.Min(maxSeconds.Value,
(int)(readerStream.Length / readerStream.WaveFormat.AverageBytesPerSecond));
}
else
{
seconds = (int)(readerStream.Length / readerStream.WaveFormat.AverageBytesPerSecond);
}
readerStream = NormalizeWaveFormat(readerStream);
return(readerStream);
}
/// <summary>
/// Creates an input WaveChannel (Audio file reader for MP3/WAV/OGG/FLAC/WMA/AIFF/Other formats in the future)
/// </summary>
/// <param name="filename"></param>
private void CreateInputWaveChannel(string filename)
{
string fileExt = Path.GetExtension(filename.ToLower());
if (fileExt == MP3Extension)
{
m_waveReader = new Mp3FileReader(filename);
m_blockAlignedStream = new BlockAlignReductionStream(m_waveReader);
// Wave channel - reads from file and returns raw wave blocks
m_waveChannel = new WaveChannel32(m_blockAlignedStream);
}
else if (fileExt == WAVExtension)
{
m_waveReader = new WaveFileReader(filename);
if (m_waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
m_waveReader = WaveFormatConversionStream.CreatePcmStream(m_waveReader);
m_waveReader = new BlockAlignReductionStream(m_waveReader);
}
if (m_waveReader.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(m_waveReader.WaveFormat.SampleRate,
16, m_waveReader.WaveFormat.Channels);
m_waveReader = new WaveFormatConversionStream(format, m_waveReader);
}
m_waveChannel = new WaveChannel32(m_waveReader);
}
else if (fileExt == OGGVExtension)
{
m_waveReader = new OggVorbisFileReader(filename);
if (m_waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
m_waveReader = WaveFormatConversionStream.CreatePcmStream(m_waveReader);
m_waveReader = new BlockAlignReductionStream(m_waveReader);
}
if (m_waveReader.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(m_waveReader.WaveFormat.SampleRate,
16, m_waveReader.WaveFormat.Channels);
m_waveReader = new WaveFormatConversionStream(format, m_waveReader);
}
m_waveChannel = new WaveChannel32(m_waveReader);
}
else if (fileExt == FLACExtension)
{
m_waveReader = new FLACFileReader(filename);
if (m_waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
m_waveReader = WaveFormatConversionStream.CreatePcmStream(m_waveReader);
m_waveReader = new BlockAlignReductionStream(m_waveReader);
}
if (m_waveReader.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(m_waveReader.WaveFormat.SampleRate,
16, m_waveReader.WaveFormat.Channels);
m_waveReader = new WaveFormatConversionStream(format, m_waveReader);
}
m_waveChannel = new WaveChannel32(m_waveReader);
}
else if (fileExt == WMAExtension)
{
m_waveReader = new WMAFileReader(filename);
if (m_waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
m_waveReader = WaveFormatConversionStream.CreatePcmStream(m_waveReader);
m_waveReader = new BlockAlignReductionStream(m_waveReader);
}
if (m_waveReader.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(m_waveReader.WaveFormat.SampleRate,
16, m_waveReader.WaveFormat.Channels);
m_waveReader = new WaveFormatConversionStream(format, m_waveReader);
}
m_waveChannel = new WaveChannel32(m_waveReader);
}
else if (fileExt == AIFFExtension)
{
m_waveReader = new AiffFileReader(filename);
m_waveChannel = new WaveChannel32(m_waveReader);
}
else
{
throw new ApplicationException("Cannot create Input WaveChannel - Unknown file type: " + fileExt);
}
}
private void printAudioWave()
{
BinaryReader binRead = null;
uint dataSize = 0;
int numSamples = 0;
Point[] points = new Point[pictureBox.Width];
int coefForWidth = 0;
int coeffForHeight = 0;
Pen penCountur = new Pen(Color.Black, 2);
SolidBrush drawBrush = new SolidBrush(Color.Black);
StringFormat drawFormat = new StringFormat();
Graphics graphicMain = pictureBox.CreateGraphics();
switch (currentAudioFormat)
{
case "wav":
Cursor.Current = Cursors.WaitCursor;
fileStreamInput.Read(new byte[4], 0, 4);
binRead = new BinaryReader(fileStreamInput);
dataSize = (uint)(fileStreamInput.Length / 4);
audioData = new Int16[dataSize];
fileStreamInput.Seek(40, System.IO.SeekOrigin.Begin);
numSamples = (int)(dataSize / 1);
for (int i = 0; i < numSamples; i++)
{
audioData[i] = binRead.ReadInt16();
}
coefForWidth = (int)(audioData.Length / (pictureBox.Width));
coeffForHeight = (int)(65536 / (pictureBox.Height - 40));
for (int i = 0; i < pictureBox.Width; i++)
{
points[i] = new Point(i, (int)((audioData[i * coefForWidth] / coeffForHeight) + (pictureBox.Height / 2)));
}
graphicMain.Clear(Color.White);
graphicMain.DrawLines(penCountur, points);
Cursor.Current = Cursors.Default;
break;
case "aiff":
Cursor.Current = Cursors.WaitCursor;
string tempFileName = Path.Combine(Environment.CurrentDirectory, "temp.wav");
using (AiffFileReader reader = new AiffFileReader(inputAudioFile))
{
using (WaveFileWriter writer = new WaveFileWriter(tempFileName, reader.WaveFormat))
{
byte[] buffer = new byte[4096];
int bytesRead = 0;
do
{
bytesRead = reader.Read(buffer, 0, buffer.Length);
writer.Write(buffer, 0, bytesRead);
} while (bytesRead > 0);
}
}
FileStream tempFileStreamInput = new FileStream(tempFileName, FileMode.Open, FileAccess.Read);
tempFileStreamInput.Read(new byte[4], 0, 4);
binRead = new BinaryReader(tempFileStreamInput);
dataSize = (uint)(tempFileStreamInput.Length / 4);
audioData = new Int16[dataSize];
tempFileStreamInput.Seek(40, System.IO.SeekOrigin.Begin);
numSamples = (int)(dataSize / 1);
for (int i = 0; i < numSamples; i++)
{
audioData[i] = binRead.ReadInt16();
}
tempFileStreamInput.Close();
File.Delete(tempFileName);
coefForWidth = (int)(audioData.Length / (pictureBox.Width));
coeffForHeight = (int)(65536 / (pictureBox.Height - 40));
for (int i = 0; i < pictureBox.Width; i++)
{
points[i] = new Point(i, (int)((audioData[i * coefForWidth] / coeffForHeight) + (pictureBox.Height / 2)));
}
graphicMain.Clear(Color.White);
graphicMain.DrawLines(penCountur, points);
Cursor.Current = Cursors.Default;
break;
default:
break;
}
}
public void CreateCurrentSongImage(AudioFile audioFile)
{
try
{
int bytesPerSample = 0;
WaveStream reader;
switch (audioFile.Format.ToLower())
{
case ".mp3":
reader = new Mp3FileReader(audioFile.Path);
break;
case ".wav":
reader = new WaveFileReader(audioFile.Path);
break;
case ".aiff":
reader = new AiffFileReader(audioFile.Path);
break;
default:
reader = new AudioFileReader(audioFile.Path);
break;
}
using (NAudio.Wave.WaveChannel32 channelStream = new NAudio.Wave.WaveChannel32(reader))
{
//initialize the progress bar, once the audio stream has been created
_progBar.Maximum = (int)reader.TotalTime.TotalMilliseconds / _visEventTimer.Interval;
bytesPerSample = (reader.WaveFormat.BitsPerSample / 8) * channelStream.WaveFormat.Channels;
//Give a size to the bitmap; either a fixed size, or something based on the length of the audio
using (Bitmap bitmap = new Bitmap((int)Math.Round(reader.TotalTime.TotalSeconds * 80), 300))
{
int width = bitmap.Width;
int height = bitmap.Height;
using (Graphics graphics = Graphics.FromImage(bitmap))
{
graphics.Clear(Color.White);
Pen bluePen = new Pen(Color.Blue);
int samplesPerPixel = (int)(reader.Length / (double)(width * bytesPerSample));
int bytesPerPixel = bytesPerSample * samplesPerPixel;
int bytesRead;
byte[] waveData = new byte[bytesPerPixel];
for (float x = 0; x < width; x++)
{
bytesRead = reader.Read(waveData, 0, bytesPerPixel);
if (bytesRead == 0)
{
break;
}
short low = 0;
short high = 0;
for (int n = 0; n < bytesRead; n += 2)
{
short sample = BitConverter.ToInt16(waveData, n);
if (sample < low)
{
low = sample;
}
if (sample > high)
{
high = sample;
}
}
float lowPercent = ((((float)low) - short.MinValue) / ushort.MaxValue);
float highPercent = ((((float)high) - short.MinValue) / ushort.MaxValue);
float lowValue = height * lowPercent;
float highValue = height * highPercent;
graphics.DrawLine(bluePen, x, lowValue, x, highValue);
}
}
_currentSongImage = new System.Drawing.Bitmap(bitmap);
bitmap.Dispose();
}
}
reader.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public AIFFMemorySoundFX(AiffFileReader reader) : base(reader)
{
}
