SignalProcUtils (MaryTTS 5.2 API)

java.lang.Object
- marytts.util.signal.SignalProcUtils

public class SignalProcUtils
extends Object

Constructor Summary

Constructors
Constructor and Description

SignalProcUtils()

Constructors
Constructor and Description
`SignalProcUtils()`

Method Summary

Methods
Modifier and Type	Method and Description
`static double[]`	`addSignals(double[] s1, double[] s2)`
`static double[]`	`addSignals(double[] s1, double gain1, double[] s2, double gain2)`
`static void`	`addWhiteNoise(double[] x, double level)`
`static double[]`	`applyPreemphasis(double[] frm, double preCoef)`
`static double[]`	`arFilter(double[] x, double[] a, double lpGain)`
`static double[]`	`arFilter(double[] x, double[] a, double lpGain, double[] yInitial)`
`static double[]`	`arFilter(double[] x, float[] a, double lpGain)`
`static double[]`	`arFilter(double[] x, float[] a, double lpGain, double[] yInitial)`
`static double[]`	`arFilterFreqDomain(double[] windowedFrame, double[] a, double lpGain, double startFreqInHz, double endFreqInHz, int samplingRateInHz)`
`static double[]`	`autocorr(double[] x, int LPOrder)`
`static double[]`	`bark2freq(double[] barks, int samplingRateInHz)`
`static double`	`bark2freq(double bark, int samplingRateInHz)`
`static double`	`barkNew2freq(double barkNew)`
`static double`	`barkNew2radian(double bark, int samplingRateInHz)`
`static void`	`centerClip(double[] x, double ratio)`
`static double`	`cepstrum2linearSpecAmp(float[] ceps, float freqInRadians)`
`static double`	`cepstrum2minimumPhase(float[] ceps, float freqInRadians)`
`static double[]`	`decimate(double[] x, double D)`
`static void`	`displayDFTSpectrumInDB(double[] frame)`
`static void`	`displayDFTSpectrumInDB(double[] frame, int fftSize)`
`static void`	`displayDFTSpectrumInDB(double[] frame, int fftSize, double[] wgt)`
`static void`	`displayDFTSpectrumInDB(double[] frame, int fftSize, int windowType)`
`static void`	`displayDFTSpectrumInDBNoWindowing(double[] frame)`
`static void`	`displayDFTSpectrumInDBNoWindowing(double[] frame, int fftSize)`
`static void`	`displayDFTSpectrumLinear(double[] frame)`
`static void`	`displayDFTSpectrumLinear(double[] frame, int fftSize)`
`static void`	`displayDFTSpectrumLinear(double[] frame, int fftSize, int windowType)`
`static void`	`displayDFTSpectrumLinearNoWindowing(double[] frame)`
`static void`	`displayDFTSpectrumLinearNoWindowing(double[] frame, int fftSize)`
`static void`	`displayLPSpectrumInDB(double[] alpha, double lpGain, int fftSize)`
`static void`	`displayLPSpectrumLinear(double[] alpha, double lpGain, int fftSize)`
`static double`	`energy(double[] x)`
`static double[]`	`fdFilter(ComplexArray frameDft, float startFreqInHz, float endFreqInHz, int samplingRateInHz, int origLen)`
`static double[]`	`fdFilter(double[] x, double[] filterFreqResponse)`
`static double[]`	`fdFilter(double[] x, float startFreqInHz, float endFreqInHz, int samplingRateInHz, int fftSize)`
`static double[][]`	`fft2barkmx(int nfft, int sr, int nfilts, int width, double minfreq, double maxfreq)` Java ported version of: wts = fft2barkmx(nfft, sr, nfilts, width) Generate a matrix of weights to combine FFT bins into Bark bins.
`static double[]`	`filter(double[] b, double[] x)`
`static double[]`	`filter(double[] b, double[] x, boolean bNormalize)`
`static double[]`	`filter(double[] b, double[] x, boolean bNormalize, double[] zi)`
`static double[]`	`filter(double[] b, double[] a, double[] x)`
`static double[]`	`filter(double[] b, double[] a, double[] x, boolean bNormalize)`
`static double[]`	`filter(double[] b, double[] a, double[] x, boolean bNormalize, double[] zi)`
`static double[]`	`filterfd(double[] filterFFTAbsMag, double[] x, double samplingRate)`
`static double[]`	`filterfd(double[] filterFFTAbsMag, double[] x, double samplingRate, double winsize)`
`static double[]`	`filterfd(double[] filterFFTAbsMag, double[] x, double samplingRate, double winsize, double skipsize)`
`static double[]`	`filtfilt(double[] b, double[] x)`
`static double[]`	`filtfilt(double[] b, double[] a, double[] x)`
`static double[]`	`fitLeastSquaresLine(double[] x, double[] y)`
`static double[]`	`fixedRateF0Values(PitchMarks pm, double wsFixedInSeconds, double ssFixedInSeconds, int numfrm, int samplingRate)`
`static int`	`frameIndex2LabelIndex(int zeroBasedFrameIndex, Labels labels, double windowSizeInSeconds, double skipSizeInSeconds)`
`static double`	`frameIndex2Time(int zeroBasedFrameIndex, double windowSizeInSeconds, double skipSizeInSeconds)`
`static float`	`frameIndex2Time(int zeroBasedFrameIndex, float windowSizeInSeconds, float skipSizeInSeconds)`
`static double`	`freq2bark(double freqInHz)`
`static double[]`	`freq2bark(double[] freqsInHz)`
`static double`	`freq2barkNew(double freqInHz)`
`static int[]`	`freq2index(double[] freqsInHz, int samplingRateInHz, int maxFreq)`
`static int`	`freq2index(double freqInHz, double samplingRateInHz, int maxFreqIndex)`
`static double[]`	`freq2indexDouble(double[] freqsInHz, double samplingRateInHz, int maxFreq)`
`static double`	`freq2indexDouble(double freqInHz, double samplingRateInHz, int maxFreqIndex)`
`static int`	`fullSpectrumSize(int maxFreq)`
`static float[]`	`getAnalysisTimes(int numfrm, double windowSizeInSeconds, double frameShiftInSeconds)`
`static double`	`getAverageSampleEnergy(double[] x)`
`static double`	`getAverageSampleEnergy(double[] x, int len)`
`static double`	`getAverageSampleEnergy(double[] x, int len, int start)`
`static float[]`	`getAverageSampleEnergyContour(double[] x, double windowSizeInSeconds, double skipSizeInSeconds, int samplingRate)`
`static float[]`	`getAverageSampleEnergyContour(double[] x, float[] times, int samplingRateInHz, float windowDurationInSeconds)`
`static double[]`	`getContourLSFit(double[] contour, boolean isPitchUVInterpolation)`
`static int`	`getDFTSize(int fs)`
`static double`	`getEnergy(double[] x)`
`static double`	`getEnergy(double[] x, int len)`
`static double`	`getEnergy(double[] x, int len, int start)`
`static double[]`	`getEnergyContourRms(double[] x, double windowSizeInSeconds, double skipSizeInSeconds, int samplingRate)`
`static double`	`getEnergydB(double x)`
`static double`	`getEnergydB(double[] x)`
`static double`	`getEnergydB(double[] x, int len)`
`static double`	`getEnergydB(double[] x, int len, int start)`
`static double[]`	`getExpF0s(double[] logF0s)`
`static double`	`getF0Range(double[] f0s)`
`static double`	`getF0Range(double[] f0s, double percentileMin, double percentileMax)`
`static int`	`getFIRFilterOrder(int fs)`
`static ComplexArray`	`getFrameDft(double[] frame, int fftSize)`
`static ComplexArray`	`getFrameDft(double[] frame, int fftSize, double[] windowWgt)`
`static ComplexArray`	`getFrameDft(double[] frame, int fftSize, int windowType)`
`static double[]`	`getFrameHalfMagnitudeSpectrum(double[] frame, int fftSize)`
`static double[]`	`getFrameHalfMagnitudeSpectrum(double[] frame, int fftSize, double[] wgt)`
`static double[]`	`getFrameHalfMagnitudeSpectrum(double[] frame, int fftSize, int windowType)`
`static double[]`	`getFrameMagnitudeSpectrum(double[] frame, int fftSize)`
`static double[]`	`getFrameMagnitudeSpectrum(double[] frame, int fftSize, double[] wgt)`
`static double[]`	`getFrameMagnitudeSpectrum(double[] frame, int fftSize, int windowType)`
`static int`	`getLifterOrder(int fs)`
`static double[]`	`getLogF0s(double[] f0s)`
`static int`	`getLPOrder(int fs)`
`static double[][]`	`getMapped(double[][] x, int[] mapInds)`
`static float[][]`	`getMapped(float[][] x, int[] mapInds)`
`static double`	`getMaximumFreqOfVoicingInHz(double[] specAmpsLinear, int[] peakInds, int[][] freqBandInds, int samplingRate)`
`static double[]`	`getNoise(double startFreqInHz, double endFreqInHz, double transitionBandwidthInHz, int samplingRateInHz, int len)`
`static double[]`	`getNoiseNormalizedFreqs(double normalizedStartFreq, double normalizedEndFreq, double normalizedTransitionBandwidth, int len)`
`static double[]`	`getPeakAmplitudeFrequencies(double[] sDft, double f0InHz, int numHarmonics, int fftSize, double samplingRateInHz, boolean bIncludeZerothHarmonic)`
`static double[]`	`getPeakAmplitudes(double[] sDft, double f0InHz, int numHarmonics, int fftSize, double samplingRateInHz, boolean bIncludeZerothHarmonic)`
`static double[]`	`getPeakAmplitudes(double[] sDft, double f0InHz, int startHarmonicIndex, int endHarmonicIndex, int fftSize, double samplingRateInHz, boolean amplitudes)`
`static double`	`getRmsDistance(double[] x, double[] y)`
`static int`	`getTotalFrames(double totalTimeInSeconds, double windowSizeInSeconds, double skipSizeInSeconds)`
`static int`	`getTotalFrames(int totalSamples, double windowSizeInSeconds, double skipSizeInSeconds)`
`static int`	`getTotalFrames(int totalSamples, int windowLengthInSamples, int skipSizeInSamples)`
`static double[]`	`getVoiceds(double[] f0s)`
`static boolean`	`getVoicing(double[] windowedSpeechFrame, int samplingRateInHz)`
`static boolean`	`getVoicing(double[] windowedSpeechFrame, int samplingRateInHz, double voicingThreshold)`
`static double`	`getVoicingProbability(double[] windowedSpeechFrame, int samplingRateInHz)`
`static boolean[]`	`getVuvs(double[] f0s)`
`static double[]`	`getWhiteNoise(int totalSamples, double maxAbsGain)`
`static double[]`	`getWhiteNoiseOfMeanVariance(int totalSamples, double mean, double variance)`
`static double[]`	`getWhiteNoiseOfVariance(int totalSamples, double variance)`
`static Window`	`getWindow(int windowType, int windowSizeInSamples)`
`static int`	`halfSpectrumSize(int fftSize)`
`static double`	`hz2bark(double freqInHz)` Since there is no asinh in Math, here it is used its definition: asinh(x) = ln( x + sqrt(x^2+1) ) This function is used in fft2barkmx()
`static double`	`hz2mel(double freqInHz, int samplingRateInHz)`
`static double`	`hz2radian(double hz, int samplingRate)`
`static float`	`hz2radian(float hz, int samplingRate)`
`static double`	`index2freq(int zeroBasedFreqIndex, int samplingRateInHz, int zeroBasedMaxFreqIndex)`
`static double`	`indexDouble2freq(double zeroBasedFreqIndex, int samplingRateInHz, int zeroBasedMaxFreqIndex)`
`static double[]`	`interpolate_pitch_uv(double[] f0s)`
`static double[]`	`interpolate_pitch_uv(double[] f0s, double minVoicedVal)`
`static double[]`	`interpolate(double[] x, double D)`
`static void`	`main(String[] args)`
`static int[]`	`mapFrameIndices(int numfrmSource, Labels srcLabs, double srcWindowSizeInSeconds, double srcSkipSizeInSeconds, int numFrmTarget, Labels tgtLabs, double tgtWindowSizeInSeconds, double tgtSkipSizeInSeconds)`
`static double`	`mean(Vector<Double> v)`
`static double[]`	`meanFilter(double[] x, int N)`
`static double[]`	`meanFilter(double[] x, int N, double leftOutOfBound, double rightOutOfBound)`
`static float[]`	`meanFilter(float[] x, int N)`
`static float[]`	`meanFilter(float[] x, int N, float leftOutOfBound, float rightOutOfBound)`
`static double[]`	`medianFilter(double[] x)`
`static double[]`	`medianFilter(double[] x, int N)`
`static float[]`	`medianFilter(float[] x)`
`static float[]`	`medianFilter(float[] x, int N)`
`static double`	`mel2hz(double mel, int samplingRateInHz)`
`static double`	`mel2radian(double mel, int samplingRateInHz)`
`static double`	`melNonMultiplied(double freqInRadian, int samplingRateInHz)`
`static double[]`	`merge(double[] x1, double[] x2)`
`static int[]`	`merge(int[] x1, int[] x2)`
`static double[]`	`normalizeAverageSampleEnergy(double[] x, double newAverageSampleEnergy)`
`static double[]`	`normalizeAverageSampleEnergyContour(double[] x, float[] times, float[] currentContour, float[] targetContour, int samplingRateInHz, float windowDurationInSeconds)`
`static double[]`	`normalizeVocalTract(double[] srcSignal, double[] tgtSignal, int windowType, double windowSizeInSeconds, double frameShiftInSeconds, int lpcOrder, int samplingRateInHz, float preCoef)`
`static double[]`	`normalizeVocalTract(double[] srcSignal, double[] tgtSignal, Labels sourceLabels, Labels targetLabels, int windowType, double windowSizeInSeconds, double frameShiftInSeconds, int lpcOrder, int samplingRateInHz, float preCoef)`
`static double[]`	`normalizeVocalTract(double[] x, float[] tAnalysisInSeconds, float[][] srcLpcs, float[][] mappedTgtLpcs, double windowSizeInSeconds, int samplingRateInHz, float preCoef)`
`static double[]`	`normalizeVocalTract(double[] s, float[] sAnalysisInSeconds, float[][] mappedTgtLpcs, int windowType, double windowSizeInSeconds, int lpcOrderSrc, int samplingRateInHz, float preCoef)`
`static PitchMarks`	`pitchContour2pitchMarks(double[] f0s, int fs, int len, double ws, double ss, boolean bPaddZerosForFinalPitchMark, int offset)`
`static double[]`	`pitchMarks2PitchContour(int[] pitchMarks, float ws, float ss, int samplingRate)`
`static double[]`	`pitchScalePitchContour(double[] f0s, float ws, float ss, float[] pScales, float[] pScalesTimes)`
`static double`	`radian2hz(double rad, int samplingRate)`
`static float`	`radian2hz(float rad, int samplingRate)`
`static double`	`radian2mel(double freqInRadian, int samplingRateInHz)`
`static double[]`	`removePreemphasis(double[] frm, double preCoef)`
`static double[]`	`replaceNaNsWith(double[] x, double val)`
`static double[]`	`reverse(double[] x)`
`static float`	`sample2time(float sample, int samplingRate)`
`static float`	`sample2time(int sample, int samplingRate)`
`static float`	`sample2time(long sample, int samplingRate)`
`static float`	`sampleFloat2time(float sample, int samplingRate)`
`static float[]`	`samples2times(int[] samples, int samplingRate)`
`static double[]`	`shift(double[] x, int N)`
`static float[]`	`shift(float[] x, int N)`
`static double`	`sourceTime2targetTime(double sourceTime, Labels sourceLabels, Labels targetLabels)`
`static double`	`sourceTime2targetTime(double sourceTime, Labels sourceLabels, Labels targetLabels, int[][] map)`
`static float[]`	`specLinear2cepstrum(double[] specLinear, int cepsOrder)`
`static double[]`	`spectralMirror(double[] halfSpectrum)`
`static double[]`	`subtractSignals(double[] s1, double[] s2)`
`static void`	`test_normalizeVocalTract()`
`static int`	`time2frameIndex(double time, double windowSizeInSeconds, double skipSizeInSeconds)`
`static int`	`time2frameIndex(float time, float windowSizeInSeconds, float skipSizeInSeconds)`
`static int`	`time2LabelIndex(double time, Labels labels)`
`static int[]`	`time2sample(double[] times, int samplingRate)`
`static int`	`time2sample(double time, int samplingRate)`
`static int[]`	`time2sample(float[] times, int samplingRate)`
`static int`	`time2sample(float time, int samplingRate)`
`static double`	`time2sampleDouble(double time, int samplingRate)`
`static int[]`	`times2samples(float[] times, int samplingRate)`
`static float`	`timeScaledTime(float t, float[] scales, float[] times)`
`static float[]`	`timeScaledTimes(float[] times, float[] tScales, float[] tScalesTimes)`
`static double[]`	`timeScalePitchContour(double[] f0s, float ws, float ss, float[] tScales, float[] tScalesTimes)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- SignalProcUtils
```
public SignalProcUtils()
```

Method Detail

getLPOrder
```
public static int getLPOrder(int fs)
```

getDFTSize
```
public static int getDFTSize(int fs)
```

getFIRFilterOrder

public static int getFIRFilterOrder(int fs)

getLifterOrder

public static int getLifterOrder(int fs)

halfSpectrumSize

public static int halfSpectrumSize(int fftSize)

fullSpectrumSize

public static int fullSpectrumSize(int maxFreq)

getEnergydB

public static double getEnergydB(double x)

getEnergydB

public static double getEnergydB(double[] x)

getEnergydB

public static double getEnergydB(double[] x,
                 int len)

getEnergydB

public static double getEnergydB(double[] x,
                 int len,
                 int start)

getEnergy

public static double getEnergy(double[] x,
               int len,
               int start)

getEnergy

public static double getEnergy(double[] x,
               int len)

getEnergy

public static double getEnergy(double[] x)

getAverageSampleEnergy

public static double getAverageSampleEnergy(double[] x,
                            int len,
                            int start)

getAverageSampleEnergy

public static double getAverageSampleEnergy(double[] x,
                            int len)

getAverageSampleEnergy

public static double getAverageSampleEnergy(double[] x)

normalizeAverageSampleEnergy

public static double[] normalizeAverageSampleEnergy(double[] x,
                                    double newAverageSampleEnergy)

getEnergyContourRms

public static double[] getEnergyContourRms(double[] x,
                           double windowSizeInSeconds,
                           double skipSizeInSeconds,
                           int samplingRate)

getAverageSampleEnergyContour

public static float[] getAverageSampleEnergyContour(double[] x,
                                    double windowSizeInSeconds,
                                    double skipSizeInSeconds,
                                    int samplingRate)

getAverageSampleEnergyContour

public static float[] getAverageSampleEnergyContour(double[] x,
                                    float[] times,
                                    int samplingRateInHz,
                                    float windowDurationInSeconds)

normalizeAverageSampleEnergyContour

public static double[] normalizeAverageSampleEnergyContour(double[] x,
                                           float[] times,
                                           float[] currentContour,
                                           float[] targetContour,
                                           int samplingRateInHz,
                                           float windowDurationInSeconds)

reverse

public static double[] reverse(double[] x)

getVuvs

public static boolean[] getVuvs(double[] f0s)

pitchContour2pitchMarks

public static PitchMarks pitchContour2pitchMarks(double[] f0s,
                                 int fs,
                                 int len,
                                 double ws,
                                 double ss,
                                 boolean bPaddZerosForFinalPitchMark,
                                 int offset)

pitchMarks2PitchContour

public static double[] pitchMarks2PitchContour(int[] pitchMarks,
                               float ws,
                               float ss,
                               int samplingRate)

fixedRateF0Values

public static double[] fixedRateF0Values(PitchMarks pm,
                         double wsFixedInSeconds,
                         double ssFixedInSeconds,
                         int numfrm,
                         int samplingRate)

interpolate_pitch_uv

public static double[] interpolate_pitch_uv(double[] f0s)

interpolate_pitch_uv

public static double[] interpolate_pitch_uv(double[] f0s,
                            double minVoicedVal)

getContourLSFit

public static double[] getContourLSFit(double[] contour,
                       boolean isPitchUVInterpolation)

fitLeastSquaresLine

public static double[] fitLeastSquaresLine(double[] x,
                           double[] y)

getVoicing

public static boolean getVoicing(double[] windowedSpeechFrame,
                 int samplingRateInHz)

getVoicing

public static boolean getVoicing(double[] windowedSpeechFrame,
                 int samplingRateInHz,
                 double voicingThreshold)

getVoicingProbability

public static double getVoicingProbability(double[] windowedSpeechFrame,
                           int samplingRateInHz)

autocorr

public static double[] autocorr(double[] x,
                int LPOrder)

applyPreemphasis

public static double[] applyPreemphasis(double[] frm,
                        double preCoef)

removePreemphasis

public static double[] removePreemphasis(double[] frm,
                         double preCoef)

freq2bark

public static double[] freq2bark(double[] freqsInHz)

freq2bark

public static double freq2bark(double freqInHz)

hz2bark
```
public static double hz2bark(double freqInHz)
```
Since there is no asinh in Math, here it is used its definition: asinh(x) = ln( x + sqrt(x^2+1) ) This function is used in fft2barkmx()

Parameters:
freqInHz - frequency In Hz

Returns:
6 times log of f + square root of f times t + 1

freq2barkNew

public static double freq2barkNew(double freqInHz)

barkNew2freq

public static double barkNew2freq(double barkNew)

bark2freq

public static double[] bark2freq(double[] barks,
                 int samplingRateInHz)

bark2freq

public static double bark2freq(double bark,
               int samplingRateInHz)

barkNew2radian

public static double barkNew2radian(double bark,
                    int samplingRateInHz)

fft2barkmx
```
public static double[][] fft2barkmx(int nfft,
                    int sr,
                    int nfilts,
                    int width,
                    double minfreq,
                    double maxfreq)
```
Java ported version of: wts = fft2barkmx(nfft, sr, nfilts, width) Generate a matrix of weights to combine FFT bins into Bark bins. nfft defines the source FFT size at sampling rate sr. Optional nfilts specifies the number of output bands required (else one per bark), and width is the constant width of each band in Bark (default 1). While wts has nfft columns, the second half are all zero. Hence, Bark spectrum is fft2barkmx(nfft,sr)*abs(fft(xincols,nfft)); 2004-09-05 dpwe@ee.columbia.edu based on rastamat/audspec.m

Parameters:
nfft - FFT size
sr - sampling rate
nfilts - number of output bark bands
width - width of each band in Bark (default 1)
minfreq - min frequency
maxfreq - max frequency

Returns:
wts

freq2index

public static int[] freq2index(double[] freqsInHz,
               int samplingRateInHz,
               int maxFreq)

freq2index

public static int freq2index(double freqInHz,
             double samplingRateInHz,
             int maxFreqIndex)

freq2indexDouble

public static double[] freq2indexDouble(double[] freqsInHz,
                        double samplingRateInHz,
                        int maxFreq)

freq2indexDouble

public static double freq2indexDouble(double freqInHz,
                      double samplingRateInHz,
                      int maxFreqIndex)

index2freq

public static double index2freq(int zeroBasedFreqIndex,
                int samplingRateInHz,
                int zeroBasedMaxFreqIndex)

indexDouble2freq

public static double indexDouble2freq(double zeroBasedFreqIndex,
                      int samplingRateInHz,
                      int zeroBasedMaxFreqIndex)

sample2time

public static float sample2time(int sample,
                int samplingRate)

sampleFloat2time

public static float sampleFloat2time(float sample,
                     int samplingRate)

sample2time

public static float sample2time(long sample,
                int samplingRate)

sample2time

public static float sample2time(float sample,
                int samplingRate)

time2sample

public static int time2sample(float time,
              int samplingRate)

time2sample

public static int[] time2sample(float[] times,
                int samplingRate)

time2sample

public static int time2sample(double time,
              int samplingRate)

time2sample

public static int[] time2sample(double[] times,
                int samplingRate)

time2sampleDouble

public static double time2sampleDouble(double time,
                       int samplingRate)

samples2times

public static float[] samples2times(int[] samples,
                    int samplingRate)

times2samples

public static int[] times2samples(float[] times,
                  int samplingRate)

timeScaledTime

public static float timeScaledTime(float t,
                   float[] scales,
                   float[] times)

timeScaledTimes

public static float[] timeScaledTimes(float[] times,
                      float[] tScales,
                      float[] tScalesTimes)

timeScalePitchContour

public static double[] timeScalePitchContour(double[] f0s,
                             float ws,
                             float ss,
                             float[] tScales,
                             float[] tScalesTimes)

pitchScalePitchContour

public static double[] pitchScalePitchContour(double[] f0s,
                              float ws,
                              float ss,
                              float[] pScales,
                              float[] pScalesTimes)

getNoise

public static double[] getNoise(double startFreqInHz,
                double endFreqInHz,
                double transitionBandwidthInHz,
                int samplingRateInHz,
                int len)

getNoiseNormalizedFreqs

public static double[] getNoiseNormalizedFreqs(double normalizedStartFreq,
                               double normalizedEndFreq,
                               double normalizedTransitionBandwidth,
                               int len)

radian2hz

public static float radian2hz(float rad,
              int samplingRate)

radian2hz

public static double radian2hz(double rad,
               int samplingRate)

hz2radian

public static float hz2radian(float hz,
              int samplingRate)

hz2radian

public static double hz2radian(double hz,
               int samplingRate)

medianFilter

public static double[] medianFilter(double[] x)

medianFilter

public static float[] medianFilter(float[] x)

medianFilter

public static float[] medianFilter(float[] x,
                   int N)

medianFilter

public static double[] medianFilter(double[] x,
                    int N)

meanFilter

public static double[] meanFilter(double[] x,
                  int N)

meanFilter

public static float[] meanFilter(float[] x,
                 int N)

meanFilter

public static float[] meanFilter(float[] x,
                 int N,
                 float leftOutOfBound,
                 float rightOutOfBound)

meanFilter

public static double[] meanFilter(double[] x,
                  int N,
                  double leftOutOfBound,
                  double rightOutOfBound)

mean

public static double mean(Vector<Double> v)

frameIndex2Time

public static float frameIndex2Time(int zeroBasedFrameIndex,
                    float windowSizeInSeconds,
                    float skipSizeInSeconds)

frameIndex2Time

public static double frameIndex2Time(int zeroBasedFrameIndex,
                     double windowSizeInSeconds,
                     double skipSizeInSeconds)

time2frameIndex

public static int time2frameIndex(float time,
                  float windowSizeInSeconds,
                  float skipSizeInSeconds)

time2frameIndex

public static int time2frameIndex(double time,
                  double windowSizeInSeconds,
                  double skipSizeInSeconds)

centerClip

public static void centerClip(double[] x,
              double ratio)

getVoiceds

public static double[] getVoiceds(double[] f0s)

getLogF0s

public static double[] getLogF0s(double[] f0s)

getExpF0s

public static double[] getExpF0s(double[] logF0s)

getF0Range

public static double getF0Range(double[] f0s)

getF0Range

public static double getF0Range(double[] f0s,
                double percentileMin,
                double percentileMax)

frameIndex2LabelIndex

public static int frameIndex2LabelIndex(int zeroBasedFrameIndex,
                        Labels labels,
                        double windowSizeInSeconds,
                        double skipSizeInSeconds)

time2LabelIndex

public static int time2LabelIndex(double time,
                  Labels labels)

getRmsDistance

public static double getRmsDistance(double[] x,
                    double[] y)

merge

public static int[] merge(int[] x1,
          int[] x2)

merge

public static double[] merge(double[] x1,
             double[] x2)

decimate

public static double[] decimate(double[] x,
                double D)

interpolate

public static double[] interpolate(double[] x,
                   double D)

energy

public static double energy(double[] x)

filter

public static double[] filter(double[] b,
              double[] x)

filter

public static double[] filter(double[] b,
              double[] a,
              double[] x)

filter

public static double[] filter(double[] b,
              double[] x,
              boolean bNormalize)

filter

public static double[] filter(double[] b,
              double[] a,
              double[] x,
              boolean bNormalize)

filter

public static double[] filter(double[] b,
              double[] x,
              boolean bNormalize,
              double[] zi)

filter

public static double[] filter(double[] b,
              double[] a,
              double[] x,
              boolean bNormalize,
              double[] zi)

filtfilt

public static double[] filtfilt(double[] b,
                double[] x)

filtfilt

public static double[] filtfilt(double[] b,
                double[] a,
                double[] x)

filterfd

public static double[] filterfd(double[] filterFFTAbsMag,
                double[] x,
                double samplingRate)

filterfd

public static double[] filterfd(double[] filterFFTAbsMag,
                double[] x,
                double samplingRate,
                double winsize)

filterfd

public static double[] filterfd(double[] filterFFTAbsMag,
                double[] x,
                double samplingRate,
                double winsize,
                double skipsize)

addWhiteNoise

public static void addWhiteNoise(double[] x,
                 double level)

getWhiteNoise

public static double[] getWhiteNoise(int totalSamples,
                     double maxAbsGain)

getWhiteNoiseOfVariance

public static double[] getWhiteNoiseOfVariance(int totalSamples,
                               double variance)

getWhiteNoiseOfMeanVariance

public static double[] getWhiteNoiseOfMeanVariance(int totalSamples,
                                   double mean,
                                   double variance)

specLinear2cepstrum

public static float[] specLinear2cepstrum(double[] specLinear,
                          int cepsOrder)

cepstrum2linearSpecAmp

public static double cepstrum2linearSpecAmp(float[] ceps,
                            float freqInRadians)

cepstrum2minimumPhase

public static double cepstrum2minimumPhase(float[] ceps,
                           float freqInRadians)

getMaximumFreqOfVoicingInHz

public static double getMaximumFreqOfVoicingInHz(double[] specAmpsLinear,
                                 int[] peakInds,
                                 int[][] freqBandInds,
                                 int samplingRate)

spectralMirror

public static double[] spectralMirror(double[] halfSpectrum)

addSignals

public static double[] addSignals(double[] s1,
                  double[] s2)

addSignals

public static double[] addSignals(double[] s1,
                  double gain1,
                  double[] s2,
                  double gain2)

subtractSignals

public static double[] subtractSignals(double[] s1,
                       double[] s2)

arFilter

public static double[] arFilter(double[] x,
                double[] a,
                double lpGain)

arFilter

public static double[] arFilter(double[] x,
                float[] a,
                double lpGain)

arFilter

public static double[] arFilter(double[] x,
                float[] a,
                double lpGain,
                double[] yInitial)

arFilter

public static double[] arFilter(double[] x,
                double[] a,
                double lpGain,
                double[] yInitial)

arFilterFreqDomain

public static double[] arFilterFreqDomain(double[] windowedFrame,
                          double[] a,
                          double lpGain,
                          double startFreqInHz,
                          double endFreqInHz,
                          int samplingRateInHz)

fdFilter

public static double[] fdFilter(double[] x,
                double[] filterFreqResponse)

fdFilter

public static double[] fdFilter(double[] x,
                float startFreqInHz,
                float endFreqInHz,
                int samplingRateInHz,
                int fftSize)

fdFilter

public static double[] fdFilter(ComplexArray frameDft,
                float startFreqInHz,
                float endFreqInHz,
                int samplingRateInHz,
                int origLen)

displayDFTSpectrumLinearNoWindowing

public static void displayDFTSpectrumLinearNoWindowing(double[] frame)

displayDFTSpectrumLinearNoWindowing

public static void displayDFTSpectrumLinearNoWindowing(double[] frame,
                                       int fftSize)

displayDFTSpectrumLinear

public static void displayDFTSpectrumLinear(double[] frame)

displayDFTSpectrumLinear

public static void displayDFTSpectrumLinear(double[] frame,
                            int fftSize)

displayDFTSpectrumLinear

public static void displayDFTSpectrumLinear(double[] frame,
                            int fftSize,
                            int windowType)

displayDFTSpectrumInDBNoWindowing

public static void displayDFTSpectrumInDBNoWindowing(double[] frame)

displayDFTSpectrumInDBNoWindowing

public static void displayDFTSpectrumInDBNoWindowing(double[] frame,
                                     int fftSize)

displayDFTSpectrumInDB

public static void displayDFTSpectrumInDB(double[] frame)

displayDFTSpectrumInDB

public static void displayDFTSpectrumInDB(double[] frame,
                          int fftSize)

displayDFTSpectrumInDB

public static void displayDFTSpectrumInDB(double[] frame,
                          int fftSize,
                          int windowType)

displayDFTSpectrumInDB

public static void displayDFTSpectrumInDB(double[] frame,
                          int fftSize,
                          double[] wgt)

getFrameHalfMagnitudeSpectrum

public static double[] getFrameHalfMagnitudeSpectrum(double[] frame,
                                     int fftSize)

getFrameMagnitudeSpectrum

public static double[] getFrameMagnitudeSpectrum(double[] frame,
                                 int fftSize)

getFrameHalfMagnitudeSpectrum

public static double[] getFrameHalfMagnitudeSpectrum(double[] frame,
                                     int fftSize,
                                     int windowType)

getFrameMagnitudeSpectrum

public static double[] getFrameMagnitudeSpectrum(double[] frame,
                                 int fftSize,
                                 int windowType)

getFrameHalfMagnitudeSpectrum

public static double[] getFrameHalfMagnitudeSpectrum(double[] frame,
                                     int fftSize,
                                     double[] wgt)

getFrameMagnitudeSpectrum

public static double[] getFrameMagnitudeSpectrum(double[] frame,
                                 int fftSize,
                                 double[] wgt)

getFrameDft

public static ComplexArray getFrameDft(double[] frame,
                       int fftSize)

getFrameDft

public static ComplexArray getFrameDft(double[] frame,
                       int fftSize,
                       int windowType)

getFrameDft

public static ComplexArray getFrameDft(double[] frame,
                       int fftSize,
                       double[] windowWgt)

displayLPSpectrumLinear

public static void displayLPSpectrumLinear(double[] alpha,
                           double lpGain,
                           int fftSize)

displayLPSpectrumInDB

public static void displayLPSpectrumInDB(double[] alpha,
                         double lpGain,
                         int fftSize)

shift

public static double[] shift(double[] x,
             int N)

shift

public static float[] shift(float[] x,
            int N)

getPeakAmplitudes

public static double[] getPeakAmplitudes(double[] sDft,
                         double f0InHz,
                         int numHarmonics,
                         int fftSize,
                         double samplingRateInHz,
                         boolean bIncludeZerothHarmonic)

getPeakAmplitudeFrequencies

public static double[] getPeakAmplitudeFrequencies(double[] sDft,
                                   double f0InHz,
                                   int numHarmonics,
                                   int fftSize,
                                   double samplingRateInHz,
                                   boolean bIncludeZerothHarmonic)

getPeakAmplitudes
```
public static double[] getPeakAmplitudes(double[] sDft,
                         double f0InHz,
                         int startHarmonicIndex,
                         int endHarmonicIndex,
                         int fftSize,
                         double samplingRateInHz,
                         boolean amplitudes)
```
Parameters:
sDft - sDtf
f0InHz - f0InHz
startHarmonicIndex - startHarmonicIndex
endHarmonicIndex - endHarmonicIndex
fftSize - fftSize
samplingRateInHz - samplingRateInHz
amplitudes - : if amplitudes true it returns the amplitude values, original function if amplitudes false it returns the amplitude frequencies where the peaks were located

Returns:
amps if amplitudes, ampsFreq otherwise

getAnalysisTimes

public static float[] getAnalysisTimes(int numfrm,
                       double windowSizeInSeconds,
                       double frameShiftInSeconds)

getMapped

public static double[][] getMapped(double[][] x,
                   int[] mapInds)

getMapped

public static float[][] getMapped(float[][] x,
                  int[] mapInds)

getWindow

public static Window getWindow(int windowType,
               int windowSizeInSamples)

getTotalFrames

public static int getTotalFrames(int totalSamples,
                 int windowLengthInSamples,
                 int skipSizeInSamples)

getTotalFrames

public static int getTotalFrames(int totalSamples,
                 double windowSizeInSeconds,
                 double skipSizeInSeconds)

getTotalFrames

public static int getTotalFrames(double totalTimeInSeconds,
                 double windowSizeInSeconds,
                 double skipSizeInSeconds)

melNonMultiplied

public static double melNonMultiplied(double freqInRadian,
                      int samplingRateInHz)

radian2mel

public static double radian2mel(double freqInRadian,
                int samplingRateInHz)

hz2mel

public static double hz2mel(double freqInHz,
            int samplingRateInHz)

mel2radian

public static double mel2radian(double mel,
                int samplingRateInHz)

mel2hz

public static double mel2hz(double mel,
            int samplingRateInHz)

replaceNaNsWith

public static double[] replaceNaNsWith(double[] x,
                       double val)

sourceTime2targetTime

public static double sourceTime2targetTime(double sourceTime,
                           Labels sourceLabels,
                           Labels targetLabels)

sourceTime2targetTime

public static double sourceTime2targetTime(double sourceTime,
                           Labels sourceLabels,
                           Labels targetLabels,
                           int[][] map)

mapFrameIndices

public static int[] mapFrameIndices(int numfrmSource,
                    Labels srcLabs,
                    double srcWindowSizeInSeconds,
                    double srcSkipSizeInSeconds,
                    int numFrmTarget,
                    Labels tgtLabs,
                    double tgtWindowSizeInSeconds,
                    double tgtSkipSizeInSeconds)

normalizeVocalTract

public static double[] normalizeVocalTract(double[] srcSignal,
                           double[] tgtSignal,
                           Labels sourceLabels,
                           Labels targetLabels,
                           int windowType,
                           double windowSizeInSeconds,
                           double frameShiftInSeconds,
                           int lpcOrder,
                           int samplingRateInHz,
                           float preCoef)

normalizeVocalTract

public static double[] normalizeVocalTract(double[] s,
                           float[] sAnalysisInSeconds,
                           float[][] mappedTgtLpcs,
                           int windowType,
                           double windowSizeInSeconds,
                           int lpcOrderSrc,
                           int samplingRateInHz,
                           float preCoef)

normalizeVocalTract

public static double[] normalizeVocalTract(double[] x,
                           float[] tAnalysisInSeconds,
                           float[][] srcLpcs,
                           float[][] mappedTgtLpcs,
                           double windowSizeInSeconds,
                           int samplingRateInHz,
                           float preCoef)

test_normalizeVocalTract

public static void test_normalizeVocalTract()
                                     throws UnsupportedAudioFileException,
                                            IOException

Throws:: UnsupportedAudioFileException; IOException

normalizeVocalTract

public static double[] normalizeVocalTract(double[] srcSignal,
                           double[] tgtSignal,
                           int windowType,
                           double windowSizeInSeconds,
                           double frameShiftInSeconds,
                           int lpcOrder,
                           int samplingRateInHz,
                           float preCoef)

main

public static void main(String[] args)
                 throws UnsupportedAudioFileException,
                        IOException

Throws:: UnsupportedAudioFileException; IOException

Class SignalProcUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SignalProcUtils

Method Detail

getLPOrder

getDFTSize

getFIRFilterOrder

getLifterOrder

halfSpectrumSize

fullSpectrumSize

getEnergydB

getEnergydB

getEnergydB

getEnergydB

getEnergy

getEnergy

getEnergy

getAverageSampleEnergy

getAverageSampleEnergy

getAverageSampleEnergy

normalizeAverageSampleEnergy

getEnergyContourRms

getAverageSampleEnergyContour

getAverageSampleEnergyContour

normalizeAverageSampleEnergyContour

reverse

getVuvs

pitchContour2pitchMarks

pitchMarks2PitchContour

fixedRateF0Values

interpolate_pitch_uv

interpolate_pitch_uv

getContourLSFit

fitLeastSquaresLine

getVoicing

getVoicing

getVoicingProbability

autocorr

applyPreemphasis

removePreemphasis

freq2bark

freq2bark

hz2bark

freq2barkNew

barkNew2freq

bark2freq

bark2freq

barkNew2radian

fft2barkmx

freq2index

freq2index

freq2indexDouble

freq2indexDouble

index2freq

indexDouble2freq

sample2time

sampleFloat2time

sample2time

sample2time

time2sample

time2sample

time2sample

time2sample

time2sampleDouble

samples2times

times2samples

timeScaledTime

timeScaledTimes

timeScalePitchContour

pitchScalePitchContour

getNoise

getNoiseNormalizedFreqs

radian2hz

radian2hz

hz2radian

hz2radian

medianFilter