public void AdpcmSampleCountIsCorrectAfterLooping(int sampleCount, bool looping, int loopStart, int loopEnd)
{
IAudioFormat adpcm = GenerateAudio.GenerateAdpcmEmpty(sampleCount, 1, 48000)
.WithLoop(looping, loopStart, loopEnd);
Assert.Equal(sampleCount, adpcm.SampleCount);
}
protected GraphFile(IEnumerable <GraphAndUI <NodeUIData> > nodes, IEnumerable <NodeGroup> groups, ReadOnlyCollection <LoadError> errors, INodeFactory nodeFactory,
GenerateAudio generateAudio, Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDocumentSource, IAudioLibrary audioProvider)
{
Contract.Assert(getDocumentSource != null);
m_nodeFactory = nodeFactory;
m_generateAudio = generateAudio;
m_getDocumentSource = a => getDocumentSource(a, this);
m_audioProvider = audioProvider;
m_nodes = new CallbackList <ConversationNode>(nodes.Select(gnu => nodeFactory.MakeNode(gnu.GraphData, gnu.UIData)));
m_nodesLookup = new O1LookupWrapper <ConversationNode, Id <NodeTemp> >(m_nodes, n => n.Data.NodeId);
m_nodesOrdered = new SortedWrapper <ConversationNode>(m_nodes);
m_groups = new CallbackList <NodeGroup>(groups);
m_groupsOrdered = new SortedWrapper <NodeGroup>(m_groups);
m_errors = errors;
IEnumerable <IDynamicEnumParameter> localDynamicEnumerationParameters = m_nodes.SelectMany(n => n.Data.Parameters.OfType <IDynamicEnumParameter>());
foreach (var ldep in localDynamicEnumerationParameters)
{
ldep.MergeInto(m_getDocumentSource(ldep));
}
m_nodes.Inserting += M_nodes_Inserting;
m_nodes.Inserted += M_nodes_Inserted;
m_nodes.Removing += M_nodes_Removing;
m_nodes.Clearing += M_nodes_Clearing;
}
public void CombineThrowsWhenElementIsNull()
{
var audio = new AudioData(GenerateAudio.GeneratePcmSineWave(100, 1, 48000));
Exception ex = Record.Exception(() => AudioData.Combine(audio, null));
Assert.IsType <ArgumentException>(ex);
}
public void Setup()
{
_adpcm = GenerateAudio.GenerateAdpcmEmpty((int)(_sampleRate * LengthSeconds), ChannelCount, _sampleRate);
_brstm = new BrstmWriter().GetFile(_adpcm);
_dsp = new DspWriter().GetFile(_adpcm);
_idsp = new IdspWriter().GetFile(_adpcm);
}
public void AdpcmDataLengthIsCorrectAfterLooping(int sampleCount, bool looping, int loopStart, int loopEnd)
{
GcAdpcmFormat adpcm = GenerateAudio.GenerateAdpcmEmpty(sampleCount, 1, 48000)
.WithLoop(looping, loopStart, loopEnd);
Assert.Equal(SampleCountToByteCount(sampleCount), adpcm.Channels[0].GetAdpcmAudio().Length);
}
public void CreatingAudioDataWithInterface()
{
IAudioFormat adpcm = GenerateAudio.GenerateAdpcmSineWave(200, 2, 48000);
var audio = new AudioData(adpcm);
Assert.Same(adpcm, audio.GetFormat <GcAdpcmFormat>());
}
public void CreatingSeekTableFirstEntryIsZero()
{
short[] pcm = GenerateAudio.GenerateAscendingShorts(0, 50);
var seekTable = new GcAdpcmSeekTable(pcm, 10);
Assert.Equal(seekTable.SeekTable.Take(2), new short[] { 0, 0 });
}
public void CreatingAudioDataWithPcm()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(200, 2, 48000);
var audio = new AudioData(pcm);
Assert.Same(pcm, audio.GetFormat <Pcm16Format>());
}
public void LoopingBoolOnlyLoopsAllFormats()
{
var audio = new AudioData(GenerateAudio.GeneratePcmSineWave(100, 1, 48000));
audio.GetFormat <GcAdpcmFormat>();
audio.SetLoop(true);
var loopedAdpcm = audio.GetFormat <GcAdpcmFormat>();
var loopedPcm = audio.GetFormat <Pcm16Format>();
Assert.True(loopedAdpcm.Looping);
Assert.Equal(0, loopedAdpcm.LoopStart);
Assert.Equal(100, loopedAdpcm.LoopEnd);
Assert.True(loopedPcm.Looping);
Assert.Equal(0, loopedPcm.LoopStart);
Assert.Equal(100, loopedPcm.LoopEnd);
audio.SetLoop(false);
var unloopedAdpcm = audio.GetFormat <GcAdpcmFormat>();
var unloopedPcm = audio.GetFormat <Pcm16Format>();
Assert.False(unloopedAdpcm.Looping);
Assert.Equal(0, unloopedAdpcm.LoopStart);
Assert.Equal(0, unloopedAdpcm.LoopEnd);
Assert.False(unloopedPcm.Looping);
Assert.Equal(0, unloopedPcm.LoopStart);
Assert.Equal(0, unloopedPcm.LoopEnd);
}
public void AlignmentAlignsChildChannels()
{
GcAdpcmChannel[] channels = GenerateAudio.GenerateAdpcmChannelsEmpty(100, 2);
GcAdpcmFormat adpcm = GcAdpcmFormat.GetBuilder(channels, 32000).WithAlignment(15).WithLoop(true, 10, 100).Build();
Assert.All(adpcm.Channels, x => Assert.Equal(100, x.UnalignedSampleCount));
Assert.All(adpcm.Channels, x => Assert.Equal(105, x.SampleCount));
}
public void ChannelsAreSetAfterCreation()
{
GcAdpcmChannel[] channels = GenerateAudio.GenerateAdpcmChannelsEmpty(100, 2);
GcAdpcmFormat adpcm = GcAdpcmFormat.GetBuilder(channels, 32000).Build();
Assert.Equal(channels[0].Adpcm, adpcm.Channels[0].Adpcm);
Assert.Equal(channels[1].Adpcm, adpcm.Channels[1].Adpcm);
}
public void CreatingSeekTableContentIsCorrect()
{
short[] expected = { 0, 0, 50, 49, 100, 99 };
short[] pcm = GenerateAudio.GenerateAscendingShorts(0, 101);
var seekTable = new GcAdpcmSeekTable(pcm, 50);
Assert.Equal(expected, seekTable.SeekTable);
}
public void GettingChannelsThrowsWhenOutOfBounds()
{
GcAdpcmFormat adpcm = GenerateAudio.GenerateAdpcmSineWave(100, 4, 48000);
Exception ex = Record.Exception(() => adpcm.GetChannels(4, 0));
Assert.IsType <ArgumentException>(ex);
}
public void GettingSecondFormatFromFirst()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(200, 2, 48000);
var audio = new AudioData(pcm);
var adpcm = audio.GetFormat <GcAdpcmFormat>();
Assert.Same(adpcm, audio.GetFormat <GcAdpcmFormat>());
}
public void CombineThrowsWhenAudioCantBeCombined()
{
var audio = new AudioData(GenerateAudio.GeneratePcmSineWave(100, 1, 48000));
var audio2 = new AudioData(GenerateAudio.GeneratePcmSineWave(200, 1, 48000));
Exception ex = Record.Exception(() => AudioData.Combine(audio, audio2));
Assert.IsType <ArgumentException>(ex);
}
public void WavePcm8LoopedBuildAndParseEqual(int numChannels)
{
Pcm8Format audio = GenerateAudio.GeneratePcm8SineWave(BuildParseTestOptions.Samples, numChannels, BuildParseTestOptions.SampleRate).WithLoop(true);
var writer = new WaveWriter {
Configuration = { Codec = WaveCodec.Pcm8Bit }
};
BuildParseTests.BuildParseCompareAudio(audio, writer, new WaveReader());
}
public void BrstmBuildAndParseEqualPcm8(int numChannels)
{
Pcm8SignedFormat audio = GenerateAudio.GeneratePcm8SignedSineWave(BuildParseTestOptions.Samples, numChannels, BuildParseTestOptions.SampleRate);
var writer = new BrstmWriter {
Configuration = { Codec = NwCodec.Pcm8Bit }
};
BuildParseTests.BuildParseCompareAudio(audio, writer, new BrstmReader());
}
public void CloningAndModifyingDoesNotChangeFirstFormat()
{
GcAdpcmChannel[] channels = GenerateAudio.GenerateAdpcmChannelsEmpty(100, 2);
GcAdpcmFormat adpcm = GcAdpcmFormat.GetBuilder(channels, 32000).WithAlignment(15).WithLoop(true, 10, 100).Build();
GcAdpcmFormat unused = adpcm.GetCloneBuilder().WithAlignment(7).Build();
Assert.All(adpcm.Channels, x => Assert.Equal(100, x.UnalignedSampleCount));
Assert.All(adpcm.Channels, x => Assert.Equal(105, x.SampleCount));
}
public void TracksAreSetAfterCreation()
{
GcAdpcmChannel[] channels = GenerateAudio.GenerateAdpcmChannelsEmpty(100, 2);
var tracks = new List <AudioTrack> {
new AudioTrack(1, 0, 0), new AudioTrack(1, 1, 0)
};
GcAdpcmFormat adpcm = GcAdpcmFormat.GetBuilder(channels, 32000).WithTracks(tracks).Build();
Assert.Equal(tracks, adpcm.Tracks);
}
public void GetAllFormats()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
var audio = new AudioData(pcm);
Assert.Collection(audio.GetAllFormats(), x => Assert.True(x is Pcm16Format));
audio.GetFormat <GcAdpcmFormat>();
Assert.Collection(audio.GetAllFormats(), x => Assert.True(x is Pcm16Format), x => Assert.True(x is GcAdpcmFormat));
}
public void BcstmBuildAndParseEqualPcm16(int numChannels)
{
Pcm16Format audio = GenerateAudio.GeneratePcmSineWave(BuildParseTestOptions.Samples, numChannels, BuildParseTestOptions.SampleRate);
var writer = new BCFstmWriter(NwTarget.Ctr)
{
Configuration = { Codec = NwCodec.Pcm16Bit }
};
BuildParseTests.BuildParseCompareAudio(audio, writer, new BCFstmReader());
}
public void AdpcmDataLengthIsCorrectAfterAlignment(int sampleCount, bool looping, int loopStart, int loopEnd, int alignment)
{
GcAdpcmFormat adpcm = GenerateAudio.GenerateAdpcmEmpty(sampleCount, 1, 48000)
.WithAlignment(alignment)
.WithLoop(looping, loopStart, loopEnd);
int extraSamples = Helpers.GetNextMultiple(loopStart, alignment) - loopStart;
Assert.Equal(SampleCountToByteCount(loopEnd + extraSamples), adpcm.Channels[0].GetAdpcmAudio().Length);
}
public void AdpcmLoopIsCorrectAfterUnalignment(int sampleCount, bool looping, int loopStart, int loopEnd, int alignment)
{
IAudioFormat adpcm = GenerateAudio.GenerateAdpcmEmpty(sampleCount, 1, 48000)
.WithAlignment(alignment)
.WithLoop(looping, loopStart, loopEnd)
.WithAlignment(0);
Assert.Equal(loopStart, adpcm.LoopStart);
Assert.Equal(loopEnd, adpcm.LoopEnd);
}
public void GettingSpecificChannels()
{
GcAdpcmFormat adpcm = GenerateAudio.GenerateAdpcmSineWave(100, 4, 48000);
GcAdpcmFormat partial = adpcm.GetChannels(2, 0, 2);
Assert.Equal(100, partial.SampleCount);
Assert.Equal(3, partial.ChannelCount);
Assert.Equal(adpcm.Channels[2], partial.Channels[0], new GcAdpcmChannelComparer());
Assert.Equal(adpcm.Channels[0], partial.Channels[1], new GcAdpcmChannelComparer());
Assert.Equal(adpcm.Channels[2], partial.Channels[2], new GcAdpcmChannelComparer());
}
public void AddingFormatsOfDifferentLengthThrows()
{
GcAdpcmChannel[] channels = GenerateAudio.GenerateAdpcmSineWave(100, 2, 48000).Channels;
GcAdpcmChannel[] channels2 = GenerateAudio.GenerateAdpcmSineWave(200, 2, 48000).Channels;
var adpcm = new GcAdpcmFormat(new[] { channels[0] }, 48000);
var adpcm2 = new GcAdpcmFormat(new[] { channels2[1] }, 48000);
Exception ex = Record.Exception(() => adpcm.Add(adpcm2));
Assert.IsType <ArgumentException>(ex);
}
public void AddingFormatsTogether()
{
GcAdpcmChannel[] channels = GenerateAudio.GenerateAdpcmSineWave(100, 2, 48000).Channels;
var adpcm = new GcAdpcmFormat(new[] { channels[0] }, 48000);
var adpcm2 = new GcAdpcmFormat(new[] { channels[1] }, 48000);
GcAdpcmFormat combined = adpcm.Add(adpcm2);
Assert.Equal(adpcm.Channels[0], combined.Channels[0], new GcAdpcmChannelComparer());
Assert.Equal(adpcm2.Channels[0], combined.Channels[1], new GcAdpcmChannelComparer());
}
public void LoopsProperlyAfterDecoding(int sampleCount, bool looping, int loopStart, int loopEnd)
{
GcAdpcmFormat adpcm = GenerateAudio.GenerateAdpcmEmpty(sampleCount, 1, 48000)
.WithLoop(looping, loopStart, loopEnd);
IAudioFormat pcm = adpcm.ToPcm16();
Assert.Equal(looping, pcm.Looping);
Assert.Equal(loopStart, pcm.LoopStart);
Assert.Equal(loopEnd, pcm.LoopEnd);
}
public void LoopsProperlyAfterEncoding(int sampleCount, bool looping, int loopStart, int loopEnd)
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(sampleCount, 1, 48000)
.WithLoop(looping, loopStart, loopEnd);
IAudioFormat adpcm = new GcAdpcmFormat().EncodeFromPcm16(pcm);
Assert.Equal(looping, adpcm.Looping);
Assert.Equal(loopStart, adpcm.LoopStart);
Assert.Equal(loopEnd, adpcm.LoopEnd);
}
public void AdpcmLoopIsCorrectAfterAlignment(int sampleCount, bool looping, int loopStart, int loopEnd, int alignment)
{
IAudioFormat adpcm = GenerateAudio.GenerateAdpcmEmpty(sampleCount, 1, 48000)
.WithAlignment(alignment)
.WithLoop(looping, loopStart, loopEnd);
int extraSamples = Helpers.GetNextMultiple(loopStart, alignment) - loopStart;
Assert.Equal(loopStart + extraSamples, adpcm.LoopStart);
Assert.Equal(loopEnd + extraSamples, adpcm.LoopEnd);
}
public void AddSameFormats()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
Pcm16Format pcm2 = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
var audio = new AudioData(pcm);
var audio2 = new AudioData(pcm2);
AudioData combined = AudioData.Combine(audio, audio2);
var pcmCombined = combined.GetFormat <Pcm16Format>();
Assert.Same(pcm.Channels[0], pcmCombined.Channels[0]);
Assert.Same(pcm2.Channels[0], pcmCombined.Channels[1]);
Assert.Equal(2, pcmCombined.ChannelCount);
}
