// Simple median filtering along frequencies and amplitudes
public static SinusoidalTracks postProcess(SinusoidalTracks st) {
for (int i = 0; i < st.totalTracks; i++) {
if (st.tracks[i].totalSins > 20) {
st.tracks[i].freqs = SignalProcUtils.meanFilter(st.tracks[i].freqs, MEAN_FILTER_FREQ_AXIS);
st.tracks[i].amps = SignalProcUtils.meanFilter(st.tracks[i].amps, MEAN_FILTER_AMP_AXIS);
}
}
return st;
}
public DoubleDataSource process(DoubleDataSource inputAudio) {
amount = MathUtils.CheckLimits(amount, MIN_AMOUNT, MAX_AMOUNT);
double[] vscales = {amount};
int frameLength = SignalProcUtils.getDFTSize(fs);
int predictionOrder = SignalProcUtils.getLPOrder(fs);
VocalTractScalingProcessor p =
new VocalTractScalingProcessor(predictionOrder, fs, frameLength, vscales);
FrameOverlapAddSource foas =
new FrameOverlapAddSource(inputAudio, Window.HANNING, true, frameLength, fs, p);
return new BufferedDoubleDataSource(foas);
}
private void initialise(
int samplingRate,
int LPOrder,
double[] pscalesIn,
double[] tscalesIn,
double[] escalesIn,
double[] vscalesIn) {
if (pscalesIn != null) {
pscales = new double[pscalesIn.length];
System.arraycopy(pscalesIn, 0, pscales, 0, pscalesIn.length);
}
if (tscalesIn != null) {
tscales = new double[tscalesIn.length];
System.arraycopy(tscalesIn, 0, tscales, 0, tscalesIn.length);
}
if (escalesIn != null) {
escales = new double[escalesIn.length];
System.arraycopy(escalesIn, 0, escales, 0, escalesIn.length);
}
if (vscalesIn != null) {
vscales = new double[vscalesIn.length];
System.arraycopy(vscalesIn, 0, vscales, 0, vscalesIn.length);
}
fs = samplingRate;
lpOrder = SignalProcUtils.getLPOrder(fs);
}
/*
* Group individual sinusoids into tracks by considering closeness in frequency
* Current version is a simple implementation of checking the frequency difference between neighbouring
* sinusoids and assigning them to same track if the absolute difference is less than a threshold
* Possible ways to improve this process would be to employ:
* - constraints on amplitude continuity
* - constraints on phase continuity (i.e. the phase difference between two consecutive sinusoids
* should not be larger or smaller than some percent of the period
*
* framesSins[i][] : Array of sinusoidal parameters (amps, freqs, phases) extracted from ith speech frame
* framesSins[i][j]: Sinusoidal parameters of the jth peak sinusoid in the DFT spectrum of speech frame i
* Returns a number of sinusoidal tracks
*
* This version uses a simple search mechanism to compare a current sinusoid frequecny with the previous and if the difference is smaller than
* +-deltaInHz, assigns the new sinusoid to the previous sinusoid´s track
* In the assignment, longer previous paths are favoured in a weighted manner, i.e. the longer a candidate track,
* the more likely the current sinusoid gets assigned to that track
*
*/
public SinusoidalTracks generateTracks(
NonharmonicSinusoidalSpeechSignal sinSignal, float deltaInHz, int samplingRate) {
int numFrames = sinSignal.framesSins.length;
float deltaInRadians = SignalProcUtils.hz2radian(deltaInHz, samplingRate);
SinusoidalTracks tr = null;
int i;
Sinusoid zeroAmpSin;
if (numFrames > 0) {
int j, k;
float tmpDist, minDist;
int trackInd;
boolean[] bSinAssigneds = null;
for (i = 0; i < numFrames; i++) {
if (tr == null) // If no tracks yet, assign the current sinusoids to new tracks
{
tr = new SinusoidalTracks(sinSignal.framesSins[i].sinusoids.length, samplingRate);
tr.setSysAmpsAndTimes(sinSignal.framesSins);
for (j = 0; j < sinSignal.framesSins[i].sinusoids.length; j++) {
// First add a zero amplitude sinusoid at previous time instant to allow smooth
// synthesis (i.e. "turning on" the track)
zeroAmpSin =
new Sinusoid(
0.0f,
sinSignal.framesSins[i].sinusoids[j].freq,
0.0f,
Sinusoid.NON_EXISTING_FRAME_INDEX);
tr.add(
new SinusoidalTrack(
sinSignal.framesSins[i].time - ZERO_AMP_SHIFT_IN_SECONDS,
zeroAmpSin,
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.TURNED_ON));
//
tr.tracks[tr.currentIndex].add(
sinSignal.framesSins[i].time,
sinSignal.framesSins[i].sinusoids[j],
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.ACTIVE);
}
} else // If there are tracks, first check "continuations" by checking whether a given
// sinusoid is in the +-deltaInRadians neighbourhood of the previous track.
// Those tracks that do not continue are "turned off".
// All sinusoids of the current frame that are not assigned to any of the "continuations" or
// "turned off" are "birth"s of new tracks.
{
for (j = 0; j < tr.currentIndex + 1; j++) {
if (tr.tracks[j] != null) tr.tracks[j].resetCandidate();
}
bSinAssigneds = new boolean[sinSignal.framesSins[i].sinusoids.length];
// Continuations:
for (k = 0; k < sinSignal.framesSins[i].sinusoids.length; k++) {
minDist =
Math.abs(
sinSignal.framesSins[i].sinusoids[k].freq
- tr.tracks[0].freqs[tr.tracks[0].currentIndex]);
if (minDist < deltaInRadians) trackInd = 0;
else trackInd = -1;
for (j = 1; j < tr.currentIndex + 1; j++) {
tmpDist =
Math.abs(
sinSignal.framesSins[i].sinusoids[k].freq
- tr.tracks[j].freqs[tr.tracks[j].currentIndex]);
if (tmpDist < deltaInRadians && (trackInd == -1 || tmpDist < minDist)) {
minDist = tmpDist;
trackInd = j;
}
}
if (trackInd > -1) {
if (tr.tracks[trackInd].newCandidateInd > -1)
bSinAssigneds[tr.tracks[trackInd].newCandidateInd] = false;
tr.tracks[trackInd].newCandidate = new Sinusoid(sinSignal.framesSins[i].sinusoids[k]);
tr.tracks[trackInd].newCandidateInd = k;
bSinAssigneds[k] =
true; // The sinusoid might be assigned to an existing track provided that a
// closer sinusoid is not found
} else
bSinAssigneds[k] =
false; // This is the birth of a new track since it does not match any existing
// tracks
}
// Here is the actual assignment of sinusoids to existing tracks
for (j = 0; j < tr.currentIndex + 1; j++) {
if (tr.tracks[j].newCandidate != null) {
Sinusoid tmpSin = new Sinusoid(tr.tracks[j].newCandidate);
if (tr.tracks[j].states[tr.tracks[j].currentIndex] != SinusoidalTrack.ACTIVE) {
zeroAmpSin =
new Sinusoid(
0.0f,
tr.tracks[j].freqs[tr.tracks[j].totalSins - 1],
0.0f,
Sinusoid.NON_EXISTING_FRAME_INDEX);
tr.tracks[j].add(
sinSignal.framesSins[i].time - ZERO_AMP_SHIFT_IN_SECONDS,
zeroAmpSin,
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.TURNED_ON);
}
tr.tracks[j].add(
sinSignal.framesSins[i].time,
tmpSin,
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.ACTIVE);
} else // Turn off tracks that are not assigned any new sinusoid
{
if (tr.tracks[j].states[tr.tracks[j].currentIndex] != SinusoidalTrack.TURNED_OFF) {
zeroAmpSin =
new Sinusoid(
0.0f,
tr.tracks[j].freqs[tr.tracks[j].totalSins - 1],
0.0f,
Sinusoid.NON_EXISTING_FRAME_INDEX);
tr.tracks[j].add(
sinSignal.framesSins[i].time + ZERO_AMP_SHIFT_IN_SECONDS,
zeroAmpSin,
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.TURNED_OFF);
}
}
}
// Births: Create new tracks from sinusoids that are not assigned to existing tracks
for (k = 0; k < bSinAssigneds.length; k++) {
if (!bSinAssigneds[k]) {
// First add a zero amplitude sinusoid to previous frame to allow smooth synthesis
// (i.e. "turning on" the track)
zeroAmpSin =
new Sinusoid(
0.0f,
sinSignal.framesSins[i].sinusoids[k].freq,
0.0f,
Sinusoid.NON_EXISTING_FRAME_INDEX);
tr.add(
new SinusoidalTrack(
sinSignal.framesSins[i].time - ZERO_AMP_SHIFT_IN_SECONDS,
zeroAmpSin,
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.TURNED_ON));
//
tr.tracks[tr.currentIndex].add(
sinSignal.framesSins[i].time,
sinSignal.framesSins[i].sinusoids[k],
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.ACTIVE);
}
}
System.out.println(
"Track generation using frame "
+ String.valueOf(i + 1)
+ " of "
+ String.valueOf(numFrames));
}
// Turn-off all active tracks after the last speech frame
if (i == numFrames - 1) {
for (j = 0; j < tr.currentIndex + 1; j++) {
if (Math.abs(
sinSignal.framesSins[i].time - tr.tracks[j].times[tr.tracks[j].totalSins - 1])
< ZERO_AMP_SHIFT_IN_SECONDS) {
if (tr.tracks[j].states[tr.tracks[j].currentIndex] == SinusoidalTrack.ACTIVE) {
zeroAmpSin =
new Sinusoid(
0.0f,
tr.tracks[j].freqs[tr.tracks[j].totalSins - 1],
0.0f,
Sinusoid.NON_EXISTING_FRAME_INDEX);
tr.tracks[j].add(
sinSignal.framesSins[i].time + ZERO_AMP_SHIFT_IN_SECONDS,
zeroAmpSin,
sinSignal.framesSins[i].maxFreqOfVoicing,
SinusoidalTrack.TURNED_OFF);
}
}
}
}
//
}
}
for (i = 0; i <= tr.currentIndex; i++) tr.tracks[i].correctTrack();
tr.setOriginalDurationManual(sinSignal.originalDurationInSeconds);
SinusoidalTracks trOut = new SinusoidalTracks(tr, 0, tr.currentIndex);
trOut = postProcess(trOut);
return trOut;
}
public void initialise(
double[] lowerCutOffsInHzIn, double[] upperCutOffsInHzIn, double overlapAround1000HzIn) {
normalizationFilterTransformedIR = null;
if (lowerCutOffsInHzIn != null && upperCutOffsInHzIn != null) {
assert lowerCutOffsInHzIn.length == upperCutOffsInHzIn.length;
lowerCutOffsInHz = new double[lowerCutOffsInHzIn.length];
upperCutOffsInHz = new double[upperCutOffsInHzIn.length];
System.arraycopy(lowerCutOffsInHzIn, 0, lowerCutOffsInHz, 0, lowerCutOffsInHzIn.length);
System.arraycopy(upperCutOffsInHzIn, 0, upperCutOffsInHz, 0, upperCutOffsInHzIn.length);
int i;
filters = new FIRFilter[lowerCutOffsInHz.length];
int filterOrder = SignalProcUtils.getFIRFilterOrder(samplingRateInHz);
double normalizedLowerCutoff;
double normalizedUpperCutoff;
overlapAround1000Hz = overlapAround1000HzIn;
for (i = 0; i < lowerCutOffsInHz.length; i++)
assert lowerCutOffsInHz[i] < upperCutOffsInHz[i];
for (i = 0; i < lowerCutOffsInHz.length; i++) {
if (lowerCutOffsInHz[i] <= 0.0) {
normalizedUpperCutoff = Math.min(upperCutOffsInHz[i] / samplingRateInHz, 0.5);
normalizedUpperCutoff = Math.max(normalizedUpperCutoff, 0.0);
filters[i] = new LowPassFilter(normalizedUpperCutoff, filterOrder);
} else if (upperCutOffsInHz[i] >= 0.5 * samplingRateInHz) {
normalizedLowerCutoff = Math.max(lowerCutOffsInHz[i] / samplingRateInHz, 0.0);
normalizedLowerCutoff = Math.min(normalizedLowerCutoff, 0.5);
filters[i] = new HighPassFilter(normalizedLowerCutoff, filterOrder);
} else {
normalizedLowerCutoff = Math.max(lowerCutOffsInHz[i] / samplingRateInHz, 0.0);
normalizedLowerCutoff = Math.min(normalizedLowerCutoff, 0.5);
normalizedUpperCutoff = Math.min(upperCutOffsInHz[i] / samplingRateInHz, 0.5);
normalizedUpperCutoff = Math.max(normalizedUpperCutoff, 0.0);
assert normalizedLowerCutoff < normalizedUpperCutoff;
filters[i] =
new BandPassFilter(normalizedLowerCutoff, normalizedUpperCutoff, filterOrder);
}
}
int maxFreq = filters[0].transformedIR.length / 2 + 1;
// Estimate a smooth gain normalization filter
normalizationFilterTransformedIR = new double[maxFreq];
Arrays.fill(normalizationFilterTransformedIR, 0.0);
int j;
for (i = 0; i < filters.length; i++) {
normalizationFilterTransformedIR[0] += Math.abs(filters[i].transformedIR[0]);
normalizationFilterTransformedIR[maxFreq - 1] += Math.abs(filters[i].transformedIR[1]);
for (j = 1; j < maxFreq - 1; j++)
normalizationFilterTransformedIR[j] +=
Math.sqrt(
filters[i].transformedIR[2 * j] * filters[i].transformedIR[2 * j]
+ filters[i].transformedIR[2 * j + 1] * filters[i].transformedIR[2 * j + 1]);
}
for (j = 0; j < maxFreq; j++)
normalizationFilterTransformedIR[j] = 1.0 / normalizationFilterTransformedIR[j];
// MaryUtils.plot(normalizationFilterTransformedIR, "Normalization filter");
//
}
}
public static void main(String[] args) throws UnsupportedAudioFileException, IOException {
// File input
AudioInputStream inputAudio = AudioSystem.getAudioInputStream(new File(args[0]));
int samplingRate = (int) inputAudio.getFormat().getSampleRate();
AudioDoubleDataSource signal = new AudioDoubleDataSource(inputAudio);
double[] x = signal.getAllData();
double maxOrig = MathUtils.getAbsMax(x);
SinusoidalAnalyzer sa = null;
SinusoidalTracks st = null;
PitchSynchronousSinusoidalAnalyzer pa = null;
//
// Analysis
float deltaInHz = SinusoidalAnalysisParams.DEFAULT_DELTA_IN_HZ;
float numPeriods = PitchSynchronousSinusoidalAnalyzer.DEFAULT_ANALYSIS_PERIODS;
boolean isSilentSynthesis = false;
int windowType = Window.HANNING;
boolean bRefinePeakEstimatesParabola = false;
boolean bRefinePeakEstimatesBias = false;
boolean bSpectralReassignment = false;
boolean bAdjustNeighFreqDependent = false;
// int spectralEnvelopeType = SinusoidalAnalysisParams.LP_SPEC;
int spectralEnvelopeType = SinusoidalAnalysisParams.SEEVOC_SPEC;
float[] initialPeakLocationsInHz = null;
initialPeakLocationsInHz = new float[1];
for (int i = 0; i < 1; i++) initialPeakLocationsInHz[i] = (i + 1) * 350.0f;
boolean isFixedRateAnalysis = false;
boolean isRealSpeech = true;
double startFreqInHz = 0.0;
double endFreqInHz = 0.5 * samplingRate;
SinusoidalAnalysisParams params =
new SinusoidalAnalysisParams(
samplingRate,
startFreqInHz,
endFreqInHz,
windowType,
bRefinePeakEstimatesParabola,
bRefinePeakEstimatesBias,
bSpectralReassignment,
bAdjustNeighFreqDependent);
if (isFixedRateAnalysis) {
// Fixed window size and skip rate analysis
double[] f0s = null;
float ws_f0 = -1.0f;
float ss_f0 = -1.0f;
sa = new SinusoidalAnalyzer(params);
if (spectralEnvelopeType == SinusoidalAnalysisParams.SEEVOC_SPEC) // Pitch info needed
{
String strPitchFile = args[0].substring(0, args[0].length() - 4) + ".ptc";
PitchReaderWriter f0 = new PitchReaderWriter(strPitchFile);
f0s = f0.contour;
ws_f0 = (float) f0.header.windowSizeInSeconds;
ss_f0 = (float) f0.header.skipSizeInSeconds;
}
st =
sa.analyzeFixedRate(
x, 0.020f, 0.010f, deltaInHz, spectralEnvelopeType, f0s, ws_f0, ss_f0);
//
} else {
// Pitch synchronous analysis
String strPitchFile = args[0].substring(0, args[0].length() - 4) + ".ptc";
PitchReaderWriter f0 = new PitchReaderWriter(strPitchFile);
int pitchMarkOffset = 0;
PitchMarks pm =
SignalProcUtils.pitchContour2pitchMarks(
f0.contour,
samplingRate,
x.length,
f0.header.windowSizeInSeconds,
f0.header.skipSizeInSeconds,
true,
pitchMarkOffset);
pa = new PitchSynchronousSinusoidalAnalyzer(params);
st =
pa.analyzePitchSynchronous(
x, pm, numPeriods, -1.0f, deltaInHz, spectralEnvelopeType, initialPeakLocationsInHz);
isSilentSynthesis = false;
}
//
// Resynthesis
PeakMatchedSinusoidalSynthesizer ss = new PeakMatchedSinusoidalSynthesizer(samplingRate);
x = ss.synthesize(st, isSilentSynthesis);
//
// File output
DDSAudioInputStream outputAudio =
new DDSAudioInputStream(new BufferedDoubleDataSource(x), inputAudio.getFormat());
String outFileName =
args[0].substring(0, args[0].length() - 4) + "_sinResynthFullbandPitchSynch.wav";
AudioSystem.write(outputAudio, AudioFileFormat.Type.WAVE, new File(outFileName));
//
}
public float getEndTime(int samplingRateInHz) {
if (waveform != null && startTime > -1.0f)
return startTime + SignalProcUtils.sample2time(waveform.length, samplingRateInHz);
else return -1.0f;
}
// Pseudo harmonics based noise generation for pseudo periods
public static double[] synthesize(
HntmSpeechSignal hnmSignal,
HntmAnalyzerParams analysisParams,
HntmSynthesizerParams synthesisParams,
String referenceFile) {
double[] noisePart = null;
int trackNoToExamine = 1;
int i, k, n;
double t; // Time in seconds
double tsik = 0.0; // Synthesis time in seconds
double tsikPlusOne = 0.0; // Synthesis time in seconds
double trackStartInSeconds, trackEndInSeconds;
// double lastPeriodInSeconds = 0.0;
int trackStartIndex, trackEndIndex;
double akt;
int numHarmonicsCurrentFrame, numHarmonicsPrevFrame, numHarmonicsNextFrame;
int harmonicIndexShiftPrev, harmonicIndexShiftCurrent, harmonicIndexShiftNext;
int maxNumHarmonics = 0;
for (i = 0; i < hnmSignal.frames.length; i++) {
if (hnmSignal.frames[i].maximumFrequencyOfVoicingInHz > 0.0f
&& hnmSignal.frames[i].n != null) {
numHarmonicsCurrentFrame =
(int) Math.floor(hnmSignal.samplingRateInHz / analysisParams.noiseF0InHz + 0.5);
numHarmonicsCurrentFrame = Math.max(0, numHarmonicsCurrentFrame);
if (numHarmonicsCurrentFrame > maxNumHarmonics) maxNumHarmonics = numHarmonicsCurrentFrame;
}
}
double aksi;
double aksiPlusOne;
float[] phasekis = null;
float phasekiPlusOne;
double ht;
float phasekt = 0.0f;
float phasekiEstimate = 0.0f;
float phasekiPlusOneEstimate = 0.0f;
int Mk;
boolean isPrevNoised, isNoised, isNextNoised;
boolean isTrackNoised, isNextTrackNoised, isPrevTrackNoised;
int outputLen =
SignalProcUtils.time2sample(
hnmSignal.originalDurationInSeconds, hnmSignal.samplingRateInHz);
noisePart =
new double
[outputLen]; // In fact, this should be prosody scaled length when you implement prosody
// modifications
Arrays.fill(noisePart, 0.0);
// Write separate tracks to output
double[][] noiseTracks = null;
if (maxNumHarmonics > 0) {
noiseTracks = new double[maxNumHarmonics][];
for (k = 0; k < maxNumHarmonics; k++) {
noiseTracks[k] = new double[outputLen];
Arrays.fill(noiseTracks[k], 0.0);
}
phasekis = new float[maxNumHarmonics];
for (k = 0; k < maxNumHarmonics; k++)
phasekis[k] = (float) (MathUtils.TWOPI * (Math.random() - 0.5));
}
//
int transitionLen =
SignalProcUtils.time2sample(
synthesisParams.unvoicedVoicedTrackTransitionInSeconds, hnmSignal.samplingRateInHz);
Window transitionWin = Window.get(Window.HAMMING, transitionLen * 2);
transitionWin.normalizePeakValue(1.0f);
double[] halfTransitionWinLeft = transitionWin.getCoeffsLeftHalf();
float halfFs = hnmSignal.samplingRateInHz;
for (i = 0; i < hnmSignal.frames.length; i++) {
isPrevNoised = false;
isNoised = false;
isNextNoised = false;
if (i > 0
&& hnmSignal.frames[i - 1].n != null
&& hnmSignal.frames[i - 1].maximumFrequencyOfVoicingInHz < halfFs
&& ((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i - 1].n).ceps != null)
isPrevNoised = true;
if (i > 0
&& hnmSignal.frames[i].n != null
&& hnmSignal.frames[i].maximumFrequencyOfVoicingInHz < halfFs
&& ((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i].n).ceps != null) isNoised = true;
if (i < hnmSignal.frames.length - 1
&& hnmSignal.frames[i + 1].maximumFrequencyOfVoicingInHz < halfFs
&& hnmSignal.frames[i + 1].n != null
&& ((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i + 1].n).ceps != null)
isNextNoised = true;
numHarmonicsPrevFrame = 0;
numHarmonicsCurrentFrame = 0;
numHarmonicsNextFrame = 0;
harmonicIndexShiftPrev = 0;
harmonicIndexShiftCurrent = 0;
harmonicIndexShiftNext = 0;
if (isPrevNoised) {
numHarmonicsPrevFrame =
(int)
Math.floor(
(hnmSignal.samplingRateInHz
- hnmSignal.frames[i - 1].maximumFrequencyOfVoicingInHz)
/ analysisParams.noiseF0InHz
+ 0.5);
numHarmonicsPrevFrame = Math.max(0, numHarmonicsPrevFrame);
harmonicIndexShiftPrev =
(int)
Math.floor(
hnmSignal.frames[i - 1].maximumFrequencyOfVoicingInHz
/ analysisParams.noiseF0InHz
+ 0.5);
harmonicIndexShiftPrev = Math.max(1, harmonicIndexShiftPrev);
}
if (isNoised) {
numHarmonicsCurrentFrame =
(int)
Math.floor(
(hnmSignal.samplingRateInHz - hnmSignal.frames[i].maximumFrequencyOfVoicingInHz)
/ analysisParams.noiseF0InHz
+ 0.5);
numHarmonicsCurrentFrame = Math.max(0, numHarmonicsCurrentFrame);
harmonicIndexShiftCurrent =
(int)
Math.floor(
hnmSignal.frames[i].maximumFrequencyOfVoicingInHz / analysisParams.noiseF0InHz
+ 0.5);
harmonicIndexShiftCurrent = Math.max(1, harmonicIndexShiftCurrent);
} else if (!isNoised && isNextNoised) {
numHarmonicsCurrentFrame =
(int)
Math.floor(
(hnmSignal.samplingRateInHz
- hnmSignal.frames[i + 1].maximumFrequencyOfVoicingInHz)
/ analysisParams.noiseF0InHz
+ 0.5);
numHarmonicsCurrentFrame = Math.max(0, numHarmonicsCurrentFrame);
harmonicIndexShiftCurrent =
(int)
Math.floor(
hnmSignal.frames[i + 1].maximumFrequencyOfVoicingInHz
/ analysisParams.noiseF0InHz
+ 0.5);
harmonicIndexShiftCurrent = Math.max(1, harmonicIndexShiftCurrent);
}
if (isNextNoised) {
numHarmonicsNextFrame =
(int)
Math.floor(
(hnmSignal.samplingRateInHz
- hnmSignal.frames[i + 1].maximumFrequencyOfVoicingInHz)
/ analysisParams.noiseF0InHz
+ 0.5);
numHarmonicsNextFrame = Math.max(0, numHarmonicsNextFrame);
harmonicIndexShiftNext =
(int)
Math.floor(
hnmSignal.frames[i + 1].maximumFrequencyOfVoicingInHz
/ analysisParams.noiseF0InHz
+ 0.5);
harmonicIndexShiftNext = Math.max(1, harmonicIndexShiftNext);
}
for (k = 0; k < numHarmonicsCurrentFrame; k++) {
aksi = 0.0;
aksiPlusOne = 0.0;
phasekiPlusOne = 0.0f;
isPrevTrackNoised = false;
isTrackNoised = false;
isNextTrackNoised = false;
if (i > 0 && hnmSignal.frames[i - 1].n != null && numHarmonicsPrevFrame > k)
isPrevTrackNoised = true;
if (hnmSignal.frames[i].n != null && numHarmonicsCurrentFrame > k) isTrackNoised = true;
if (i < hnmSignal.frames.length - 1
&& hnmSignal.frames[i + 1].n != null
&& numHarmonicsNextFrame > k) isNextTrackNoised = true;
tsik = hnmSignal.frames[i].tAnalysisInSeconds;
if (i == 0) trackStartInSeconds = 0.0;
else trackStartInSeconds = tsik;
if (i == hnmSignal.frames.length - 1) tsikPlusOne = hnmSignal.originalDurationInSeconds;
else tsikPlusOne = hnmSignal.frames[i + 1].tAnalysisInSeconds;
trackEndInSeconds = tsikPlusOne;
trackStartIndex =
SignalProcUtils.time2sample(trackStartInSeconds, hnmSignal.samplingRateInHz);
trackEndIndex = SignalProcUtils.time2sample(trackEndInSeconds, hnmSignal.samplingRateInHz);
if (isTrackNoised && trackEndIndex - trackStartIndex + 1 > 0) {
// Amplitudes
if (isTrackNoised) {
if (!analysisParams.useNoiseAmplitudesDirectly) {
if (analysisParams.regularizedCepstrumWarpingMethod
== RegularizedCepstrumEstimator.REGULARIZED_CEPSTRUM_WITH_PRE_BARK_WARPING)
aksi =
RegularizedPreWarpedCepstrumEstimator.cepstrum2linearSpectrumValue(
((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i].n).ceps,
(k + harmonicIndexShiftCurrent) * analysisParams.noiseF0InHz,
hnmSignal.samplingRateInHz);
else if (analysisParams.regularizedCepstrumWarpingMethod
== RegularizedCepstrumEstimator.REGULARIZED_CEPSTRUM_WITH_POST_MEL_WARPING)
aksi =
RegularizedPostWarpedCepstrumEstimator.cepstrum2linearSpectrumValue(
((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i].n).ceps,
(k + harmonicIndexShiftCurrent) * analysisParams.noiseF0InHz,
hnmSignal.samplingRateInHz);
} else {
if (k < ((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i].n).ceps.length)
aksi =
((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i].n)
.ceps[k]; // Use amplitudes directly without cepstrum method
else aksi = 0.0;
}
} else aksi = 0.0;
if (isNextTrackNoised) {
if (!analysisParams.useNoiseAmplitudesDirectly) {
if (analysisParams.regularizedCepstrumWarpingMethod
== RegularizedCepstrumEstimator.REGULARIZED_CEPSTRUM_WITH_PRE_BARK_WARPING)
aksiPlusOne =
RegularizedPreWarpedCepstrumEstimator.cepstrum2linearSpectrumValue(
((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i + 1].n).ceps,
(k + harmonicIndexShiftNext) * analysisParams.noiseF0InHz,
hnmSignal.samplingRateInHz);
else if (analysisParams.regularizedCepstrumWarpingMethod
== RegularizedCepstrumEstimator.REGULARIZED_CEPSTRUM_WITH_POST_MEL_WARPING)
aksiPlusOne =
RegularizedPostWarpedCepstrumEstimator.cepstrum2linearSpectrumValue(
((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i + 1].n).ceps,
(k + harmonicIndexShiftNext) * analysisParams.noiseF0InHz,
hnmSignal.samplingRateInHz);
} else {
if (k < ((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i + 1].n).ceps.length)
aksiPlusOne =
((FrameNoisePartPseudoHarmonic) hnmSignal.frames[i + 1].n)
.ceps[k]; // Use amplitudes directly without cepstrum method
else aksiPlusOne = 0.0;
}
} else aksiPlusOne = 0.0;
//
// Phases
phasekis[k] = (float) (MathUtils.TWOPI * (Math.random() - 0.5));
phasekiPlusOne =
(float)
(phasekis[k]
+ (k + harmonicIndexShiftCurrent)
* MathUtils.TWOPI
* analysisParams.noiseF0InHz
* (tsikPlusOne - tsik)); // Equation (3.55)
//
if (!isPrevTrackNoised) trackStartIndex = Math.max(0, trackStartIndex - transitionLen);
for (n = trackStartIndex; n <= Math.min(trackEndIndex, outputLen - 1); n++) {
t = SignalProcUtils.sample2time(n, hnmSignal.samplingRateInHz);
// if (t>=tsik && t<tsikPlusOne)
{
// Amplitude estimate
akt = MathUtils.interpolatedSample(tsik, t, tsikPlusOne, aksi, aksiPlusOne);
//
// Phase estimate
phasekt = (float) (phasekiPlusOne * (t - tsik) / (tsikPlusOne - tsik));
//
if (!isPrevTrackNoised && n - trackStartIndex < transitionLen)
noiseTracks[k][n] =
halfTransitionWinLeft[n - trackStartIndex] * akt * Math.cos(phasekt);
else noiseTracks[k][n] = akt * Math.cos(phasekt);
}
}
phasekis[k] = phasekiPlusOne;
}
}
}
for (k = 0; k < noiseTracks.length; k++) {
for (n = 0; n < noisePart.length; n++) noisePart[n] += noiseTracks[k][n];
}
// Write separate tracks to output
if (noiseTracks != null) {
for (k = 0; k < noiseTracks.length; k++) {
for (n = 0; n < noisePart.length; n++) noisePart[n] += noiseTracks[k][n];
}
if (referenceFile != null
&& FileUtils.exists(referenceFile)
&& synthesisParams.writeSeparateHarmonicTracksToOutputs) {
// Write separate tracks to output
AudioInputStream inputAudio = null;
try {
inputAudio = AudioSystem.getAudioInputStream(new File(referenceFile));
} catch (UnsupportedAudioFileException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (inputAudio != null) {
// k=1;
for (k = 0; k < noiseTracks.length; k++) {
noiseTracks[k] = MathUtils.divide(noiseTracks[k], 32767.0);
DDSAudioInputStream outputAudio =
new DDSAudioInputStream(
new BufferedDoubleDataSource(noiseTracks[k]), inputAudio.getFormat());
String outFileName =
StringUtils.getFolderName(referenceFile)
+ "noiseTrack"
+ String.valueOf(k + 1)
+ ".wav";
try {
AudioSystem.write(outputAudio, AudioFileFormat.Type.WAVE, new File(outFileName));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//
}
return noisePart;
}
