//resampler <wav in> <wav out> <pitch> <velocity> <flags>
int main(int ArgQ, char** ArgList)
{
CDSP2_SetArch(CDSP2_Arch_Gnrc);
CDSP2_SetDebugOn(CDSP2_Debug_Check);
printf("Sleepwalking's toy resampler v0.1.\n");
printf("Powered by Rocaloid's subprojects: CVESVP, CVEDSP2, and RFNL.\n");
String OutputPath, InputPath, StrPitch, StrVelocity, StrFlags, StrOffset,
StrLength;
RNew(String, & OutputPath, & InputPath, & StrPitch, & StrVelocity,
& StrFlags, & StrOffset, & StrLength);
if(ArgQ < 4)
{
printf("Wrong number of Arguments.\n");
return 1;
}
String_SetChars(& InputPath, ArgList[1]);
String_SetChars(& OutputPath, ArgList[2]);
String_SetChars(& StrPitch, ArgList[3]);
String_SetChars(& StrVelocity, "100");
String_SetChars(& StrFlags, "");
String_SetChars(& StrOffset, "0");
String_SetChars(& StrLength, "-1");
if(ArgQ > 4)
String_SetChars(& StrVelocity, ArgList[4]);
if(ArgQ > 5)
String_SetChars(& StrFlags, ArgList[5]);
if(ArgQ > 6)
String_SetChars(& StrOffset, ArgList[6]);
if(ArgQ > 7)
String_SetChars(& StrLength, ArgList[7]);
number Fundamental = FreqFromPitch(& StrPitch);
number Velocity = CNumberStr(& StrVelocity);
int Length = CIntStr(& StrLength);
if(Fundamental < 50)
{
printf("Wrong pitch.\n");
return 1;
}
/*
printf("resampler (in)%s (out)%s (pitch)%s (vel)%s (flags)%s (offset)%s "
"(length)%s\n",
String_GetChars(& InputPath), String_GetChars(& OutputPath),
String_GetChars(& StrPitch), String_GetChars(& StrVelocity),
String_GetChars(& StrFlags), String_GetChars(& StrOffset),
String_GetChars(& StrLength));
*/
Wave InWave, OutWave;
FWindow_T DyWin;
PSOLAIterlyzer PAna;
PSOLAItersizer PSyn;
List_DataFrame DataList;
number* HannWind = RCall(RAlloc, number)(2048);
RNew(Wave, & InWave, & OutWave);
RNew(PSOLAIterlyzer, & PAna);
RNew(PSOLAItersizer, & PSyn);
RNew(List_DataFrame, & DataList);
RCall(CDSP2_GenHanning, number)(HannWind, 2048);
RCall(Wave, Resize)(& OutWave, 100000);
RCall(Wave, SetWindow)(& InWave, HannWind, 2048);
RCall(Wave, SetWindow)(& OutWave, HannWind, 2048);
if(! RCall(Wave, FromFile)(& InWave, & InputPath))
{
printf("Cannot read file!\n");
return 1;
}
Length = Length * (number)InWave.SampleRate / 1000;
if(Length < 0) Length = InWave.Size;
int VOT = RCall(CSVP_VOTFromWave, number)(& InWave, 0, InWave.Size / 2);
int Onset = RCall(CSVP_OnsetFromWave, number)
(& InWave, 0.005, 0, InWave.Size);
printf("Got VOT at %d.\n", VOT);
printf("Got Onset at %d.\n", Onset);
//Analysis process
RCall(PSOLAIterlyzer, SetWave)(& PAna, & InWave);
RCall(PSOLAIterlyzer, SetPosition)(& PAna, VOT + 2000);
RCall(PSOLAIterlyzer, SetBound)(& PAna, VOT);
if(! RCall(PSOLAIterlyzer, PreAnalysisTo)(& PAna, VOT + 4000))
{
printf("Preanalysis failed.\n");
return 1;
}
RCall(PSOLAIterlyzer, IterNextTo)(& PAna, InWave.Size);
RCall(PSOLAIterlyzer, PrevTo)(& PAna, Onset);
RCall(List_DataFrame, FromWave)(& DataList, & InWave, & PAna.PulseList);
int i;
/*
for(i = 0; i <= PAna.PulseList.Frames_Index; i ++)
{
int p = RCall(PSOLAIterlyzer, Fetch)(& PAna, i);
printf("%f %f\n", (float)p / InWave.SampleRate
, (float)p / InWave.SampleRate);
}*/
//Pre-synthesis process
OutWave.SampleRate = InWave.SampleRate;
RCall(FWindow_T, Ctor)(& DyWin);
RCall(FWindow, SetPara)(& DyWin, 30, 3000, 20);
RCall(FWindow, SetFunc)(& DyWin,
_C(RFNL_Hanning_Size_Gnrc, _, number),
_C(RFNL_Hanning_Valu_Gnrc, _, number));
RCall(FWindow, Initialize)(& DyWin);
RCall(PSOLAItersizer, SetWave)(& PSyn, & OutWave);
RCall(PSOLAItersizer, SetWindow)(& PSyn, & DyWin);
RCall(PSOLAItersizer, SetPosition)(& PSyn, 0);
//Transposition process
PMatch SorcPulse, LengthMatch;
RNew(PMatch, & SorcPulse, & LengthMatch);
for(i = 0; i <= PAna.PulseList.Frames_Index; i ++)
PAna.PulseList.Frames[i] -= Onset;
PMatchFromList_Int(& SorcPulse, & PAna.PulseList);
int Fill = SorcPulse.X[1] - SorcPulse.X[0];
i = 0;
number p = SorcPulse.X[0];
number Period = (number)InWave.SampleRate / Fundamental;
while(p < VOT - Onset)
{
i = RCall(PMatch, Query)(& SorcPulse, p).LowerIndex;
RCall(PSOLAItersizer, Add)(& PSyn, p, & DataList.Frames[i]);
p += Fill;
}
RCall(PMatch, AddPair)(& LengthMatch, VOT - Onset, VOT - Onset);
RCall(PMatch, AddPair)(& LengthMatch, Length,
SorcPulse.X[SorcPulse.X_Index - 1]);
while(p < Length)
{
Transition TransPulse;
int p2 = RCall(PMatch, Query)(& LengthMatch, p).Y;
TransPulse = RCall(PMatch, Query)(& SorcPulse, p2);
i = TransPulse.LowerIndex;
RCall(PSOLAItersizer, Add)(& PSyn, p, & DataList.Frames[i]);
p += Period;
}
int Offset = (int)CNumberStr(& StrOffset) * InWave.SampleRate / 1000;
//int OffIndex = RCall(PMatch, Query)(& SorcPulse, Offset).LowerIndex;
RCall(PSOLAItersizer, RepositionFrom)(& PSyn, Onset - Offset);
//Synthesis process
RCall(PSOLAItersizer, IterNextTo)(& PSyn, InWave.Size);
RCall(Wave, ToFile)(& OutWave, & OutputPath);
printf("Generated.\n");
RFree(HannWind);
RDelete(& OutputPath, & InputPath, & StrPitch, & StrVelocity, & StrFlags,
& InWave, & OutWave, & DyWin, & PAna, & PSyn, & DataList, & SorcPulse,
& LengthMatch, & StrOffset, & StrLength);
}
int main(int argc, char** arg)
{
int i, j;
Wave XWave, YWave;
RCall(Wave, CtorSize)(& XWave, 20);
RCall(Wave, CtorSize)(& YWave, 44100 * 5);
Float* Win = RAlloc_Float(2048);
CDSP2_GenHanning_Float(Win, 2048);
RCall(Wave, SetWindow)(& XWave, Win, 2048);
RCall(Wave, SetWindow)(& YWave, Win, 2048);
String Path;
String_Ctor(& Path);
String_SetChars(& Path, arg[1]);
RCall(Wave, FromFile)(& XWave, & Path);
RCall(Wave, Resize)(& YWave, XWave.Size * Stretch + 5000);
int VOT = CSVP_VOTFromWave_Float(& XWave, 0, XWave.Size - 5000);
printf("VOT: %d\n", VOT);
CSVP_F0Iterlyzer_Float F0Iter;
CSVP_F0Iterlyzer_Float_Ctor(& F0Iter);
F0Iter.Option.Adlib = 1;
F0Iter.Option.LFreq = 50;
F0Iter.Option.HFreq = 700;
F0Iter.Option.Method = CSVP_F0_YIN;
CSVP_F0Iterlyzer_Float_SetHopSize(& F0Iter, 256);
CSVP_F0Iterlyzer_Float_SetWave(& F0Iter, & XWave);
CSVP_F0Iterlyzer_Float_SetPosition(& F0Iter, VOT + 2000);
CSVP_F0Iterlyzer_Float_PreAnalysisTo(& F0Iter, VOT + 10000);
CSVP_F0Iterlyzer_Float_IterNextTo(& F0Iter, XWave.Size - 5000);
CSVP_F0Iterlyzer_Float_PrevTo(& F0Iter, 0);
CSVP_F0PostProcess_Float(& F0Iter.F0List, 4000, 0.15, 100, 700);
printf("Got F0.\n");
HNMIterlyzer HNMIter;
RCall(HNMIterlyzer, CtorSize)(& HNMIter, 2048);
HNMIter.GenPhase = 1;
//HNMIter.LeftBound = VOT;
RCall(HNMIterlyzer, SetHopSize)(& HNMIter, FFTSIZE);
RCall(HNMIterlyzer, SetWave)(& HNMIter, & XWave);
RCall(HNMIterlyzer, SetPosition)(& HNMIter, VOT + 1000);
RCall(HNMIterlyzer, SetUpperFreq)(& HNMIter, 10000);
RCall(HNMIterlyzer, SetPitch)(& HNMIter, & F0Iter.F0List);
RCall(HNMIterlyzer, PrevTo)(& HNMIter, 0);
RCall(HNMIterlyzer, IterNextTo)(& HNMIter, XWave.Size);
HNMItersizer HNMSizer;
RCall(HNMItersizer, CtorSize)(& HNMSizer, 2048);
HNMContour TempCont;
HNMFrame TempHNM;
RCall(HNMContour, Ctor)(& TempCont);
RCall(HNMFrame, Ctor)(& TempHNM);
CSVP_PitchModel PM;
CSVP_PitchModel_Ctor(& PM);
int Offset = HNMIter.PulseList.Frames[0];
int Last;
for(i = 0; i <= HNMIter.PulseList.Frames_Index; i ++)
{
HNMFrame* OrigHNM = & HNMIter.HNMList.Frames[i];
float F0 = OrigHNM -> Hmnc.Freq[0] * 2;
CSVP_PitchConvertHNMFrame_Float(& TempCont, OrigHNM, & PM, F0, 12000,
XWave.SampleRate);
RCall(HNMFrame, From)(& TempHNM, OrigHNM);
//RCall(HNMFrame, FromContour)(& TempHNM, & TempCont, F0, 12000);
/*
if(i % 5 == 0)
{
float PhaseAdj = CSVP_PitchModel_GetPhseCoh(& PM, F0);
CSVP_PhaseSyncH_Float(& HNMIter.PhseList.Frames[i], 0);
CSVP_PhaseContract_Float(& HNMIter.PhseList.Frames[i], PhaseAdj);
RCall(HNMItersizer, AddPhase)(& HNMSizer,
& HNMIter.PhseList.Frames[i], Offset);
}*/
RCall(HNMItersizer, AddPhase)(& HNMSizer, & HNMIter.PhseList.Frames[i],
HNMIter.PulseList.Frames[i]);
// Uncomment to plot the spectral env.
/*
if(Offset > 10000)
{
for(j = 0; j < 1024; j ++)
printf("%f\n", TempCont.Hmnc[j]);
exit(0);
}*/
for(j = 0; j < Stretch; j ++)
{
RCall(HNMItersizer, Add)(& HNMSizer, & TempHNM, Offset);
Offset += FFTSIZE;
}
}
Last = HNMSizer.PulseList.Frames[i * Stretch - 1];
RDelete(& TempCont, & TempHNM, & PM);
RCall(HNMItersizer, SetHopSize)(& HNMSizer, FFTSIZE);
RCall(HNMItersizer, SetWave)(& HNMSizer, & YWave);
RCall(HNMItersizer, SetPosition)(& HNMSizer,
HNMSizer.SubsizerS -> PhseMatch.PulseList.X[50]);
RCall(HNMItersizer, SetInitPhase)(& HNMSizer,
& HNMSizer.SubsizerS -> PhseMatch.PhseList.Frames[50]);
printf("%f\n", HNMSizer.SubsizerS -> PhseMatch.PulseList.X[50]);
HNMSizer.Option.PhaseControl = 1;//CSVP_PhaseFlag_Regen;
/*
RCall(HNMItersizer, PrevTo )(& HNMSizer, 0);
RCall(HNMItersizer, IterNextTo)(& HNMSizer, Last - 8000);
RCall(HNMItersizer, IterNextTo)(& HNMSizer, Last - 1000);
RCall(HNMItersizer, IterNextTo)(& HNMSizer, Last);
*/
List_Sinusoid SList;
RCall(List_Sinusoid, Ctor)(& SList);
RCall(List_HNMFrame, ToSinuList)(& HNMIter.HNMList, & SList);
CSVP_SinusoidalFromSinuList_Float(& YWave, & HNMIter.PulseList,
& SList, & HNMIter.PhseList);
/*
CSVP_NoiseTurbFromSinuList_Float(& YWave, & XWave, & HNMIter.PulseList,
& SList, & HNMIter.PhseList);
*/
RCall(List_Sinusoid, Dtor)(& SList);
YWave.SampleRate = XWave.SampleRate;
if(argc > 2)
String_SetChars(& Path, arg[2]);
else
String_SetChars(& Path, "/tmp/out.wav");
RCall(Wave, ToFile)(& YWave, & Path);
RFree(Win);
RDelete(& Path);
RDelete(& XWave, & YWave, & HNMIter, & HNMSizer, & F0Iter);
return 0;
}
void PMatchFromList_Int(PMatch* Dest, List_Int* Sorc)
{
int i;
for(i = Sorc -> Frames_Index; i >= 0; i --)
RCall(PMatch, AddPair)(Dest, Sorc -> Frames[i], i);
}
int main(int ArgN, char** Arg)
{
int RegenFlag = 0;
char* CWaveFile = NULL;
char* CLabelFile = NULL;
char* CRecFile = NULL;
char* CRegenFile = "RegeneratedTrack.txt";
int c;
while((c = getopt(ArgN, Arg, "r")) != -1)
{
switch(c)
{
case 'r':
RegenFlag = 1;
break;
case '?':
printf("Usage: rsegment [-r] "
"[-h] wavfile labelfile recfile\n");
return 1;
default:
abort();
}
}
int i;
for(i = optind; i < ArgN; i ++)
{
switch(i - optind)
{
case 0:
CWaveFile = Arg[i];
break;
case 1:
CLabelFile = Arg[i];
break;
case 2:
CRecFile = Arg[i];
break;
default:
fprintf(stderr, "Warning: redundant argument '%s'.\n", Arg[i]);
}
}
if(! CWaveFile)
{
fprintf(stderr, "Missing argument 'wavfile'.\n");
return 1;
}
if(! CLabelFile)
{
fprintf(stderr, "Missing argument 'labelfile'.\n");
return 1;
}
if(! CRecFile)
{
fprintf(stderr, "Missing argument 'recfile'.\n");
return 1;
}
Wave SorcWave;
File LabelFile;
File RecFile;
File RegenFile;
String WavePath, LabelPath, RecPath, RegenPath;
RNew(String, & WavePath, & LabelPath, & RecPath, & RegenPath);
RNew(File, & LabelFile, & RecFile, & RegenFile);
RCall(Wave, Ctor)(& SorcWave);
String_SetChars(& WavePath, CWaveFile);
String_SetChars(& LabelPath, CLabelFile);
String_SetChars(& RecPath, CRecFile);
String_SetChars(& RegenPath, CRegenFile);
if(! RCall(Wave, FromFile)(& SorcWave, & WavePath))
{
fprintf(stderr, "Cannot load wave file.\n");
return 1;
}
if(! File_Open(& LabelFile, & LabelPath, READONLY))
{
fprintf(stderr, "Cannot load label file.\n");
return 1;
}
if(! File_Open(& RecFile, & RecPath, READONLY))
{
fprintf(stderr, "Cannot load word table.\n");
return 1;
}
if(RegenFlag)
{
if(! File_Open(& RegenFile, & RegenPath, CREATE))
{
fprintf(stderr, "Cannot create '%s'.\n", CRegenFile);
return 1;
}
}
Array_Ctor(String, RecList);
Array_Ctor(int, SegList);
ParseRecFile(& RecFile);
ParseLabelFile(& LabelFile, SorcWave.SampleRate);
Wave SegWave;
RCall(Wave, Ctor)(& SegWave);
SegWave.SampleRate = SorcWave.SampleRate;
String SegName, LineBuf, TempBuf;
RNew(String, & SegName, & LineBuf, & TempBuf);
for(i = 0; i <= SegList_Index; i ++)
{
int Start = SegList[i];
int End;
if(i == SegList_Index)
End = SorcWave.Size;
else
End = SegList[i + 1];
if(i > RecList_Index)
{
fprintf(stderr, "Insufficient records in word table.\n");
fprintf(stderr, "Segmentation aborted at %fs.\n",
(float)Start / SorcWave.SampleRate);
return 1;
}
String* Name = & RecList[i];
String_Copy(& SegName, Name);
String_JoinChars(& SegName, ".wav");
if(! RegenFlag)
{
int Size = End - Start;
Real* Data = RCall(RAlloc, Real)(Size);
RCall(Wave, Read)(& SorcWave, Data, Start, Size);
RCall(Wave, Resize)(& SegWave, Size);
RCall(Wave, Write)(& SegWave, Data, 0, Size);
if(! RCall(Wave, ToFile)(& SegWave, & SegName))
fprintf(stderr, "Exporting '%s' failed. Skipped.\n",
String_GetChars(& SegName));
RFree(Data);
}
if(RegenFlag)
{
CStrFloat(& LineBuf, (float)SegList[i] / SorcWave.SampleRate);
String_Copy(& TempBuf, & LineBuf);
String_JoinChars(& LineBuf, "\t");
String_Join(& LineBuf, & TempBuf);
String_JoinChars(& LineBuf, "\t");
String_Join(& LineBuf, Name);
File_WriteLine(& RegenFile, & LineBuf);
}
}
if(i <= RecList_Index)
fprintf(stderr, "Warning: redundant records in word table starting from"
" '%s'.\n", String_GetChars(& RecList[i]));
if(RegenFlag)
File_Flush(& RegenFile);
File_Close(& RecFile);
File_Close(& LabelFile);
File_Close(& RegenFile);
Array_ObjDtor(String, RecList);
Array_Dtor(String, RecList);
Array_Dtor(int, SegList);
RDelete(& WavePath, & LabelPath, & RecPath, & RegenPath, & SegName,
& LineBuf, & TempBuf);
RDelete(& SorcWave, & LabelFile, & RecFile, & SegWave, & RegenFile);
return 0;
}
