public void SetPlayMusicInformation(PlayMusicInformation aPlayMusicInformation)
{
scrollPosition = Vector2.zero;
x = 0;
y = 0;
playMusicInformation = aPlayMusicInformation;
if (playMusicInformation != null)
{
loopArrayArray = new LoopInformation[playMusicInformation.music.GetCountLoopX()][];
for (int i = 0; i < playMusicInformation.music.GetCountLoopX(); i++)
{
loopArrayArray[i] = new LoopInformation[playMusicInformation.music.GetCountLoopY(i)];
for (int j = 0; j < playMusicInformation.music.GetCountLoopY(i); j++)
{
loopArrayArray[i][j] = playMusicInformation.music.GetLoop(i, j);
}
}
}
else
{
loopArrayArray = null;
}
}
public static void Execute(string aFilePathOutput, LoopInformation aLoopInformation)
{
RiffWaveRiff lRiffWaveRiff = ( RiffWaveRiff )PoolCollection.GetRiffWave(aFilePathOutput);
WaveformReaderPcm waveform = new WaveformReaderPcm(lRiffWaveRiff, true);
OverrideCuePoint(lRiffWaveRiff, ( int )aLoopInformation.start.sample, ( int )aLoopInformation.end.sample);
OverrideSampleLoop(lRiffWaveRiff, ( int )aLoopInformation.start.sample, ( int )aLoopInformation.end.sample);
Byte[] lDataArrayRead = null;
RiffWaveData dataChunk = ( RiffWaveData )lRiffWaveRiff.GetChunk(RiffWaveData.ID);
using (FileStream u = new FileStream(lRiffWaveRiff.name, FileMode.Open, FileAccess.Read))
{
AByteArray l = new ByteArrayLittle(u);
int bytePosition = ( int )dataChunk.position;
l.SetPosition(bytePosition);
lDataArrayRead = l.ReadBytes(dataChunk.Size);
}
Byte[] lDataArrayWrite = lDataArrayRead;
if (IsCutLast == true)
{
int lLength = ( int )(aLoopInformation.end.sample + 1) * waveform.format.channels * (waveform.format.sampleBits / 8);
Logger.BreakDebug("End:" + aLoopInformation.end.sample);
lDataArrayWrite = new Byte[lLength];
for (int i = 0; i < lLength; i++)
{
lDataArrayWrite[i] = lDataArrayRead[i];
}
}
SetDataArray(lRiffWaveRiff, lDataArrayWrite);
MemoryStream lMemoryStreamWrite = new MemoryStream(( int )lRiffWaveRiff.Size + 8);
ByteArrayLittle lByteArray = new ByteArrayLittle(lMemoryStreamWrite);
lRiffWaveRiff.WriteByteArray(lByteArray);
Logger.BreakDebug("WriteByteArray");
Logger.BreakDebug("Out:" + aFilePathOutput);
try
{
using (FileStream u = new FileStream(aFilePathOutput, FileMode.Create, FileAccess.Write, FileShare.Read))
{
u.Write(lMemoryStreamWrite.GetBuffer(), 0, ( int )lMemoryStreamWrite.Length);
}
}
catch (Exception aExpection)
{
Logger.BreakError("Write Exception:" + aExpection);
}
}
public void Change(LoopInformation aLoopInformation)
{
Vector3[] lVertices = meshFilter.mesh.vertices;
int diff = ( int )aLoopInformation.length.sample;
for (int i = 0; i < Screen.width; i++)
{
sbyte lMax = 0;
sbyte lMin = 0;
sbyte lMaxRight = 0;
sbyte lMinRight = 0;
for (int j = ( int )(waveform.Length / Screen.width * i); j < waveform.Length / Screen.width * (i + 1); j += 20)
{
int lIndexRight = j - ( int )aLoopInformation.length.sample;
if (j >= 0 && j < waveform.Length)
{
sbyte lValue = waveform[j];
if (lValue > lMax)
{
lMax = lValue;
}
if (lValue < lMin)
{
lMin = lValue;
}
}
if (lIndexRight >= 0 && lIndexRight < waveform.Length)
{
sbyte lValue = waveform[lIndexRight];
if (lValue > lMaxRight)
{
lMaxRight = lValue;
}
if (lValue < lMinRight)
{
lMinRight = lValue;
}
}
}
double lX = -Screen.width / 2.0d + i;
double lY = Screen.height / 2.0d - 1.0d - 130.0d;
lVertices[i * 2 + 0] = new Vector3(( float )lX, ( float )(lY + ( float )lMax / 16.0f), 0.0f);
lVertices[i * 2 + 1] = new Vector3(( float )lX, ( float )(lY + ( float )lMin / 16.0f), 0.0f);
}
meshFilter.mesh.vertices = lVertices;
meshFilter.mesh.RecalculateBounds();
}
public MusicAdx(AdxFile aAdxFile)
{
Channels = aAdxFile.GetAdxHeader().GetChannelLength();
SampleLength = ( int )aAdxFile.GetAdxHeader().GetSampleLength();
SampleRate = ( int )aAdxFile.GetAdxHeader().GetSampleRate();
Loop[0][0] = new LoopInformation(SampleRate, ( int )aAdxFile.GetAdxHeader().GetSampleLoopStart(), ( int )aAdxFile.GetAdxHeader().GetSampleLoopEnd());
sampleArray = aAdxFile.GetSampleArray();
}
public ViewLoopDisplay(LoopInformation aLoop)
{
loop = aLoop;
captions = new string[3] {
"min:sec.msec", "msec.", "samples"
};
grid = 0;
}
public void SetLoop(LoopInformation aLoopInformation)
{
if (aLoopInformation.length.sample != player.Loop.length.sample)
{
componentWaveform.ChangeLoop(aLoopInformation, scale, positionWaveform);
}
player.SetLoop(aLoopInformation);
componentWaveform.UpdateVertex(player, scale, positionWaveform);
}
public SynthesizerPcm(WaveformReaderPcm aWaveform, LoopInformation aLoop)
{
waveform = aWaveform;
oneSampelList = new Dictionary <int, SoundTime>();
Position = new SoundTime(waveform.format.sampleRate, 0);
Elapsed = new SoundTime(waveform.format.sampleRate, 0);
loop = aLoop;
isLoop = false;
}
public LoopInformation GetLoopPoint()
{
LoopInformation lLoopPoint = player.GetLoopPoint();
if (lLoopPoint == null)
{
lLoopPoint = new LoopInformation(44100, 0, 0);
}
return(lLoopPoint);
}
private void PlayMusic(string aFilePath)
{
if (componentPlaylist.musicInformationDictionary.ContainsKey(aFilePath) == true)
{
bool lIsMute = player.IsMute;
bool lIsLoop = player.IsLoop;
float lVolume = player.Volume;
player = ConstructorCollection.ConstructPlayer(aFilePath);
player.IsMute = lIsMute;
player.IsLoop = lIsLoop;
player.Volume = lVolume;
componentLoopEditor.SetPlayer(player, componentPlaylist.musicInformationDictionary[aFilePath]);
componentLoopPlayer.SetPlayer(player);
componentLoopSelector.SetPlayMusicInformation(componentPlaylist.musicInformationDictionary[aFilePath]);
}
else
{
if (componentInputlist.musicInformationDictionary.ContainsKey(aFilePath) == true)
{
IMusic lMusic = componentInputlist.musicInformationDictionary[aFilePath].music;
LoopInformation lLoop = componentInputlist.musicInformationDictionary[aFilePath].music.Loop;
PlayMusicInformation l = new PlayMusicInformation(0, false, lMusic, lLoop);
bool lIsMute = player.IsMute;
bool lIsLoop = player.IsLoop;
float lVolume = player.Volume;
player = ConstructorCollection.ConstructPlayer(aFilePath);
player.IsMute = lIsMute;
player.IsLoop = lIsLoop;
player.Volume = lVolume;
componentLoopEditor.SetPlayer(player, l);
componentLoopPlayer.SetPlayer(player);
componentLoopSelector.SetPlayMusicInformation(l);
}
}
componentLoopEditor.UpdateMesh();
}
private void Execute()
{
for (int i = 0; i < componentPlaylist.filePathList.Count; i++)
{
string lFilePathOutput = componentPlaylist.filePathList[i];
if (componentPlaylist.musicInformationDictionary.ContainsKey(lFilePathOutput) == true && componentPlaylist.musicInformationDictionary[lFilePathOutput].isSelected == true)
{
LoopInformation lLoopInformation = componentPlaylist.musicInformationDictionary[lFilePathOutput].music.Loop;
Logger.BreakDebug("Loop:" + lLoopInformation.start.sample + ", " + lLoopInformation.end.sample + ", " + lLoopInformation.length.sample);
LoopSave.Execute(lFilePathOutput, lLoopInformation);
componentPlaylist.musicInformationDictionary[lFilePathOutput].isSelected = false;
}
}
isOnSave = false;
}
public MusicPcm(RiffWaveRiff aRiffFile)
{
Name = aRiffFile.name;
Waveform = new WaveformReaderPcm(aRiffFile, false);
Length = new SoundTime(Waveform.format.sampleRate, Waveform.format.samples);
RiffWaveSmpl lRiffWaveSmpl = ( RiffWaveSmpl )aRiffFile.GetChunk(RiffWaveSmpl.ID);
if (lRiffWaveSmpl != null)
{
loopList = new List <List <LoopInformation> >();
int lIndex = -1;
int lLoopLength = -1;
for (int i = 0; i < lRiffWaveSmpl.sampleLoops; i++)
{
SampleLoop lLoop = lRiffWaveSmpl.sampleLoopList[i];
if (( int )(lLoop.end - lLoop.start) == lLoopLength)
{
}
else
{
loopList.Add(new List <LoopInformation>());
lLoopLength = ( int )(lLoop.end - lLoop.start);
lIndex++;
}
loopList[lIndex].Add(new LoopInformation(Length.sampleRate, ( int )lLoop.start, ( int )lLoop.end));
}
}
else
{
loopList = new List <List <LoopInformation> >();
loopList.Add(new List <LoopInformation>());
loopList[0].Add(new LoopInformation(Length.sampleRate, -1, -1));
}
Loop = GetLoop(0, 0);
}
public void ChangeLoop(LoopInformation aLoopInformation, float scale, float positionWaveform)
{
Vector3[] lVerticesRight = meshFilterDetailRight.mesh.vertices;
int diff = ( int )aLoopInformation.length.sample; // % ( waveform.Length / Screen.width );
for (int i = 0; i < Screen.width; i++)
{
sbyte lMaxRight = 0;
sbyte lMinRight = 0;
for (int j = ( int )(waveform.Length / Screen.width * i / scale); j < waveform.Length / Screen.width * (i + 1) / scale; j += ( int )Math.Ceiling(20.0d / scale))
{
int lIndexRight = ( int )(waveform.Length * positionWaveform + j - diff);
if (lIndexRight >= 0 && lIndexRight < waveform.Length)
{
sbyte lValue = waveform[lIndexRight];
if (lValue > lMaxRight)
{
lMaxRight = lValue;
}
if (lValue < lMinRight)
{
lMinRight = lValue;
}
}
}
double lX = -Screen.width / 2.0d + i;
double lY = Screen.height / 2.0d - 1.0d - GuiSettings.GuiSettingLoopEditor.seekbarTop - GuiStyleSet.StylePlayer.seekbar.fixedHeight / 2.0d;
lVerticesRight[i * 2 + 0] = new Vector3(( float )lX, ( float )(lY + ( float )lMaxRight / 4.0f), 0.0f);
lVerticesRight[i * 2 + 1] = new Vector3(( float )lX, ( float )(lY + ( float )lMinRight / 4.0f), 0.0f);
}
meshFilterDetailRight.mesh.vertices = lVerticesRight;
meshFilterDetailRight.mesh.RecalculateBounds();
}
public void Update(float[] aSoundBuffer, int aChannels, int aSampleRate)
{
LoopInformation lLoop = music.Loop[loopNumber1][loopNumber2];
if (lLoop.start.sample != 0 && lLoop.end.sample != 0 && ( int )timePosition.sample > lLoop.end.sample)
{
Logger.LogDebug("Start:" + lLoop.start.sample + ", End:" + lLoop.end.sample);
double diff = timePosition.sample % 1.0d;
timePosition.sample = ( int )lLoop.start.sample + diff;
}
if (( int )timePosition.sample + 1 < music.SampleLength)
{
for (int i = 0; i < aChannels; i++)
{
aSoundBuffer[i] = MeanInterpolation.Calculate(music, i, timePosition.sample);
}
}
else if (( int )timePosition.sample < music.SampleLength)
{
for (int i = 0; i < aChannels; i++)
{
aSoundBuffer[i] = MeanInterpolation.Calculate(music, i, timePosition.sample, ( int )lLoop.start.sample);
}
}
else
{
timePosition.sample = 0.0d;
}
if (timePosition.sample == 1)
{
Logger.LogDebug("Start:" + aSoundBuffer[0]);
}
timePosition.sample += ( double )music.SampleRate / ( double )aSampleRate;
timeElapsed.sample += ( double )music.SampleRate / ( double )aSampleRate;
}
public void SetLoop(LoopInformation aLoopInformation, int aSampleLength, double scale, double offset)
{
int[] lIndices = meshFilter.mesh.GetIndices(0);
int lStart = ( int )((aLoopInformation.start.sample / aSampleLength - offset) * Screen.width * scale);
int lEnd = ( int )((aLoopInformation.end.sample / aSampleLength - offset) * Screen.width * scale);
for (int i = 0; i < lIndices.Length / 2; i++)
{
if (i > lStart && i <= lEnd)
{
lIndices[i * 2 + 0] = i * 2 + 0;
lIndices[i * 2 + 1] = i * 2 + 1;
}
else
{
lIndices[i * 2 + 0] = lIndices[lIndices.Length - 1];
lIndices[i * 2 + 1] = lIndices[lIndices.Length - 1];
}
}
meshFilter.mesh.SetIndices(lIndices, MeshTopology.Lines, 0);
meshFilter.mesh.RecalculateBounds();
}
public void SetLoop(LoopInformation aLoopInformation)
{
}
public void SetLoop(LoopInformation aLoopInformation)
{
Loop = aLoopInformation;
Music.Loop = Loop;
}
