/// <summary>
/// Loads the specified sound file.
/// </summary>
/// <param name="filename">Filename of a 44khz 16-bit wav sample.</param>
/// <returns>-1 on error, bufferId on success.</returns>
public override int Load(string filename)
{
#if DEBUG
if (!NativeAssetManager.Instance.FileExists(filename))
{
return(-1);
}
#endif
int buffer = AL.GenBuffer();
using (Stream str = NativeAssetManager.Instance.GetFileStream(filename))
using (WaveReader sound = new WaveReader(str))
{
SoundData s = sound.ReadToEnd();
AL.BufferData(buffer, s.SoundFormat.SampleFormatAsOpenALFormat, s.Data, s.Data.Length, s.SoundFormat.SampleRate);
}
if (AL.GetError() != ALError.NoError)
{
return(-1);
}
return(buffer);
}
public WaveFormView(Stream waveForm)
{
if (waveForm == null)
{
throw new ArgumentNullException(nameof(WaveForm));
}
this._Stream = waveForm;
this._Reader = new WaveReader(waveForm);
this._Format = this._Reader.Format;
this.ReadPointsFromWaveForm();
InitializeComponent();
this.panelWaveForm.Paint += new PaintEventHandler(panelWaveForm_Paint);
this.MouseWheel += (o, e) =>
{
var d = e.Delta / 120.0;
this.ZoomFactor *= d switch
{
< 0 => 1.0 / (d * 10),
> 0 => d * 10,
_ => 1.0
};
};
static void Main(string[] args)
{
if (args.Length != 1)
{
System.Console.WriteLine("Usage: KCS_Decoder <full filename>");
System.Environment.Exit(-1);
}
WaveReader waveReader = new WaveReader();
if (!waveReader.readWaveFileFirst20Minutes(args[0]))
{
System.Console.WriteLine("Could not read 'wav' file: " + args[0]);
System.Environment.Exit(-1);
}
Decoder decoder = new Decoder(waveReader.sampleRate, waveReader.numChannels, waveReader.channelData);
if (decoder.analyzeFile())
{
System.Console.WriteLine("session: " + decoder.getSession());
System.Console.WriteLine("date/time: " + decoder.getDateTime());
System.Console.WriteLine("for start time, subtract " + decoder.getStartTime() + " seconds");
}
else
{
System.Console.WriteLine("No aural sync detected in first 20 minutes of file");
}
}
public byte[] convertToBrstm(byte[] data)
{
string temppath = $"{DateTime.Now.ToFileTimeUtc()}.wav";
using (var input = new WaveFileReader(new MemoryStream(data)))
{
if (input.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
var outFormat = new WaveFormat(input.WaveFormat.SampleRate, input.WaveFormat.Channels);
using (var resampler = new MediaFoundationResampler(input, outFormat))
{
// resampler.ResamplerQuality = 48;
WaveFileWriter.CreateWaveFile(temppath, resampler);
}
data = File.ReadAllBytes(temppath);
}
}
WaveReader reader = new WaveReader();
WaveStructure structure = reader.ReadMetadata(new MemoryStream(data));
AudioData audio = reader.Read(data);
audio.SetLoop(true, 0, structure.SampleCount);
byte[] brstmFile = new BrstmWriter().GetFile(audio);
File.Delete(temppath);
return(brstmFile);
}
public IArchData ToArchData(byte[] wave, string waveExt, Dictionary <string, object> context = null)
{
WaveReader reader = new WaveReader();
var data = reader.Read(wave);
using MemoryStream oms = new MemoryStream();
NxOpusWriter writer = new NxOpusWriter();
writer.WriteToStream(data, oms, new NxOpusConfiguration());
OpusArchData archData = new OpusArchData {
Data = new PsbResource {
Data = oms.ToArray()
}
};
var format = data.GetAllFormats().FirstOrDefault();
if (format != null)
{
archData.SampleCount = format.SampleCount;
archData.SampRate = format.SampleRate;
archData.ChannelCount = format.ChannelCount;
}
return(archData);
}
public FileWaveSender(WaveReader reader)
{
mReader = reader;
#if DEBUG
mNumInstance++;
#endif
}
/* メソッド ****************************************************************/
/// <summary>
/// コンストラクタ生成時に渡された情報に従って特徴ベクトル生成器を構成します
/// </summary>
/// <param name="reader">音源ファイルを開いた状態のWaveReaderオブジェクト<para>情報取得に利用します。</para></param>
private void SetGenerator(WaveReader reader)
{
IFeatureGenerator generator = null;
var startupDir = System.Windows.Forms.Application.StartupPath;
var fname = startupDir + @"\" + "filter.txt";
switch (this.id)
{
case UnitMember.KMCustomUnit1c1d:
MinimumCondition condition1 = new MinimumCondition(50);
generator = new FeatureGenerator <KMCustomUnit1c1d>(condition1, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
break;
case UnitMember.KMCustomUnit2c1d:
MinimumCondition condition2 = new MinimumCondition(50);
generator = new FeatureGenerator <KMCustomUnit2c1d>(condition2, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
break;
case UnitMember.KMCustomUnit2c1dver2:
MinimumCondition condition3 = new MinimumCondition(50);
generator = new FeatureGenerator <KMCustomUnit2c1dver2>(condition3, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
break;
case UnitMember.KMCustomUnit3c1d:
MinimumCondition condition4 = new MinimumCondition(5);
generator = new FeatureGenerator <KMCustomUnit3c1d>(condition4, reader.SamplingRate, reader.SamplingRate / (double)this.ReadAmount, fname); // 特徴ベクトル生成器のインスタンスを作る
break;
}
this._generator = generator;
return;
}
public void Test16BitSingleChannelRoundTrip()
{
const int samplesPerSecond = 44_100;
const double delta = 1.0 / samplesPerSecond;
Func <double, double> func = (double t) => Math.Cos(2.0 * Math.PI * t);
short[] data = new short[samplesPerSecond];
for (int i = 0; i < samplesPerSecond; ++i)
{
data[i] = (short)(short.MaxValue * func(i * delta));
}
using var ms = new MemoryStream();
var writer = new WaveWriter(ms, samplesPerSecond);
writer.Write(data.Length, data);
ms.Position = 0;
var reader = new WaveReader(ms);
Assert.AreEqual(reader.Format.Channels, 1);
Assert.AreEqual(reader.Format.SamplesPerSecond, samplesPerSecond);
Assert.AreEqual(reader.Format.BitsPerSample, 16);
var channel = reader.GetChannelInt16(0);
int h = 0;
var e = channel.GetEnumerator();
while (e.MoveNext())
{
Assert.AreEqual(data[h++], e.Current, $"Index: {h}");
}
}
} //Read
/// <summary>
/// ファイルから Wave データを読み出し。
/// (後ろ0詰め)
/// </summary>
/// <param name="filename">ファイル名</param>
/// <param name="length">読み込む長さ</param>
/// <param name="skip">ファイルの先頭を読み飛ばす長さ</param>
/// <param name="threshold">閾値。この値以下の音は無音とみなす</param>
/// <param name="relative">閾値にピーク値からみた相対値を使う</param>
/// <param name="dstLength">コピー後の配列の長さ</param>
/// <returns>読み出したデータ</returns>
static WaveData Read(
string filename, int skip, int length,
double threshold, bool relative, int dstLength)
{
WaveReader reader = null;
FormatHeader header;
double[] l;
double[] r;
using (reader = new WaveReader(filename))
{
header = reader.Header;
reader.Read(reader.Length, out l, out r);
}
if (relative)
{
threshold *= Math.Max(GetPeekValue(l), GetPeekValue(r));
}
skip += Math.Min(GetSilentLength(l, threshold), GetSilentLength(r, threshold));
if (skip < 0 || skip + length >= l.Length)
{
skip = 0;
}
if (header.IsStereo)
{
return(new WaveTime(header, CopyArray(l, skip, length, dstLength), CopyArray(r, skip, length, dstLength)));
}
return(new WaveMonaural(header, CopyArray(l, skip, length, dstLength)));
} //Read
public WaveFormView2(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
InitializeComponent();
_Reader = new WaveReader(stream);
for (short i = 0; i < _Reader.Format.Channels; ++i)
{
switch (_Reader.Format.BitsPerSample)
{
case 8: this.wavePlot.plt.PlotSignalConst(_Reader.GetChannelInt8(i).Select(x => (float)x).ToArray()); break;
case 16: this.wavePlot.plt.PlotSignalConst(_Reader.GetChannelInt16(i).Select(x => (float)x).ToArray()); break;
case 32: this.wavePlot.plt.PlotSignalConst(_Reader.GetChannelFloat(i).ToArray()); break;
default:
throw new NotSupportedException($"Invalid sample size: {_Reader.Format.BitsPerSample}.");
}
;
}
this.wavePlot.MouseWheel += WavePlot_MouseWheel;
this.wavePlot.plt.AxisAuto(horizontalMargin: 0, verticalMargin: 0);
}
public void OpusArchiveEncoderTest()
{
ExtendedArchiveWriter writer = new ExtendedArchiveWriter("opusencoder");
writer.Files.Add(new Subfile(new FileSource(WavTestFile), "audio.wav", "arc"));
writer.Write("opusencodertest.ppx");
ExtendedArchive arc = new ExtendedArchive("opusencodertest.ppx");
var subfile = arc.Files.First();
Assert.AreEqual(ArchiveFileType.OpusAudio, subfile.Type);
Assert.IsTrue(subfile.Name == "audio.opus", $"Internal name did not switch to \"audio.opus\". Actual: {subfile.Name}");
Assert.IsTrue(subfile.EmulatedName == "audio.wav", $"Emulated name did stay as \"audio.wav\". Actual: {subfile.EmulatedName}");
Assert.IsTrue(subfile.ArchiveName == "arc", $"Archive name did not stay as \"arc\". Actual: {subfile.ArchiveName}");
Assert.IsTrue(subfile.EmulatedArchiveName == "arc.pp", $"Emulated archive name did not change to \"arc.pp\". Actual: {subfile.EmulatedArchiveName}");
using (OpusEncoder decoder = new OpusEncoder(subfile.GetRawStream()))
{
Stream decoded = decoder.Decode();
//Ensure it can be read
using (WaveReader wavreader = new WaveReader(decoded)) { }
}
File.Delete("opusencodertest.ppx");
}
public bool LoadSample(ref int[] samples, ref int sampleRate)
{
if (m_SampleOpen.ShowDialog( ))
{
BinaryReader br = new BinaryReader(m_SampleOpen.OpenFile( ));
WaveReader wav = new WaveReader(br);
if (wav.loaded)
{
sampleRate = wav.sampleRate;
samples = new int [wav.samples.Length];
for (int i = 0; i < samples.Length; i++)
{
samples [i] = Mathf.RoundToInt((wav.samples [i] / 255f) * Instruments.InstrumentInstance.LINEAR_STEPS);
}
}
br.Close( );
return(wav.loaded);
}
return(false);
}
private void TryReplacingTrackContents(Blackboard blackboard, TemporaryTrack track)
{
if (track.ExpectedName == null)
{
return;
}
var originalCodec = AvailableCodecs.GetCodec(track.CurrentCodec);
if (originalCodec == null)
{
blackboard.Logger.Error($"The track ({track.ExpectedName}) uses the {track.OriginalEntry.Codec} Codec, but AudioMog has no handler to replace it! Skipping!");
return;
}
var typelessFilePath = Path.Combine(_hcaFilesFolder, track.ExpectedName);
if (blackboard.Settings.UseWavFilesIfAvailable)
{
var wavFilePath = AddExtension(typelessFilePath, ".wav");
if (File.Exists(wavFilePath))
{
blackboard.Logger.Log($"Appending {AddExtension(track.ExpectedName, ".wav")}!");
var wavFileBytes = File.ReadAllBytes(wavFilePath);
var wavReader = new WaveReader();
var audioData = wavReader.Read(wavFileBytes);
var hcaWriter = new HcaWriter();
var hcaFileBytes = hcaWriter.GetFile(audioData);
track.RawPortion = hcaFileBytes;
track.CurrentCodec = MaterialCodecType.HCA;
return;
}
}
var hcaFilePath = AddExtension(typelessFilePath, ".hca");
if (File.Exists(hcaFilePath))
{
blackboard.Logger.Log($"Appending {AddExtension(track.ExpectedName, ".hca")}!");
var hcaFileBytes = File.ReadAllBytes(hcaFilePath);
track.RawPortion = hcaFileBytes;
track.CurrentCodec = MaterialCodecType.HCA;
return;
}
var rawFilePath = AddExtension(typelessFilePath, originalCodec.FileFormat);
if (File.Exists(rawFilePath))
{
blackboard.Logger.Log($"Appending {AddExtension(track.ExpectedName, originalCodec.FileFormat)}!");
var hcaFileBytes = File.ReadAllBytes(rawFilePath);
track.RawPortion = hcaFileBytes;
track.CurrentCodec = track.OriginalEntry.Codec;
return;
}
blackboard.Logger.Log($"Found no replacement to {track.ExpectedName}, using original track from uexp!");
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
WaveChannel.Dispose();
WaveReader.Dispose();
}
}
private void SetWaveFile(string fileName)
{
WaveReader waveReader = new WaveReader(fileName);
samples = (from samp in waveReader select samp[0]).ToArray();
sampleRate = (int)waveReader.SampleRate;
waveReader.Close();
}
public void LoadAudio(Stream stream, IFileFormat format)
{
stream.Position = 0;
Format = format;
foreach (string ext in Format.Extension)
{
string extension = ext.TrimStart('*');
switch (extension)
{
case ".bfstm":
case ".bcstm":
case ".bfwav":
case ".bcwav":
var bcfstmReader = new BCFstmReader();
audioWithConfig = bcfstmReader.ReadWithConfig(stream);
stream.Position = 0;
bxstmStructure = bcfstmReader.ReadMetadata(stream);
break;
case ".brstm":
case ".brwav":
var brstmReader = new BrstmReader();
bxstmStructure = brstmReader.ReadMetadata(stream);
stream.Position = 0;
audioWithConfig = brstmReader.ReadWithConfig(stream);
break;
case ".idsp":
var idspReader = new IdspReader();
idspStructure = idspReader.ReadMetadata(stream);
stream.Position = 0;
audioWithConfig = idspReader.ReadWithConfig(stream);
break;
case ".hps":
var hpsReader = new HpsReader();
hpsStructure = hpsReader.ReadMetadata(stream);
stream.Position = 0;
audioWithConfig = hpsReader.ReadWithConfig(stream);
break;
case ".wav":
var wavReader = new WaveReader();
waveStructure = wavReader.ReadMetadata(stream);
stream.Position = 0;
audioWithConfig = wavReader.ReadWithConfig(stream);
break;
default:
throw new Exception("Unsupported Extension " + ext);
}
audioData = audioWithConfig.Audio;
}
}
private byte[] WavToPcm(string wavfile)
{
WaveFormat wf = GetWaveFormat();
FormatDetails[] fdArr = AudioCompressionManager.GetFormatList(wf);
IntPtr format = fdArr[0].FormatHandle;
WaveReader wr = new WaveReader(File.Open(wavfile, FileMode.Open));
return(AudioCompressionManager.Convert(wr.ReadFormat(), format, wr.ReadData(), false));
}
public BatchEncode(string outDir, string inFile, string at9ToolPath)
{
OutDir = outDir;
InFile = inFile;
At9ToolPath = at9ToolPath;
using (var stream = new FileStream(InFile, FileMode.Open, FileAccess.Read))
{
Wave = new WaveReader().ReadMetadata(stream);
}
}
} //Read
/// <summary>
/// ファイルから Wave データを読み出し。
/// </summary>
/// <param name="filename">ファイル名</param>
/// <param name="length">読み込む長さ</param>
/// <param name="skip">ファイルの先頭を読み飛ばす長さ</param>
/// <param name="threshold">閾値。この値以下の音は無音とみなす</param>
/// <param name="relative">閾値にピーク値からみた相対値を使う</param>
/// <param name="type">リファレンスのタイプ</param>
/// <returns>読み出したデータ</returns>
static WaveData Read(
string filename, int skip, int length,
double threshold, bool relative, ReferenceType type)
{
WaveReader reader = null;
FormatHeader header;
double[] l;
double[] r;
using (reader = new WaveReader(filename))
{
header = reader.Header;
// R ch を使いたいのに wave ファイルがモノラルの場合
if (type != ReferenceType.Left && reader.Header.ch == 1)
{
return(new WaveTime());
}
reader.Skip(0);
reader.Read(reader.Length, out l, out r);
}
if (type == ReferenceType.Left)
{
if (relative)
{
threshold *= GetPeekValue(l);
}
skip += GetSilentLength(l, threshold);
}
else if (type == ReferenceType.Right)
{
if (relative)
{
threshold *= GetPeekValue(r);
}
skip += GetSilentLength(r, threshold);
}
else
{
if (relative)
{
threshold *= Math.Max(GetPeekValue(l), GetPeekValue(r));
}
skip += Math.Min(GetSilentLength(l, threshold), GetSilentLength(r, threshold));
}
if (skip < 0 || skip + length >= l.Length)
{
skip = 0;
}
return(new WaveTime(header, CopyArray(l, skip, length), CopyArray(r, skip, length)));
} //Read
public void OpusDecoderTest()
{
using (Stream opus = File.OpenRead(OpusTestFile))
using (OpusEncoder decoder = new OpusEncoder(opus))
{
Stream decoded = decoder.Decode();
//Ensure it can be read
using (WaveReader wavreader = new WaveReader(decoded)) { }
}
}
public static void Main(string[] args)
{
var wav = WaveReader.readWAV("../Toumei Elegy.wav");
var ds = new double[wav.channels[0].Length];
for (int i = 0; i < wav.channels[0].Length; i++)
{
ds[i] = wav.channels[0][i] / 65536.0;
}
subspectrum(ds, 1024, wav.frequency * 20, wav.frequency * 30, 2200, 512, "../spectrum_cs.bmp", 25);
}
void ShowSynthCommandExecuted(object sender, ExecutedRoutedEventArgs args)
{
const int sampleRate = 44100;
var func = _Parser.Compile(this.ExpressionText);
var sample = Generate(sampleRate, 1.0, func);
var delta = 1.0 / sampleRate;
var reader = new WaveReader(sample);
var fmt = reader.Format;
var xSeries = Enumerable.Range(0, (int)reader.NumberOfSamples).Select(i => i * delta);
var ySeries = reader.GetChannelFloat(0).Select(x => (double)x);
channel1.Plot(xSeries, ySeries);
}
public void StartPlay()
{
if (playEx.State == DeviceState.Paused)
{
playEx.ResumePlay();
}
else
{
wr = new WaveReader(_stream);
IntPtr format = wr.ReadFormat();
playEx.OpenPlayer(format);
byte[] data = wr.ReadData();
playEx.AddData(data);
playEx.StartPlay();
}
}
public WAVSampler(Stream stream, short channel = 0)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
_waveReader = new WaveReader(stream);
if (channel >= _waveReader.Format.Channels)
{
throw new ArgumentOutOfRangeException(nameof(channel), channel, $"Channel must be in range [0, {_waveReader.Format.Channels}).");
}
_channel = channel;
_data = _waveReader.GetChannelFloat(channel).Select(f => (double)f).ToArray();
this.Length = _data.LongLength;
}
/// <summary>
/// ファイルから Wave データを読み出し。
/// </summary>
/// <param name="filename">ファイル名</param>
/// <param name="length">読み込む長さ</param>
/// <param name="skip">ファイルの先頭を読み飛ばす長さ</param>
/// <returns>読み出したデータ</returns>
static WaveData Read(string filename, int skip, int length)
{
WaveReader reader = null;
FormatHeader header;
double[] l;
double[] r;
using (reader = new WaveReader(filename))
{
header = reader.Header;
reader.Skip(skip);
reader.Read((uint)length, out l, out r);
}
return(new WaveTime(header, l, r));
} //Read
public static void ConvertWAVtoBFWAV(string input, string output)
{
byte[] fileAudioData = File.ReadAllBytes(input);
string fileAudioIdntr = ".wav";
STRG fileStrg = new STRG();
fileStrg.name = Path.GetFileNameWithoutExtension(input);
if (fileAudioIdntr == ".wav")
{
FileStream f = File.Create(output);
WaveReader reader = new WaveReader();
BCFstmWriter writer = new BCFstmWriter(NwTarget.Cafe);
VGAudio.Formats.AudioData convertedWav = reader.Read(fileAudioData);
writer.WriteToStream(convertedWav, f);
f.Close();
}
}
public void OpusEncoderTest()
{
using (Stream source = File.OpenRead(WavTestFile))
{
using (OpusEncoder encoder = new OpusEncoder(source))
{
Stream encoded = encoder.Encode();
using (OpusEncoder decoder = new OpusEncoder(encoded))
{
Stream decoded = decoder.Decode();
//Ensure it can be read
using (WaveReader wavreader = new WaveReader(decoded)) { }
}
}
}
}
public void PlayMusic()
{
string[] songs = new string[7];
songs[0] = "National Anthem of the soviet union - Red Army Choir.wav";
songs[1] = "Katyusha_Катюша with Lyrics.wav";
songs[2] = "'Kalinka'.wav";
songs[3] = "Red Army Choir - Korobeiniki.wav";
songs[4] = "Boney M. - Rasputin.wav";
songs[5] = "Tetris Theme (Piano Version) - 400k Special.wav";
songs[6] = "Dschinghis Khan - Moskau 1979.wav";
SoundPlayer player = new SoundPlayer();
WaveReader reader = new WaveReader(File.OpenRead(songs[index]));
player.SoundLocation = songs[index];
player.Play();
Thread.Sleep(reader.GetDurationInMS());
OnMusicEnded();
}
static IEnumerable<ComparisonAgregator> CompareByFrequencies(WaveReader originalReader, WaveReader compressedReader, float samplingRate, int numChannels, long compressedSamplesToSkip)
{
var minWindowSize = samplingRate / 16;
int windowSize;
var windowSizeCtr = 0;
do
{
windowSizeCtr++;
windowSize = Convert.ToInt32(Math.Pow(2, windowSizeCtr));
} while (windowSize <= minWindowSize);
var samplesPerCheck = minWindowSize / 2;
var comparisonAgregators = new Dictionary<int, ComparisonAgregator>();
for (var ctr = 1; ctr < windowSize / 2; ctr++)
{
var lowerFrequency = (ctr - 1) * samplingRate / windowSize;
var frequency = ctr * samplingRate / windowSize;
if (frequency >= 16)
comparisonAgregators[ctr - 1] = new ComparisonAgregator(lowerFrequency.ToString() + "hz", lowerFrequency);
}
comparisonAgregators[windowSize / 2] = new ComparisonAgregator((samplingRate / 2).ToString() + "hz", samplingRate / 2);
var equilizationMethods = new Dictionary<int, Action<float[], float[]>>();
foreach (var kvp in comparisonAgregators)
equilizationMethods[kvp.Key] = kvp.Value.DetermineEquilization;
EnumerateByFrequencies (originalReader, compressedReader, numChannels, windowSize, samplesPerCheck, equilizationMethods, compressedSamplesToSkip);
var comparisonMethods = new Dictionary<int, Action<float[], float[]>>();
foreach (var kvp in comparisonAgregators)
comparisonMethods[kvp.Key] = kvp.Value.CompareSamples;
EnumerateByFrequencies (originalReader, compressedReader, numChannels, windowSize, samplesPerCheck, comparisonMethods, compressedSamplesToSkip);
foreach (var compressionAgregator in comparisonAgregators.OrderBy(kvp => kvp.Key).Select(kvp => kvp.Value))
compressionAgregator.WriteResults();
return comparisonAgregators.Values;
}
} //Read
/// <summary>
/// ファイルから Wave データを読み出し。
/// (後ろ0詰め)
/// </summary>
/// <param name="filename">ファイル名</param>
/// <param name="length">読み込む長さ</param>
/// <param name="skip">ファイルの先頭を読み飛ばす長さ</param>
/// <param name="dstLength">コピー後の配列の長さ</param>
/// <returns>読み出したデータ</returns>
static WaveData Read(string filename, int skip, int length, int dstLength)
{
WaveReader reader = null;
FormatHeader header;
double[] l;
double[] r;
using (reader = new WaveReader(filename))
{
header = reader.Header;
reader.Skip(skip);
reader.Read((uint)length, out l, out r);
}
if (header.IsStereo)
{
return(new WaveTime(header, CopyArray(l, 0, length, dstLength), CopyArray(r, 0, length, dstLength)));
}
return(new WaveMonaural(header, CopyArray(l, 0, length, dstLength)));
} //Read
public static void convertToBrstm(string path)
{
using (var input = new WaveFileReader(path))
{
if (input.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
string temppath = "temp.wav";
var outFormat = new WaveFormat(input.WaveFormat.SampleRate, input.WaveFormat.Channels);
using (var resampler = new MediaFoundationResampler(input, outFormat))
{
// resampler.ResamplerQuality = 48;
WaveFileWriter.CreateWaveFile(temppath, resampler);
}
}
}
if (File.Exists("temp.wav"))
{
File.Delete(path);
File.Move("temp.wav", path);
}
WaveStructure structure;
WaveReader reader = new WaveReader();
byte[] fs = File.ReadAllBytes(path);
string newpath = new string(path.Take(path.Length - 3).ToArray());
newpath += "brstm";
handleExistingFile(newpath);
Stream stream = new MemoryStream(fs);
structure = reader.ReadMetadata(stream);
AudioData audio = reader.Read(fs);
audio.SetLoop(true, 0, structure.SampleCount);
byte[] brstmFile = new BrstmWriter().GetFile(audio);
File.WriteAllBytes(newpath, brstmFile);
Console.WriteLine($"Converted: {path} \n --> {newpath}");
}
static void EnumerateBySamples(WaveReader originalReader, WaveReader compressedReader, long compressedSamplesToSkip, Action<float[], float[]> compareMethod)
{
originalReader.Seek(0);
compressedReader.Seek(compressedSamplesToSkip);
using (var compressedSamplesItr = compressedReader.ReadAllSamples_Float ().GetEnumerator ())
{
foreach (var originalSamples in originalReader.ReadAllSamples_Float ())
{
if (compressedSamplesItr.MoveNext ())
{
var compressedSamples = compressedSamplesItr.Current;
compareMethod (originalSamples, compressedSamples);
}
else
{
Console.WriteLine ("Compressed file is shorter");
break;
}
}
if (compressedSamplesItr.MoveNext ())
{
Console.WriteLine ("Compressed file is longer");
}
}
}
static void EnumerateByFrequencyBands(
WaveReader originalReader,
WaveReader compressedReader,
long compressedSamplesToSkip,
Action<float[], float[]> highComparisonMethod,
Action<float[], float[]> midComparisonMethod,
Action<float[], float[]> lowComparisonMethod)
{
originalReader.Seek(0);
compressedReader.Seek(compressedSamplesToSkip);
var originalHighSamplesQueue = new Queue<float[]> ();
var compressedHighSamplesQueue = new Queue<float[]> ();
var originalMidSamples = SampleRateAdjustor.DownSample (originalReader.ReadAllSamples_Float (), originalReader.NumChannels, 16, originalHighSamplesQueue.Enqueue);
var compressedMidSamples = SampleRateAdjustor.DownSample (compressedReader.ReadAllSamples_Float (), compressedReader.NumChannels, 16, compressedHighSamplesQueue.Enqueue);
var originalMidSamplesQueue = new Queue<float[]> ();
var compressedMidSamplesQueue = new Queue<float[]> ();
var originalLowSamples = SampleRateAdjustor.DownSample (originalMidSamples, originalReader.NumChannels, 16, originalMidSamplesQueue.Enqueue);
var compressedLowSamples = SampleRateAdjustor.DownSample (compressedMidSamples, compressedReader.NumChannels, 16, compressedMidSamplesQueue.Enqueue);
using (var compressedSamplesItr = compressedLowSamples.GetEnumerator ())
{
foreach (var originalSamples in originalLowSamples)
{
if (compressedSamplesItr.MoveNext ())
{
var compressedSamples = compressedSamplesItr.Current;
lowComparisonMethod (originalSamples.ToArray (), compressedSamples.ToArray ());
while (originalHighSamplesQueue.Count > 0 && compressedHighSamplesQueue.Count > 0)
highComparisonMethod (originalHighSamplesQueue.Dequeue (), compressedHighSamplesQueue.Dequeue ());
while (originalMidSamplesQueue.Count > 0 && compressedMidSamplesQueue.Count > 0)
midComparisonMethod (originalMidSamplesQueue.Dequeue (), compressedMidSamplesQueue.Dequeue ());
}
else
{
Console.WriteLine ("Compressed file is shorter");
break;
}
}
if (compressedSamplesItr.MoveNext ())
{
Console.WriteLine ("Compressed file is longer");
}
}
}
static void EnumerateByFrequencies(WaveReader originalReader, WaveReader compressedReader, int numChannels, int windowSize, float samplesPerCheck, Dictionary<int, Action<float[], float[]>> comparisonMethods, long compressedSamplesToSkip)
{
originalReader.Seek(0);
compressedReader.Seek(compressedSamplesToSkip);
var fft = new ComplexFourierTransformation();
var originalQueue = new Queue<float[]> ();
var compressedQueue = new Queue<float[]> ();
using (var compressedSamplesItr = compressedReader.ReadAllSamples_Float ().GetEnumerator ())
{
foreach (var originalSamples in originalReader.ReadAllSamples_Float ())
{
if (compressedSamplesItr.MoveNext ())
{
originalQueue.Enqueue (originalSamples);
compressedQueue.Enqueue (compressedSamplesItr.Current);
if (originalQueue.Count == windowSize)
{
for (var channelCtr = 0; channelCtr < numChannels; channelCtr++)
{
var originalSamplesToTransform = originalQueue.Select (s => new Complex (s [channelCtr], 0)).ToArray ();
var compressedSamplesToTransform = compressedQueue.Select (s => new Complex (s [channelCtr], 0)).ToArray ();
fft.TransformForward (originalSamplesToTransform);
fft.TransformForward (compressedSamplesToTransform);
foreach (var kvp in comparisonMethods)
{
var fftIndex = kvp.Key;
var comparisonMethod = kvp.Value;
comparisonMethod(
new float[] { Convert.ToSingle (originalSamplesToTransform [fftIndex].Modulus) },
new float[] { Convert.ToSingle (compressedSamplesToTransform [fftIndex].Modulus) });
}
}
for (var ctr = 0; ctr < samplesPerCheck; ctr++)
{
originalQueue.Dequeue ();
compressedQueue.Dequeue ();
}
}
}
else
{
Console.WriteLine ("Compressed file is shorter");
break;
}
}
if (compressedSamplesItr.MoveNext ())
{
Console.WriteLine ("Compressed file is longer");
}
}
}
static IEnumerable<ComparisonAgregator> CompareBySamples(WaveReader originalReader, WaveReader compressedReader, long compressedSamplesToSkip)
{
var comparisonAgregator = new ComparisonAgregator ("All samples", 0);
EnumerateBySamples (originalReader, compressedReader, compressedSamplesToSkip, comparisonAgregator.DetermineEquilization);
EnumerateBySamples (originalReader, compressedReader, compressedSamplesToSkip, comparisonAgregator.CompareSamples);
comparisonAgregator.WriteResults ();
yield return comparisonAgregator;
}
public static void Main(string[] args)
{
var originalFile = args[0];
var compressedFile = args[1];
var spreadsheet = args[2];
/*var pck = new OfficeOpenXml.ExcelPackage(System.IO.File.OpenRead(spreadsheet));
foreach (var worksheet in pck.Workbook.Worksheets)
SpreadsheetWriter.CreateChart(worksheet);
pck.File = new System.IO.FileInfo(spreadsheet);
pck.Save();*/
var compressedSamplesToSkip = 0L;
if (args.Length > 3)
long.TryParse(args[3], out compressedSamplesToSkip);
Console.WriteLine("Comparing files:\n\tOriginal: {0}\n\tCompressed: {1}", originalFile, compressedFile);
// Goal is to compare three bands:
// High frequencies: above 5000hz
// Sensitive frequencies: Between 2000-5000hz
// Low frequencies: below 2000hz
// At 48khz
// Low band: 3khz, (1/4th sampling rate from mid band)
// Mid band: 12khz, (1/4th sampling rate from high band)
// High band: 48khz
using (var originalReader = new WaveReader(originalFile))
{
using (var compressedReader = new WaveReader(compressedFile))
{
if (originalReader.SamplingRate != compressedReader.SamplingRate)
{
Console.WriteLine("Sampling rates do not match. Can not compare files with different sampling rates");
return;
}
if (originalReader.NumChannels != compressedReader.NumChannels)
{
Console.WriteLine("Number of channels do not match. Can not compare files with different channels");
return;
}
var comparisonsByName = new Dictionary<string, IEnumerable<ComparisonAgregator>>();
comparisonsByName["samples"] = CompareBySamples (originalReader, compressedReader, compressedSamplesToSkip).ToArray();
if (originalReader.SamplingRate == 48000)
{
comparisonsByName["banded"] = CompareByFrequencyBands (originalReader, compressedReader, compressedSamplesToSkip).ToArray();
}
else
{
Console.WriteLine("Banded comparison requires a 48000 sampling rate");
}
comparisonsByName["frequencies"] = CompareByFrequencies (originalReader, compressedReader, originalReader.SamplingRate, originalReader.NumChannels, compressedSamplesToSkip).ToArray();
if (null != spreadsheet)
SpreadsheetWriter.WriteSpreadsheet(spreadsheet, comparisonsByName);
}
}
}
public void StartPlay()
{
if (_stream != null)
{
if (playEx.State == DeviceState.Paused)
{
playEx.ResumePlay();
}
else
{
wr = new WaveReader(_stream);
IntPtr format = wr.ReadFormat();
playEx.OpenPlayer(format);
byte[] data = wr.ReadData();
playEx.AddData(data);
playEx.StartPlay();
}
}
}
private static void Wav2Vox(string inFile, string outFile, int samplesPerSec, bool isResample)
{
WaveReader wr = new WaveReader(File.OpenRead(inFile));
IntPtr format = wr.ReadFormat();
byte[] data = wr.ReadData();
wr.Close();
WaveFormat wf = AudioCompressionManager.GetWaveFormat(format);
if (wf.wFormatTag != AudioCompressionManager.PcmFormatTag)//Decode if not PCM data
{
Decode2Pcm(ref format, ref data, ref wf);
}
if (isResample && wf.nSamplesPerSec != samplesPerSec)
{
Resample(ref format, ref data, ref wf, samplesPerSec);
}
BinaryWriter bw = new BinaryWriter(File.OpenWrite(outFile));
BinaryReader br = new BinaryReader(new MemoryStream(data));
Vox.Raw2Vox(br, bw, wf.wBitsPerSample);
br.Close();
bw.Close();
}
private string[] IntspectFile(string fileName)
{
ID3v1 m_id3;
Dictionary<WaveInfo, string> m_waveTags = null;
IAudioReader ar = null;
Stream stream = null;
string ext = Path.GetExtension(fileName.ToLower());
m_id3 = null;
m_waveTags = null;
switch (ext)
{
case ".avi":
stream = File.OpenRead(fileName);
ar = new AviReader(stream);
if (!((AviReader)ar).HasAudio)
{
return new string[] { string.Format("'{0}' file is not contains audio data", fileName) };
}
break;
case ".au":
case ".snd":
ar = new AuReader(File.OpenRead(fileName));
break;
case ".wav":
stream = File.OpenRead(fileName);
ar = new WaveReader(stream);
m_waveTags = (ar as WaveReader).ReadInfoTag();
break;
case ".mp3":
stream = File.OpenRead(fileName);
ar = new Mp3Reader(stream);
Mp3Reader mrID3 = new Mp3Reader(File.OpenRead(fileName));
m_id3 = mrID3.ReadID3v1Tag();
break;
default:
ar = new DsReader(fileName);
if (!((DsReader)ar).HasAudio)
{
return new string[] { string.Format("'{0}' file is not contains audio data", fileName) };
}
break;
}
IntPtr format = ar.ReadFormat();
WaveFormat wf = AudioCompressionManager.GetWaveFormat(format);
List<string> list = new List<string>();
list.Add(string.Format("Opening {0}", fileName));
list.Add(string.Format("{0}, {1} Hz, {2} channels, {3} bits per sample", GetFormatTagName(wf.wFormatTag), wf.nSamplesPerSec, wf.nChannels, wf.wBitsPerSample));
list.Add(string.Format("Block Align: {0}, Average Bytes Per Second: {1}", wf.nBlockAlign, wf.nAvgBytesPerSec ));
TimeSpan duration = TimeSpan.FromMilliseconds(ar.GetDurationInMS());
list.Add(string.Format("Duration: {0}", duration));
if (m_id3 != null)
{
list.Add("--------- ID3 -----------");
list.Add(string.Format("Title: {0}", m_id3.Title));
list.Add(string.Format("Artist: {0}", m_id3.Artist));
list.Add(string.Format("Album: {0}", m_id3.Album));
list.Add(string.Format("Year: {0}", m_id3.Year));
list.Add(string.Format("Genre: {0}", m_id3.Genre.ToString()));
list.Add(string.Format("Comment: {0}", m_id3.Comment));
}
if (m_waveTags != null)
{
list.Add("--------- Wave tags -----------");
foreach(WaveInfo key in m_waveTags.Keys)
list.Add(string.Format("{0}: {1}", key.ToString(), m_waveTags[key]));
}
ar.Close();
return list.ToArray();
}
static IEnumerable<ComparisonAgregator> CompareByFrequencyBands(WaveReader originalReader, WaveReader compressedReader, long compressedSamplesToSkip)
{
var highComparisonAgregator = new ComparisonAgregator ("High Frequencies: > 6khz", 0);
var midComparisonAgregator = new ComparisonAgregator ("Mid Frequencies: < 6khz, > 3khz", 1);
var lowComparisonAgregator = new ComparisonAgregator ("Low Frequencies: < 3khz", 2);
EnumerateByFrequencyBands (
originalReader,
compressedReader,
compressedSamplesToSkip,
highComparisonAgregator.DetermineEquilization,
midComparisonAgregator.DetermineEquilization,
lowComparisonAgregator.DetermineEquilization);
EnumerateByFrequencyBands (
originalReader,
compressedReader,
compressedSamplesToSkip,
highComparisonAgregator.CompareSamples,
midComparisonAgregator.CompareSamples,
lowComparisonAgregator.CompareSamples);
lowComparisonAgregator.WriteResults ();
midComparisonAgregator.WriteResults ();
highComparisonAgregator.WriteResults ();
yield return lowComparisonAgregator;
yield return midComparisonAgregator;
yield return highComparisonAgregator;
}
static IEnumerable<IEnumerable<float>> UpSample(WaveReader reader, int windowSize)
{
var fft = new MathNet.Numerics.Transformations.ComplexFourierTransformation ();
var determineVolumeSource = new Complex[]
{
new Complex(1, 0),
new Complex(1, 0),
new Complex(1, 0),
new Complex(1, 0),
};
fft.TransformForward(determineVolumeSource);
var determineVolumeDestination = new Complex[windowSize];
determineVolumeDestination[0] = determineVolumeSource[0];
for (var sampleCtr = 1; sampleCtr < windowSize; sampleCtr++)
determineVolumeDestination[sampleCtr] = Complex.FromModulusArgument(0,0);
fft.TransformBackward(determineVolumeDestination);
var multiplier = determineVolumeDestination[0].Real;
var sampleQueue = new Queue<float[]>();
for (var sampleCtr = 0; sampleCtr < 2; sampleCtr++)
sampleQueue.Enqueue(new float[reader.NumChannels]);
foreach (var samples in reader.ReadAllSamples_Float().Select(s => s.ToArray()))
{
sampleQueue.Enqueue(samples);
if (sampleQueue.Count == 4)
{
var expanded = new float[windowSize / 2][];
for (var ctr = 0; ctr < windowSize / 2; ctr++)
expanded[ctr] = new float[reader.NumChannels];
for (var channelCtr = 0; channelCtr < reader.NumChannels; channelCtr++)
{
var samplesToTransform = sampleQueue.Select(s => new Complex (s[channelCtr], 0)).ToArray();
fft.TransformForward (samplesToTransform);
var samplesToTransformBack = new Complex[windowSize];
samplesToTransformBack[0] = samplesToTransform[0];
samplesToTransformBack[1] = samplesToTransform[1];
samplesToTransformBack[1].Modulus /= 2;
samplesToTransformBack[samplesToTransformBack.Length - 1] = samplesToTransform[1];
samplesToTransformBack[samplesToTransformBack.Length - 1].Modulus /= 2;
samplesToTransformBack[samplesToTransformBack.Length - 1].Argument *= -1;
for (var ctr = 2; ctr < samplesToTransformBack.Length - 1; ctr++)
samplesToTransformBack[ctr] = Complex.FromModulusArgument(0, 0);
fft.TransformBackward(samplesToTransformBack);
for (var ctr = 0; ctr < windowSize / 2; ctr++)
expanded[ctr][channelCtr] = Convert.ToSingle(samplesToTransformBack[ctr + windowSize / 4].Real / multiplier);
}
foreach (var simplified in expanded)
yield return simplified;
sampleQueue.Dequeue();
sampleQueue.Dequeue();
}
}
}
