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 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 CreatingAudioDataWithInterface()
{
IAudioFormat adpcm = GenerateAudio.GenerateAdpcmSineWave(200, 2, 48000);
var audio = new AudioData(adpcm);
Assert.Same(adpcm, audio.GetFormat <GcAdpcmFormat>());
}
public void CreatingAudioDataWithPcm()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(200, 2, 48000);
var audio = new AudioData(pcm);
Assert.Same(pcm, audio.GetFormat <Pcm16Format>());
}
protected override void SetupWriter(AudioData audio)
{
var encodingConfig = new CriHcaParameters
{
Progress = Configuration.Progress,
Bitrate = Configuration.Bitrate,
LimitBitrate = Configuration.LimitBitrate
};
if (Configuration.Quality != CriHcaQuality.NotSet)
{
encodingConfig.Quality = Configuration.Quality;
}
var hcaFormat = audio.GetFormat <CriHcaFormat>(encodingConfig);
Hca = hcaFormat.Hca;
AudioData = hcaFormat.AudioData;
if (Configuration.EncryptionKey != null)
{
CriHcaEncryption.Crypt(Hca, AudioData, Configuration.EncryptionKey, false);
Hca.EncryptionType = Configuration.EncryptionKey.KeyType;
}
}
protected override void SetupWriter(AudioData audio)
{
Adpcm = audio.GetFormat <GcAdpcmFormat>(new GcAdpcmParameters {
Progress = Configuration.Progress
});
int channelSize = GetNextMultiple(MaxBlockSize / ChannelCount - 0x20, 0x20);
MaxBlockSizeActual = channelSize * ChannelCount;
int alignment = ByteCountToSampleCount(channelSize);
if (!LoopPointsAreAligned(Adpcm.LoopStart, alignment))
{
Adpcm = Adpcm.GetCloneBuilder().WithAlignment(alignment).Build();
}
Parallel.For(0, ChannelCount, i =>
{
GcAdpcmChannelBuilder builder = Adpcm.Channels[i].GetCloneBuilder();
builder.LoopAlignmentMultiple = alignment;
builder.EnsureLoopContextIsSelfCalculated = true;
Adpcm.Channels[i] = builder.Build();
});
BlockMap = CreateBlockMap(Adpcm.SampleCount, Adpcm.Looping, Adpcm.LoopStart, Adpcm.ChannelCount, MaxBlockSizeActual);
}
protected override void SetupWriter(AudioData audio)
{
var parameters = new GcAdpcmParameters {
Progress = Configuration.Progress
};
if (Codec == NwCodec.GcAdpcm)
{
Adpcm = audio.GetFormat <GcAdpcmFormat>(parameters);
AudioFormat = Adpcm;
}
else if (Codec == NwCodec.Pcm16Bit)
{
Pcm16 = audio.GetFormat <Pcm16Format>(parameters);
AudioFormat = Pcm16;
}
}
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));
}
protected override void SetupWriter(AudioData audio)
{
var encodingConfig = new OpusParameters
{
Bitrate = Configuration.Bitrate,
Progress = Configuration.Progress
};
Format = audio.GetFormat <OpusFormat>(encodingConfig);
}
protected override void SetupWriter(AudioData audio)
{
Adpcm = audio.GetFormat <GcAdpcmFormat>(new GcAdpcmParameters {
Progress = Configuration.Progress
});
if (Configuration.BlockSize != 0)
{
Adpcm = Adpcm.WithAlignment(ByteCountToSampleCount(Configuration.BlockSize));
}
}
protected override void SetupWriter(AudioData audio)
{
var parameters = new GcAdpcmParameters {
Progress = Configuration.Progress
};
if (Codec == NwCodec.GcAdpcm)
{
Adpcm = audio.GetFormat <GcAdpcmFormat>(parameters);
if (!LoopPointsAreAligned(Adpcm.LoopStart, Configuration.LoopPointAlignment))
{
Adpcm = Adpcm.GetCloneBuilder().WithAlignment(Configuration.LoopPointAlignment).Build();
}
Parallel.For(0, Adpcm.ChannelCount, i =>
{
GcAdpcmChannelBuilder builder = Adpcm.Channels[i].GetCloneBuilder()
.WithSamplesPerSeekTableEntry(SamplesPerSeekTableEntry)
.WithLoop(Adpcm.Looping, Adpcm.UnalignedLoopStart, Adpcm.UnalignedLoopEnd);
builder.LoopAlignmentMultiple = Configuration.LoopPointAlignment;
builder.EnsureLoopContextIsSelfCalculated = Configuration.RecalculateLoopContext;
builder.EnsureSeekTableIsSelfCalculated = Configuration.RecalculateSeekTable;
Adpcm.Channels[i] = builder.Build();
});
AudioFormat = Adpcm;
Tracks = Adpcm.Tracks;
}
else if (Codec == NwCodec.Pcm16Bit)
{
Pcm16 = audio.GetFormat <Pcm16Format>(parameters);
AudioFormat = Pcm16;
Tracks = Pcm16.Tracks;
}
else if (Codec == NwCodec.Pcm8Bit)
{
Pcm8 = audio.GetFormat <Pcm8SignedFormat>(parameters);
AudioFormat = Pcm8;
Tracks = Pcm8.Tracks;
}
}
protected override void SetupWriter(AudioData audio)
{
var parameters = new CodecParameters {
Progress = Configuration.Progress
};
switch (Codec)
{
case WaveCodec.Pcm16Bit:
Pcm16 = audio.GetFormat <Pcm16Format>(parameters);
AudioFormat = Pcm16;
break;
case WaveCodec.Pcm8Bit:
Pcm8 = audio.GetFormat <Pcm8Format>(parameters);
AudioFormat = Pcm8;
break;
}
}
protected override void SetupWriter(AudioData audio)
{
var encodingConfig = new OpusParameters
{
Bitrate = Configuration.Bitrate,
Progress = Configuration.Progress
};
Format = audio.GetFormat <OpusFormat>(encodingConfig);
Format.EnsureHasFinalRange();
DataSize = Format.Frames.Sum(x => x.Length + 8);
}
public void AddSameFormatsAfterEncodingChoosesEncodedFormat()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
Pcm16Format pcm2 = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
var audio = new AudioData(pcm);
var audio2 = new AudioData(pcm2);
var adpcm = audio.GetFormat <GcAdpcmFormat>();
var adpcm2 = audio2.GetFormat <GcAdpcmFormat>();
AudioData combined = AudioData.Combine(audio, audio2);
Assert.Collection(combined.GetAllFormats(), x => Assert.True(x is GcAdpcmFormat));
var pcmCombined = combined.GetFormat <Pcm16Format>();
var adpcmCombined = combined.GetFormat <GcAdpcmFormat>();
Assert.Same(adpcm.Channels[0].GetAdpcmAudio(), adpcmCombined.Channels[0].GetAdpcmAudio());
Assert.Same(adpcm2.Channels[0].GetAdpcmAudio(), adpcmCombined.Channels[1].GetAdpcmAudio());
Assert.NotSame(pcm.Channels[0], pcmCombined.Channels[0]);
Assert.NotSame(pcm2.Channels[0], pcmCombined.Channels[1]);
Assert.Equal(2, adpcmCombined.ChannelCount);
}
public void ListAvailableFormats()
{
var expected = new List <Type> {
typeof(Pcm16Format)
};
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
var audio = new AudioData(pcm);
Assert.Equal(expected, audio.ListAvailableFormats());
expected.Add(typeof(GcAdpcmFormat));
audio.GetFormat <GcAdpcmFormat>();
Assert.Equal(expected, audio.ListAvailableFormats());
}
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);
}
public void AddDifferentFormats()
{
Pcm16Format pcm = GenerateAudio.GeneratePcmSineWave(100, 1, 48000);
GcAdpcmFormat adpcm = GenerateAudio.GenerateAdpcmSineWave(100, 1, 48000);
var audio = new AudioData(pcm);
var audio2 = new AudioData(adpcm);
AudioData combined = AudioData.Combine(audio, audio2);
Assert.Collection(combined.GetAllFormats(), x => Assert.True(x is Pcm16Format));
var pcmCombined = combined.GetFormat <Pcm16Format>();
Assert.Same(pcm.Channels[0], pcmCombined.Channels[0]);
Assert.Equal(2, pcmCombined.ChannelCount);
}
protected override void SetupWriter(AudioData audio)
{
var encodingConfig = new CriAdxParameters
{
Progress = Configuration.Progress,
Version = Configuration.Version,
FrameSize = Configuration.FrameSize,
Filter = Configuration.Filter,
Type = Configuration.Type
};
Adpcm = audio.GetFormat <CriAdxFormat>(encodingConfig);
if (Adpcm.Looping)
{
CalculateAlignmentBytes();
}
}
protected override void SetupWriter(AudioData audio)
{
var encodingConfig = new CriHcaParameters
{
Progress = Configuration.Progress,
Bitrate = Configuration.Bitrate,
LimitBitrate = Configuration.LimitBitrate
};
if (Configuration.Quality != CriHcaQuality.NotSet)
{
encodingConfig.Quality = Configuration.Quality;
}
var hcaFormat = audio.GetFormat <CriHcaFormat>(encodingConfig);
Hca = hcaFormat.Hca;
AudioData = hcaFormat.AudioData;
}
public void AddDifferentFormatsMultipleInputs()
{
Pcm16Format pcmFormat = GenerateAudio.GeneratePcmSineWave(100, 4, 48000);
Pcm16Format pcm0 = pcmFormat.GetChannels(0);
Pcm16Format pcm1 = pcmFormat.GetChannels(1, 2);
Pcm16Format pcm2 = pcmFormat.GetChannels(3);
var audio0 = new AudioData(pcm0);
var audio1 = new AudioData(pcm1);
var audio2 = new AudioData(pcm2);
audio0.GetFormat <GcAdpcmFormat>();
audio2.GetFormat <GcAdpcmFormat>();
AudioData combined = AudioData.Combine(audio0, audio1, audio2);
Assert.Collection(combined.GetAllFormats(), x => Assert.True(x is Pcm16Format));
var pcmCombined = combined.GetFormat <Pcm16Format>();
Assert.Equal(4, pcmCombined.ChannelCount);
Assert.Same(pcm0.Channels[0], pcmCombined.Channels[0]);
Assert.Same(pcm1.Channels[0], pcmCombined.Channels[1]);
Assert.Same(pcm1.Channels[1], pcmCombined.Channels[2]);
Assert.Same(pcm2.Channels[0], pcmCombined.Channels[3]);
}
protected override void SetupWriter(AudioData audio)
{
Adpcm = audio.GetFormat <GcAdpcmFormat>(new GcAdpcmParameters {
Progress = Configuration.Progress
});
}
