int mergeFiles(){
clock_t start, end;
start = clock();
int rounds=0;
bool flag=1;
while(flag) { //keep merging until number of file less than 2
int fileCount = 0;
int fileNextCount = 0;
while(1) { // one round of merge
string dataPath1 = basePath + "interFile_data_"+int2str(rounds)+"_"+int2str(fileCount);
string indexPath1 = basePath+"interFile_index_"+int2str(rounds)+"_"+int2str(fileCount++);
string dataPath2 = basePath +"interFile_data_"+int2str(rounds)+"_"+int2str(fileCount);
string indexPath2 = basePath + "interFile_index_"+int2str(rounds)+"_"+int2str(fileCount++);
string outputDataPath = basePath + "interFile_data_"+int2str(rounds+1)+"_"+int2str(fileNextCount);
string outputIndexPath = basePath + "interFile_index_"+int2str(rounds+1)+"_"+int2str(fileNextCount++);
cout<<dataPath1<<" "<<dataPath2<<endl;
Merge M;
int fileOpened = M.initial(dataPath1,dataPath2,indexPath1,indexPath2);
if(fileOpened<4 ){
M.close();
if( fileCount == 2 ){
flag =0;
cout <<"All merged"<<endl;
}
else {
cout <<"One round Complete."<<endl;
if(fileOpened == 2){
ifstream inputData(dataPath1,ios::binary);
ifstream inputIndex(indexPath1);
ofstream outputData(outputDataPath);
ofstream outputIndex(outputIndexPath);
outputData<<inputData.rdbuf();
outputIndex<<inputIndex.rdbuf();
inputData.close();
inputIndex.close();
outputData.close();
outputIndex.close();
}
rounds++;
}
break;
}
M.setOutput(outputDataPath, outputIndexPath);
M.readIndex();
M.startMerging();
M.close();
}
}
end = clock();
double duration = (double) (end - start)/CLOCKS_PER_SEC;
cout << "time cost is = "<<duration<<endl;
return 0;
}
void CorrelationUGenInternal::processBlock(bool& shouldDelete, const unsigned int blockID, const int channel) throw()
{
const int blockSize = uGenOutput.getBlockSize();
int numSamplesToProcess = blockSize;
float* inputASamples = inputs[InputA].processBlock(shouldDelete, blockID, channel);
float* inputBSamples = inputs[InputB].processBlock(shouldDelete, blockID, channel);
float* outputSamples = uGenOutput.getSampleData();
float* const windowsSamples = window.getDataUnchecked(0);
float* const scoreSamples = score.getDataUnchecked(0);
float* const bufferASamples = buffers.getDataUnchecked(InputBufferA);
float* const bufferBSamples = buffers.getDataUnchecked(InputBufferB);
float* const outputBufferSamples = buffers.getDataUnchecked(OutputBuffer);
while(numSamplesToProcess > 0)
{
int bufferSamplesToProcess = length_ - bufferIndex;
if(bufferSamplesToProcess > numSamplesToProcess)
{
// buffer the inputs
memcpy(bufferASamples + bufferIndex, inputASamples, numSamplesToProcess * sizeof(float));
memcpy(bufferBSamples + bufferIndex, inputBSamples, numSamplesToProcess * sizeof(float));
bufferIndex += numSamplesToProcess;
inputASamples += numSamplesToProcess;
inputBSamples += numSamplesToProcess;
// ...and the output - output the lockedIndexOfMax into the outputSamples
outputIndex(outputSamples, numSamplesToProcess);
// outputBuffer(outputSamples, numSamplesToProcess);
// outputScore(outputSamples, numSamplesToProcess);
outputSamples += numSamplesToProcess;
numSamplesToProcess = 0;
}
else
{
numSamplesToProcess -= bufferSamplesToProcess;
memcpy(bufferASamples + bufferIndex, inputASamples, bufferSamplesToProcess * sizeof(float));
memcpy(bufferBSamples + bufferIndex, inputBSamples, bufferSamplesToProcess * sizeof(float));
memset(outputBufferSamples, 0, (length_ + length_) * sizeof(float));
//apply windows
for (int i = 0; i < length_; i++)
{
bufferASamples[i] *= windowsSamples[i];
bufferBSamples[i] *= windowsSamples[i];
}
bufferIndex += bufferSamplesToProcess;
inputASamples += bufferSamplesToProcess;
inputBSamples += bufferSamplesToProcess;
vDSP_conv (bufferASamples, 1,
bufferBSamples, 1,
outputBufferSamples, 1,
length_, length_);
for (int i = 0; i < length_; i++)
scoreSamples[i] *= 0.9f;
indexOfMax = findPeak(outputBufferSamples, length_);
if ((indexOfMax >= 0) && (indexOfMax < length_))
{
if (lockedIndexOfMax >= 0)
{
int diff = indexOfMax - lockedIndexOfMax;
if (diff < 0)
diff = -diff;
int maximum = length_ / 4;
diff = ugen::min(diff, maximum);
int score = maximum - diff;
float fScore = (float)score / maximum;
fScore = ugen::cubed(fScore);
scoreSamples[indexOfMax] += fScore;
}
else
{
scoreSamples[indexOfMax] += 1.f;
}
}
lockedIndexOfMax = findPeak(scoreSamples, length_);
// output the lockedIndexOfMax into the outputSamples
outputIndex(outputSamples, bufferSamplesToProcess);
// outputBuffer(outputSamples, bufferSamplesToProcess);
// outputScore(outputSamples, bufferSamplesToProcess);
outputSamples += bufferSamplesToProcess;
bufferSamplesToProcess = 0;
bufferIndex = 0;
}
}
}
