public static void RegisterSound(string soundName)
{
var file = $"{SharpCraft.Instance.GameFolderDir}/assets/sharpcraft/sounds/{soundName}.ogg";
if (!File.Exists(file))
{
Console.WriteLine($"ERROR: Couldn't find sound '{soundName}'");
return;
}
using (var wr = new VorbisWaveReader(file))
{
byte[] data = new byte[wr.Length];
wr.Read(data, 0, data.Length);
int buffer = AL.GenBuffer();
int source = AL.GenSource();
AL.BufferData(buffer, ALFormat.VorbisExt, data, data.Length, wr.WaveFormat.SampleRate);
AL.Source(source, ALSourcei.Buffer, buffer);
AL.BindBufferToSource(source, buffer);
//Sounds.TryAdd(soundName, new ValueTuple<int, int>(source, buffer));
}
}
/// <summary>Reads sound data from a Ogg Vorbis file.</summary>
/// <param name="fileName">The file name of the Ogg Vorbis file.</param>
/// <returns>The raw sound data.</returns>
private static Sound LoadFromFile(string fileName)
{
using (VorbisWaveReader reader = new VorbisWaveReader(fileName))
{
int sampleCount = (int)reader.Length / (reader.WaveFormat.Channels * sizeof(float));
float[] dataFloats = new float[sampleCount * reader.WaveFormat.Channels];
// Convert Ogg Vorbis to raw 32-bit float n channels PCM.
int floatsRead = reader.Read(dataFloats, 0, sampleCount * reader.WaveFormat.Channels);
byte[] dataBytes = new byte[floatsRead * sizeof(short)];
byte[][] buffers = new byte[reader.WaveFormat.Channels][];
for (int i = 0; i < buffers.Length; i++)
{
buffers[i] = new byte[dataBytes.Length / buffers.Length];
}
// Convert PCM bit depth from 32-bit float to 16-bit integer.
using (MemoryStream stream = new MemoryStream(dataBytes))
using (BinaryWriter writer = new BinaryWriter(stream))
{
for (int i = 0; i < floatsRead; i++)
{
float sample = dataFloats[i];
if (sample < -1.0f)
{
sample = -1.0f;
}
if (sample > 1.0f)
{
sample = 1.0f;
}
writer.Write((short)(sample * short.MaxValue));
}
}
// Separated for each channel.
for (int i = 0; i < floatsRead / buffers.Length; i++)
{
for (int j = 0; j < buffers.Length; j++)
{
for (int k = 0; k < sizeof(short); k++)
{
buffers[j][i * sizeof(short) + k] = dataBytes[i * sizeof(short) * buffers.Length + sizeof(short) * j + k];
}
}
}
return(new Sound(reader.WaveFormat.SampleRate, sizeof(short) * 8, buffers));
}
}
public int Read(float[] buffer, int offset, int count)
{
if (isDisposed)
{
return(0);
}
int read = reader.Read(buffer, offset, count);
if (read == 0)
{
reader.Dispose();
isDisposed = true;
}
return(read);
}
public int Read(float[] buffer, int offset, int count)
{
if (_reader == null)
{
return(0);
}
var read = _reader.Read(buffer, offset, count);
if (read == 0)
{
_reader.Dispose();
_reader = null;
}
return(read);
}
public VorbisCachedSound(string audioFileName)
{
using (var audioFileReader = new VorbisWaveReader(audioFileName))
{
// TODO: could add resampling in here if required
WaveFormat = audioFileReader.WaveFormat;
var wholeFile = new List <float>((int)(audioFileReader.Length / 4));
var readBuffer = new float[audioFileReader.WaveFormat.SampleRate * audioFileReader.WaveFormat.Channels];
int samplesRead;
while ((samplesRead = audioFileReader.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
wholeFile.AddRange(readBuffer.Take(samplesRead));
}
AudioData = wholeFile.ToArray();
}
}
private IWaveProvider GetOggWaveProvider()
{
Logger.Info($"Reading Ogg @ {opts.File}");
var oggReader = new VorbisWaveReader(opts.File);
int bytes = (int)oggReader.Length;
byte[] buffer = new byte[bytes];
Logger.Info($"Read Ogg - Sample Rate {oggReader.WaveFormat.SampleRate}");
if (oggReader.WaveFormat.SampleRate < INPUT_SAMPLE_RATE)
{
Logger.Error($"Ogg Sample rate must be at least 16000 but is {oggReader.WaveFormat.SampleRate} - Quitting. Use Audacity or another tool to resample as 16000 or Higher");
Environment.Exit(1);
}
int read = oggReader.Read(buffer, 0, (int)bytes);
BufferedWaveProvider bufferedWaveProvider = new BufferedWaveProvider(oggReader.WaveFormat)
{
BufferLength = read * 2,
ReadFully = false,
DiscardOnBufferOverflow = true
};
bufferedWaveProvider.AddSamples(buffer, 0, read);
VolumeSampleProvider volumeSample =
new VolumeSampleProvider(bufferedWaveProvider.ToSampleProvider())
{
Volume = opts.Volume
};
oggReader.Close();
oggReader.Dispose();
Logger.Info($"Convert to Mono 16bit PCM");
//after this we've got 16 bit PCM Mono - just need to sort sample rate
return(volumeSample.ToMono().ToWaveProvider16());
}
private static void MergeOgg(string[] inputFiles, string outputFile)
{
// MediaFoundationInterop.MFStartup();
var vorbisReader = new VorbisWaveReader("bias__us_1.ogg");
MediaFoundationEncoder.EncodeToMp3(vorbisReader, outputFile);
var outputStream = new FileStream("output.mp3", FileMode.Create);
byte[] array = new byte[255];
var span = new Span <byte>(array);
vorbisReader.Read(span);
outputStream.Write(span);
//Mp3Frame frame;
//while ((frame = reader.ReadNextFrame()) != null)
//{
// outputStream.Write(frame.RawData, 0, frame.RawData.Length);
//}
}
private void LoadMusic(string musicFile)
{
using (var reader = new VorbisWaveReader(musicFile)) {
channels = reader.WaveFormat.Channels;
sampleRate = reader.WaveFormat.SampleRate;
Log.Info($"Sample rate is {sampleRate}, channels {channels}");
var channelSize = (int)Math.Ceiling(sampleRate * reader.TotalTime.TotalSeconds);
var bufferSize = channels * channelSize;
buffer = new float[bufferSize];
reader.Read(buffer, 0, bufferSize);
bufferLength = bufferSize / channels;
if (Audio.SoundEffectInstance == null)
{
Audio.SoundEffectInstance = new DynamicSoundEffectInstance(sampleRate, AudioChannels.Stereo);
Audio.SoundEffectInstance.BufferNeeded += Audio.SubmitBuffer;
GC.SuppressFinalize(Audio.SoundEffectInstance);
Audio.SoundEffectInstance.Play();
}
}
}
public int Read(byte[] buffer, int offset, int count)
{
if (count % bytesPerSample != 0)
{
count = (count / bytesPerSample) * bytesPerSample;
}
lock (this)
{
for (int i = 0; i < count;)
{
if (reader.Length - reader.Position <= count - i)
{
i += reader.Read(buffer, offset + i, (int)reader.Length - (int)reader.Position);
reader.Position = loopFrom;
}
else
{
i += reader.Read(buffer, offset + i, count - i);
}
}
#region 淡入淡出
if (preReader != null)
{
if (UseSmoothSwitchWhenPause)
{
unsafe
{
if (buffer1 == null || buffer1.Length < count)
{
buffer1 = new byte[count];
}
for (int i = 0; i < count;)
{
if (preReader.Length - preReader.Position <= count - i)
{
i += preReader.Read(buffer1, i, (int)preReader.Length - (int)preReader.Position);
preReader.Position = preLoopFrom;
}
else
{
i += preReader.Read(buffer1, i, count - i);
}
}
float al, ar, bl, br;
fixed(byte *pa = buffer)
{
fixed(byte *pb = buffer1)
{
float *fpa = (float *)(pa + offset);
float *fpb = (float *)pb;
int end = count / bytesPerSample * 2;
float x;
for (int i = 0; i < end; i += 2)
{
al = fpa[i];
ar = fpa[i + 1];
bl = fpb[i];
br = fpb[i + 1];
x = (i + 1) * 1.0f / end;
fpa[i] = al * x + bl * (1 - x);
fpa[i + 1] = ar * x + br * (1 - x);
}
}
}
}
}
preReader.Dispose();
preFile.Dispose();
preReader = null;
preFile = null;
UseSmoothSwitchWhenPause = true;
}
#endregion
}
return(count);
}
private BitmapImage _Draw(double height, double width, CancellationToken ct)
{
isDrawing = true;
reader.Position = 0;
DrawingVisual dv = new DrawingVisual();
using (DrawingContext dc = dv.RenderOpen()) {
Pen bluePen = new Pen(new SolidColorBrush(Constants.Editor.Waveform.ColourWPF), Constants.Editor.Waveform.ThicknessWPF);
bluePen.Freeze();
int channels = reader.WaveFormat.Channels;
var bytesPerSample = reader.WaveFormat.BitsPerSample / 8 * channels;
var numSamples = reader.Length / bytesPerSample;
int samplesPerPixel = (int)(numSamples / height) * channels;
double samplesPerPixel_d = numSamples / height * channels;
int totalSamples = 0;
double totalSamples_d = 0;
var buffer = new float[samplesPerPixel + channels];
for (int pixel = 0; pixel < height; pixel++)
{
// read samples
int samplesRead = reader.Read(buffer, 0, samplesPerPixel);
if (samplesRead == 0)
{
break;
}
// correct floating point rounding errors
totalSamples += samplesPerPixel;
totalSamples_d += samplesPerPixel_d;
if (totalSamples_d - totalSamples > channels)
{
totalSamples += channels;
reader.Read(buffer, samplesPerPixel, channels);
}
var samples = new List <float>(buffer);
float lowPercent = (samples.Min() + 1) / 2;
float highPercent = (samples.Max() + 1) / 2;
float lowValue = (float)width * lowPercent;
float highValue = (float)width * highPercent;
dc.DrawLine(
bluePen,
new Point(lowValue, (int)(height - pixel)),
new Point(highValue, (int)(height - pixel))
);
// cancel task if required
if (ct.IsCancellationRequested)
{
isDrawing = false;
return(null);
}
}
}
RenderTargetBitmap bmp = new RenderTargetBitmap((int)width, (int)height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(dv);
bmp.Freeze();
//RenderTargetToDisk(bmp);
isDrawing = false;
return(RenderTargetToImage(bmp));
}
