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); }