protected void process() {
int i, j, len, ch, chunkLength;
long progOff, progLen;
float f1;
// io
AudioFile inF = null;
AudioFile outF = null;
AudioFileDescr inStream;
AudioFileDescr outStream;
FloatFile[] floatF = null;
File tempFile[] = null;
// buffers
float[][] inBuf, outBuf;
float[] win;
float[] convBuf1, convBuf2;
float[] tempFlt;
int inChanNum, inLength, inputStep, outputStep, winSize;
int transLen, skip, inputLen, outputLen, fltLen;
int framesRead, framesWritten;
float warp, a1, b0, b1, x0, x1, y0, y1, b0init;
Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
Param peakGain;
float gain = 1.0f; // gain abs amp
float maxAmp = 0.0f;
PathField ggOutput;
topLevel:
try {
// ---- open input, output ----
// input
inF = AudioFile.openAsRead(new File(pr.text[PR_INPUTFILE]));
inStream = inF.getDescr();
inChanNum = inStream.channels;
inLength = (int) inStream.length;
// this helps to prevent errors from empty files!
if ((inLength * inChanNum) < 1) throw new EOFException(ERR_EMPTY);
// .... check running ....
if (!threadRunning) break topLevel;
// output
ggOutput = (PathField) gui.getItemObj(GG_OUTPUTFILE);
if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
outStream = new AudioFileDescr(inStream);
ggOutput.fillStream(outStream);
outF = AudioFile.openAsWrite(outStream);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- parameter inits ----
warp =
Math.max(-0.98f, Math.min(0.98f, (float) (pr.para[PR_WARP].val / 100))); // DAFx2000 'b'
f1 = (1.0f - warp) / (1.0f + warp); // DAFx2000 (25)
winSize = 32 << pr.intg[PR_FRAMESIZE]; // DAFx2000 'N'
j = winSize >> 1;
transLen = (int) (f1 * winSize + 0.5f); // DAFx2000 'P' (26)
i = pr.intg[PR_OVERLAP] + 1;
while (((float) transLen / (float) i) > j) i++;
inputStep = (int) (((float) transLen / (float) i) + 0.5f); // DAFx2000 'L'
fltLen = Math.max(winSize, transLen);
// System.out.println( "inputStep "+inputStep+"; winSize "+winSize+"; transLen "+transLen+";
// fltLen "+fltLen+"; warp "+warp+"; � "+f1 );
win = Filter.createFullWindow(winSize, Filter.WIN_HANNING); // DAFx2000 (27)
outputStep = inputStep;
b0init = (float) Math.sqrt(1.0f - warp * warp);
progOff = 0;
progLen = (long) inLength * (2 + inChanNum); // + winSize;
tempFlt = new float[fltLen];
inputLen = winSize + inputStep;
inBuf = new float[inChanNum][inputLen];
outputLen = transLen + outputStep;
outBuf = new float[inChanNum][outputLen];
// normalization requires temp files
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
tempFile = new File[inChanNum];
floatF = new FloatFile[inChanNum];
for (ch = 0; ch < inChanNum; ch++) { // first zero them because an exception might be thrown
tempFile[ch] = null;
floatF[ch] = null;
}
for (ch = 0; ch < inChanNum; ch++) {
tempFile[ch] = IOUtil.createTempFile();
floatF[ch] = new FloatFile(tempFile[ch], GenericFile.MODE_OUTPUT);
}
progLen += (long) inLength;
} else {
gain = (float) ((Param.transform(pr.para[PR_GAIN], Param.ABS_AMP, ampRef, null)).val);
}
// .... check running ....
if (!threadRunning) break topLevel;
// ----==================== the real stuff ====================----
framesRead = 0;
framesWritten = 0;
skip = 0;
while (threadRunning && (framesWritten < inLength)) {
chunkLength = Math.min(inputLen, inLength - framesRead + skip);
// ---- read input chunk ----
len = Math.max(0, chunkLength - skip);
inF.readFrames(inBuf, skip, len);
framesRead += len;
progOff += len;
// off += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// .... check running ....
if (!threadRunning) break topLevel;
// zero padding
if (chunkLength < inputLen) {
for (ch = 0; ch < inChanNum; ch++) {
convBuf1 = inBuf[ch];
for (i = chunkLength; i < convBuf1.length; i++) {
convBuf1[i] = 0.0f;
}
}
}
for (ch = 0; threadRunning && (ch < inChanNum); ch++) {
convBuf1 = inBuf[ch];
convBuf2 = outBuf[ch];
for (i = 0, j = fltLen; i < winSize; i++) {
tempFlt[--j] = convBuf1[i] * win[i];
}
while (j > 0) {
tempFlt[--j] = 0.0f;
}
a1 = -warp; // inital allpass
b0 = b0init;
b1 = 0.0f;
for (j = 0; j < transLen; j++) {
x1 = 0.0f;
y1 = 0.0f;
// for( i = 0; i < transLen; i++ ) { // DAFx2000 (2 resp. 3)
for (i = 0; i < fltLen; i++) { // DAFx2000 (2 resp. 3)
x0 = tempFlt[i];
y0 = b0 * x0 + b1 * x1 - a1 * y1;
tempFlt[i] = y0; // (work with double precision while computing cascades)
y1 = y0;
x1 = x0;
}
a1 = -warp; // cascaded allpasses
b0 = -warp;
b1 = 1.0f;
convBuf2[j] += (float) y1;
}
// .... progress ....
progOff += chunkLength - skip;
setProgression((float) progOff / (float) progLen);
} // for channels
// .... check running ....
if (!threadRunning) break topLevel;
chunkLength = Math.min(outputStep, inLength - framesWritten);
// ---- write output chunk ----
if (floatF != null) {
for (ch = 0; ch < inChanNum; ch++) {
floatF[ch].writeFloats(outBuf[ch], 0, chunkLength);
}
progOff += chunkLength;
// off += len;
framesWritten += chunkLength;
// .... progress ....
setProgression((float) progOff / (float) progLen);
} else {
for (ch = 0; ch < inChanNum; ch++) {
Util.mult(outBuf[ch], 0, chunkLength, gain);
}
outF.writeFrames(outBuf, 0, chunkLength);
progOff += chunkLength;
// off += len;
framesWritten += chunkLength;
// .... progress ....
setProgression((float) progOff / (float) progLen);
}
// .... check running ....
if (!threadRunning) break topLevel;
// check max amp
for (ch = 0; ch < inChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) {
f1 = Math.abs(convBuf1[i]);
if (f1 > maxAmp) {
maxAmp = f1;
}
}
}
// overlaps
skip = winSize;
for (ch = 0; ch < inChanNum; ch++) {
System.arraycopy(inBuf[ch], inputStep, inBuf[ch], 0, winSize);
convBuf1 = outBuf[ch];
System.arraycopy(convBuf1, outputStep, convBuf1, 0, transLen);
for (i = transLen; i < outputLen; ) {
convBuf1[i++] = 0.0f;
}
}
} // until framesWritten == outLength
// .... check running ....
if (!threadRunning) break topLevel;
// ----==================== normalize output ====================----
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
peakGain = new Param((double) maxAmp, Param.ABS_AMP);
gain =
(float)
(Param.transform(
pr.para[PR_GAIN],
Param.ABS_AMP,
new Param(1.0 / peakGain.val, peakGain.unit),
null))
.val;
normalizeAudioFile(floatF, outF, inBuf, gain, 1.0f);
maxAmp *= gain;
for (ch = 0; ch < inChanNum; ch++) {
floatF[ch].cleanUp();
floatF[ch] = null;
tempFile[ch].delete();
tempFile[ch] = null;
}
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Finish ----
outF.close();
outF = null;
outStream = null;
inF.close();
inF = null;
inStream = null;
inBuf = null;
// inform about clipping/ low level
handleClipping(maxAmp);
} catch (IOException e1) {
setError(e1);
} catch (OutOfMemoryError e2) {
inStream = null;
outStream = null;
inBuf = null;
convBuf1 = null;
convBuf2 = null;
System.gc();
setError(new Exception(ERR_MEMORY));
;
}
// ---- cleanup (topLevel) ----
if (inF != null) {
inF.cleanUp();
inF = null;
}
if (outF != null) {
outF.cleanUp();
outF = null;
}
if (floatF != null) {
for (ch = 0; ch < floatF.length; ch++) {
if (floatF[ch] != null) {
floatF[ch].cleanUp();
floatF[ch] = null;
}
if (tempFile[ch] != null) {
tempFile[ch].delete();
tempFile[ch] = null;
}
}
}
} // process()
/**
* Transformiert einen Parameter von einer Groesse/Masseinheit (eindimensional) in eine andere
* (eindimensional)
*
* <p>- bei gleichen Einheiten (ohne Umrechnung) wird das Original zurueckgeliefert! - ein
* ParamSpace.fitValue() wird nicht durchgefuehrt!
*
* @param reference optionaler Referrer, der ggf. fuer Umrechnungen von/in relative Werte
* benoetigt wird; kann null sein; WENN ER BENOETIGT WIRD, MUSS ER ENTWEDER IN DER FORM
* ABS_UNIT VORLIEGEN ODER (OHNE REFERENZ) IN DIESE UMWANDELBAR SEIN!
* <p>reference wird synchronisiert!
* @param stream optionaler Stream-Referrer, der ggf. fuer Umrechnungen von/in Beats oder
* Semitones benoetigt wird; darf null sein (ggf. wird dann auf die globale
* Geschwindigkeit/Scala zurueckgegriffen)
* @return null, wenn wg. fehlendem Referrer die Transformation nicht durchgefuehrt werden kann
* oder bei Inkompatiblitaet (Zeit kann nicht in Frequenzen umgerechnet werden etc.)
*/
public static Param transform(Param src, int destUnit, Param reference, SpectStream stream) {
if (src.unit == destUnit) return src;
double destVal = src.value;
int srcChain, destChain;
// -------- take out special forms --------
switch (src.unit & SPECIAL_MASK) {
case BEATS:
destVal *= 60000.0 / timeScale;
break;
case SEMITONES:
if (reference == null) return null;
destVal = reference.value * (Math.pow(2, destVal / freqScale) - 1);
break;
case DECIBEL:
destVal = Math.exp(destVal / 20 * Constants.ln10) * 100;
break;
default:
break;
}
// chain: Abs% <==> AbsUnit <==> RelUnit <==> Rel%
srcChain = chain[(src.unit & FORM_MASK) >> 4];
destChain = chain[(destUnit & FORM_MASK) >> 4];
if (srcChain != destChain) {
if (reference == null) return null; // we need reference here
// i.e. in the form of an absolute unit:
reference =
Param.transform(
reference, (reference.unit & ~(FORM_MASK | SPECIAL_MASK)) | ABS_UNIT, null, stream);
if (reference == null) return null; // transformation did not work out
try {
synchronized (reference) {
if (srcChain < destChain) { // -------- chain from left to right --------
for (int i = srcChain; i < destChain; i++) {
switch (i) {
case 0:
destVal *= reference.value / 100; // Abs% ==> AbsUnit
break;
case 1:
destVal -= reference.value; // AbsUnit ==> RelUnit
break;
case 2:
destVal *= 100 / reference.value; // RelUnit ==> Rel%
break;
default:
break;
}
}
} else { // -------- chain from right to left --------
for (int i = srcChain; i > destChain; i--) {
switch (i) {
case 3:
destVal *= reference.value / 100; // Rel% ==> RelUnit
break;
case 2:
destVal += reference.value; // RelUnit ==> AbsUnit
break;
case 1:
destVal *= 100 / reference.value; // AbsUnit ==> Abs%
break;
default:
break;
}
}
}
}
} catch (ArithmeticException e) { // division by zero
return null;
}
}
// -------- include special forms --------
switch (destUnit & SPECIAL_MASK) {
case BEATS:
destVal *= timeScale / 60000;
break;
case SEMITONES:
if (reference == null) return null;
destVal = Math.log(1 + destVal / reference.value) / Constants.ln2 * freqScale;
break;
case DECIBEL:
if (destVal > Constants.minPercent) {
destVal = Math.log(destVal / 100) * 20 / Constants.ln10;
} else { // value too small; minus infinite dB assumed to be -144 dB
destVal = Constants.minDecibel;
}
break;
default:
break;
}
return new Param(destVal, destUnit);
}
protected void process() {
int i, j, ch, len, off, chunkLength;
long progOff, progLen;
float f1, f2;
double d1;
boolean extraAudioFile;
// io
AudioFile inF = null;
AudioFile outF = null;
AudioFile envInF = null;
AudioFile envOutF = null;
AudioFileDescr inStream = null;
AudioFileDescr outStream = null;
AudioFileDescr envInStream = null;
AudioFileDescr envOutStream = null;
FloatFile[] outFloatF = null;
FloatFile[] envFloatF = null;
File outTempFile[] = null;
File envTempFile[] = null;
int inChanNum, outChanNum, envInChanNum, envOutChanNum, shapeChanNum;
int[][] shapeChan = null;
int[][] inChan = null;
float[][] shapeChanWeight = null;
float[][] inChanWeight = null;
// buffers
float[][] inBuf = null; // Sound-In
float[][] outBuf = null; // Sound-Out
float[][] inEnvBuf = null; // Envelope of Input
float[][] shapeEnvBuf = null; // Envelope of Shaper
float[][] envInBuf = null; // Direct-In of Shaper-File
float[] convBuf1, convBuf2;
int inLength, outLength, envInLength, envOutLength;
int framesRead, framesWritten; // re sound-files
int framesRead2, framesWritten2; // re env-files
Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
Param peakGain;
float gain = 1.0f; // gain abs amp
float envGain = 1.0f; // gain abs amp
float maxAmp = 0.0f;
float envMaxAmp = 0.0f;
float maxChange;
int average, avrOff;
double[] inEnergy, envInEnergy;
PathField ggOutput;
topLevel:
try {
// ---- open input, output; init ----
// input
inF = AudioFile.openAsRead(new File(pr.text[PR_INPUTFILE]));
inStream = inF.getDescr();
inChanNum = inStream.channels;
inLength = (int) inStream.length;
// this helps to prevent errors from empty files!
if ((inLength < 1) || (inChanNum < 1)) throw new EOFException(ERR_EMPTY);
// .... check running ....
if (!threadRunning) break topLevel;
envInLength = 0;
envInChanNum = inChanNum;
shapeChanNum = 0;
// shape input
switch (pr.intg[PR_ENVSOURCE]) {
case SRC_SOUNDFILE:
case SRC_ENVFILE:
envInF = AudioFile.openAsRead(new File(pr.text[PR_ENVINFILE]));
envInStream = envInF.getDescr();
envInChanNum = envInStream.channels;
shapeChanNum = envInChanNum;
envInLength = (int) envInStream.length;
// this helps to prevent errors from empty files!
if ((envInLength < 1) || (envInChanNum < 1)) throw new EOFException(ERR_EMPTY);
i = Math.min(inLength, envInLength);
inLength = i;
envInLength = i;
break;
case SRC_ENV:
if (pr.bool[PR_RIGHTCHAN]) {
shapeChanNum = 2;
envInChanNum = Math.max(envInChanNum, shapeChanNum); // ggf. mono => stereo
} else {
shapeChanNum = 1;
}
break;
case SRC_INPUT:
shapeChanNum = inChanNum;
break;
}
// .... check running ....
if (!threadRunning) break topLevel;
outChanNum = Math.max(inChanNum, envInChanNum);
outLength = inLength;
shapeChan = new int[outChanNum][2];
shapeChanWeight = new float[outChanNum][2];
inChan = new int[outChanNum][2];
inChanWeight = new float[outChanNum][2];
extraAudioFile =
(envInF != null) && (pr.intg[PR_ENVSOURCE] == SRC_SOUNDFILE); // not if SRC_ENVFILE!!!
// calc weights
for (ch = 0; ch < outChanNum; ch++) {
if (shapeChanNum == 1) {
shapeChan[ch][0] = 0;
shapeChan[ch][1] = 0;
shapeChanWeight[ch][0] = 1.0f;
shapeChanWeight[ch][1] = 0.0f;
} else {
f1 = ((float) ch / (float) (outChanNum - 1)) * (float) (shapeChanNum - 1);
shapeChan[ch][0] = (int) f1; // Math.max verhindert ArrayIndex-Fehler
shapeChan[ch][1] = Math.min((int) f1 + 1, shapeChanNum - 1); // (Weight ist dabei eh Null)
f1 %= 1.0f;
shapeChanWeight[ch][0] = 1.0f - f1;
shapeChanWeight[ch][1] = f1;
}
if (inChanNum == 1) {
inChan[ch][0] = 0;
inChan[ch][1] = 0;
inChanWeight[ch][0] = 1.0f;
inChanWeight[ch][1] = 0.0f;
} else {
f1 = ((float) ch / (float) (outChanNum - 1)) * (float) (inChanNum - 1);
inChan[ch][0] = (int) f1;
inChan[ch][1] = Math.min((int) f1 + 1, inChanNum - 1);
f1 %= 1.0f;
inChanWeight[ch][0] = 1.0f - f1;
inChanWeight[ch][1] = f1;
}
/*
for( i = 0; i < 2; i++ ) {
System.out.println( "shapeChan["+ch+"]["+i+"] = "+shapeChan[ch][i] );
System.out.println( "shapeWeig["+ch+"]["+i+"] = "+shapeChanWeight[ch][i] );
System.out.println( "inputChan["+ch+"]["+i+"] = "+inChan[ch][i] );
System.out.println( "inputWeig["+ch+"]["+i+"] = "+inChanWeight[ch][i] );
}
*/
}
// output
ggOutput = (PathField) gui.getItemObj(GG_OUTPUTFILE);
if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
outStream = new AudioFileDescr(inStream);
ggOutput.fillStream(outStream);
outStream.channels = outChanNum;
outF = AudioFile.openAsWrite(outStream);
// .... check running ....
if (!threadRunning) break topLevel;
envOutLength = 0;
envOutChanNum = 0;
// envelope output
if (pr.bool[PR_ENVOUTPUT]) {
ggOutput = (PathField) gui.getItemObj(GG_ENVOUTFILE);
if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
envOutStream = new AudioFileDescr(inStream);
ggOutput.fillStream(envOutStream);
envOutStream.file = new File(pr.text[PR_ENVOUTFILE]);
envOutF = AudioFile.openAsWrite(envOutStream);
envOutLength = inLength;
envOutChanNum = inChanNum;
}
// .... check running ....
if (!threadRunning) break topLevel;
// average buffer size
d1 =
Param.transform(
pr.para[PR_AVERAGE],
Param.ABS_MS,
new Param(AudioFileDescr.samplesToMillis(inStream, inLength), Param.ABS_MS),
null)
.val; // average in millis
average = ((int) (AudioFileDescr.millisToSamples(inStream, d1) + 0.5) & ~1) + 1; // always odd
avrOff = (average >> 1) + 1; // first element needed for subtraction (see calcEnv())
progOff = 0;
progLen =
(long) Math.max(average - avrOff, inLength)
+ (long) (extraAudioFile ? Math.max(average - avrOff, envInLength) : envInLength)
+ (long) outLength
+ (long) envOutLength;
// normalization requires temp files
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
outTempFile = new File[outChanNum];
outFloatF = new FloatFile[outChanNum];
for (ch = 0;
ch < outChanNum;
ch++) { // first zero them because an exception might be thrown
outTempFile[ch] = null;
outFloatF[ch] = null;
}
for (ch = 0; ch < outChanNum; ch++) {
outTempFile[ch] = IOUtil.createTempFile();
outFloatF[ch] = new FloatFile(outTempFile[ch], GenericFile.MODE_OUTPUT);
}
progLen += (long) outLength;
} else {
gain = (float) (Param.transform(pr.para[PR_GAIN], Param.ABS_AMP, ampRef, null)).val;
}
// .... check running ....
if (!threadRunning) break topLevel;
// normalization requires temp files
if (pr.intg[PR_ENVGAINTYPE] == GAIN_UNITY) {
envTempFile = new File[envOutChanNum];
envFloatF = new FloatFile[envOutChanNum];
for (ch = 0;
ch < envOutChanNum;
ch++) { // first zero them because an exception might be thrown
envTempFile[ch] = null;
envFloatF[ch] = null;
}
for (ch = 0; ch < envOutChanNum; ch++) {
envTempFile[ch] = IOUtil.createTempFile();
envFloatF[ch] = new FloatFile(envTempFile[ch], GenericFile.MODE_OUTPUT);
}
progLen += (long) envOutLength;
} else {
envGain = (float) (Param.transform(pr.para[PR_ENVGAIN], Param.ABS_AMP, ampRef, null)).val;
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- further inits ----
maxChange = (float) (Param.transform(pr.para[PR_MAXCHANGE], Param.ABS_AMP, ampRef, null)).val;
inBuf = new float[inChanNum][8192 + average];
Util.clear(inBuf);
outBuf = new float[outChanNum][8192];
Util.clear(outBuf);
if (extraAudioFile) {
envInBuf = new float[envInChanNum][8192 + average];
Util.clear(envInBuf);
}
inEnvBuf = new float[inChanNum][8192]; // = envOutBuf
Util.clear(inEnvBuf);
shapeEnvBuf = new float[envInChanNum][8192];
Util.clear(shapeEnvBuf);
inEnergy = new double[inChanNum];
for (ch = 0; ch < inChanNum; ch++) {
inEnergy[ch] = 0.0;
}
envInEnergy = new double[envInChanNum];
for (ch = 0; ch < envInChanNum; ch++) {
envInEnergy[ch] = 0.0;
}
// System.out.println( "inLength "+inLength+"; envInLength "+envInLength+"; envOutLength
// "+envOutLength+"; outLength "+outLength );
// System.out.println( "average "+average+"; avrOff "+avrOff );
// ----==================== buffer init ====================----
framesRead = 0; // re inF
framesRead2 = 0; // re envInF
// ---- init buffers ----
for (off = avrOff; threadRunning && (off < average); ) {
len = Math.min(inLength - framesRead, Math.min(8192, average - off));
if (len == 0) break;
inF.readFrames(inBuf, off, len);
// calc initial energy per channel (see calcEnv())
for (ch = 0; ch < inChanNum; ch++) {
convBuf1 = inBuf[ch];
d1 = 0.0;
for (i = 0, j = off; i < len; i++) {
f1 = convBuf1[j++];
d1 += f1 * f1;
}
inEnergy[ch] += d1;
}
framesRead += len;
off += len;
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
}
// zero padding bereits durch initialisierung mit Util.clear() passiert!
if (extraAudioFile) {
for (off = avrOff; threadRunning && (off < average); ) {
len = Math.min(envInLength - framesRead2, Math.min(8192, average - off));
if (len == 0) break;
envInF.readFrames(envInBuf, off, len);
// calc initial energy per channel (see calcEnv())
for (ch = 0; ch < envInChanNum; ch++) {
convBuf1 = envInBuf[ch];
d1 = 0.0;
for (i = 0, j = off; i < len; i++) {
f1 = convBuf1[j++];
d1 += f1 * f1;
}
envInEnergy[ch] += d1;
}
framesRead2 += len;
off += len;
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
}
// zero padding bereits durch initialisierung mit Util.clear() passiert!
}
// .... check running ....
if (!threadRunning) break topLevel;
// ----==================== the real stuff ====================----
framesWritten = 0; // re OutF
framesWritten2 = 0; // re envOutF
while (threadRunning && (framesWritten < outLength)) {
chunkLength = Math.min(8192, outLength - framesWritten);
// ---- read input chunk ----
len = Math.min(inLength - framesRead, chunkLength);
inF.readFrames(inBuf, average, len);
// zero padding
for (ch = 0; ch < inChanNum; ch++) {
convBuf1 = inBuf[ch];
for (i = len, j = len + average; i < chunkLength; i++) {
convBuf1[j++] = 0.0f;
}
}
framesRead += len;
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- read input env chunk ----
if (envInF != null) {
len = Math.min(envInLength - framesRead2, chunkLength);
if (extraAudioFile) { // ........ needs averaging ........
envInF.readFrames(envInBuf, average, len);
// zero padding
for (ch = 0; ch < envInChanNum; ch++) {
convBuf1 = envInBuf[ch];
for (i = len, j = len + average; i < chunkLength; i++) {
convBuf1[j++] = 0.0f;
}
}
} else { // ........ is already env ........
envInF.readFrames(shapeEnvBuf, 0, len);
// zero padding
for (ch = 0; ch < envInChanNum; ch++) {
convBuf1 = shapeEnvBuf[ch];
for (i = len; i < chunkLength; i++) {
convBuf1[i] = 0.0f;
}
}
}
framesRead2 += len;
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- calc input envelope ----
for (ch = 0; ch < inChanNum; ch++) {
inEnergy[ch] = calcEnv(inBuf[ch], inEnvBuf[ch], average, chunkLength, inEnergy[ch]);
}
// ---- write output env file ----
if (pr.bool[PR_ENVOUTPUT]) {
if (envFloatF != null) { // i.e. unity gain
for (ch = 0; ch < envOutChanNum; ch++) {
convBuf1 = inEnvBuf[ch];
for (i = 0; i < chunkLength; i++) { // measure max amp
f1 = Math.abs(convBuf1[i]);
if (f1 > envMaxAmp) {
envMaxAmp = f1;
}
}
envFloatF[ch].writeFloats(convBuf1, 0, chunkLength);
}
} else { // i.e. abs gain
for (ch = 0; ch < envOutChanNum; ch++) {
convBuf1 = inEnvBuf[ch];
for (i = 0; i < chunkLength; i++) { // measure max amp + adjust gain
f1 = Math.abs(convBuf1[i]);
convBuf1[i] *= envGain;
if (f1 > envMaxAmp) {
envMaxAmp = f1;
}
}
}
envOutF.writeFrames(inEnvBuf, 0, chunkLength);
}
framesWritten2 += chunkLength;
progOff += chunkLength;
// .... progress ....
setProgression((float) progOff / (float) progLen);
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- calc shape envelope ----
switch (pr.intg[PR_ENVSOURCE]) {
case SRC_INPUT: // shape env = input env
for (ch = 0; ch < inChanNum; ch++) {
System.arraycopy(inEnvBuf[ch], 0, shapeEnvBuf[ch], 0, chunkLength);
}
break;
case SRC_SOUNDFILE: // calc shape env from envInBuf
for (ch = 0; ch < envInChanNum; ch++) {
envInEnergy[ch] =
calcEnv(envInBuf[ch], shapeEnvBuf[ch], average, chunkLength, envInEnergy[ch]);
}
break;
case SRC_ENVFILE: // nothing to do, we have already loaded the env
break; // in the correct buffer
case SRC_ENV:
throw new IOException("Graphic env not yet supported");
}
// ---- calc output ----
// first generate output envelope
switch (pr.intg[PR_MODE]) {
case MODE_SUPERPOSE:
if (!pr.bool[PR_INVERT]) { // multiply by shape
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) {
f1 =
shapeEnvBuf[shapeChan[ch][0]][i] * shapeChanWeight[ch][0]
+ shapeEnvBuf[shapeChan[ch][1]][i] * shapeChanWeight[ch][1];
convBuf1[i] = Math.min(maxChange, f1);
}
}
} else { // divide by shape
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) {
f1 =
shapeEnvBuf[shapeChan[ch][0]][i] * shapeChanWeight[ch][0]
+ shapeEnvBuf[shapeChan[ch][1]][i] * shapeChanWeight[ch][1];
if (f1 > 0.0f) {
convBuf1[i] = Math.min(maxChange, 1.0f / f1);
} else {
convBuf1[i] = maxChange;
}
}
}
}
break;
case MODE_REPLACE:
if (!pr.bool[PR_INVERT]) { // shape / input
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) {
f1 =
shapeEnvBuf[shapeChan[ch][0]][i] * shapeChanWeight[ch][0]
+ shapeEnvBuf[shapeChan[ch][1]][i] * shapeChanWeight[ch][1];
f2 =
inEnvBuf[inChan[ch][0]][i] * inChanWeight[ch][0]
+ inEnvBuf[inChan[ch][1]][i] * inChanWeight[ch][1];
if (f2 > 0.0f) {
convBuf1[i] = Math.min(maxChange, f1 / f2);
} else {
convBuf1[i] = 0.0f; // input ist eh ueberall null, somit unveraenderlich
}
}
}
} else { // 1 / (shape * input)
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) {
f1 =
shapeEnvBuf[shapeChan[ch][0]][i] * shapeChanWeight[ch][0]
+ shapeEnvBuf[shapeChan[ch][1]][i] * shapeChanWeight[ch][1];
f1 *=
inEnvBuf[inChan[ch][0]][i] * inChanWeight[ch][0]
+ inEnvBuf[inChan[ch][1]][i] * inChanWeight[ch][1];
if (f1 > 0.0f) {
convBuf1[i] = Math.min(maxChange, 1.0f / f1);
} else {
convBuf1[i] = maxChange;
}
}
}
}
break;
}
// then multiply input bites
if (inChanNum == outChanNum) { // no weighting - use faster routine
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
convBuf2 = inBuf[ch];
for (i = 0, j = avrOff; i < chunkLength; i++, j++) {
convBuf1[i] *= convBuf2[j];
}
}
} else {
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0, j = avrOff; i < chunkLength; i++, j++) {
f1 =
inBuf[inChan[ch][0]][j] * inChanWeight[ch][0]
+ inBuf[inChan[ch][1]][j] * inChanWeight[ch][1];
convBuf1[i] *= f1;
}
}
}
// ---- write output sound file ----
if (outFloatF != null) { // i.e. unity gain
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) { // measure max amp
f1 = Math.abs(convBuf1[i]);
if (f1 > maxAmp) {
maxAmp = f1;
}
}
outFloatF[ch].writeFloats(convBuf1, 0, chunkLength);
}
} else { // i.e. abs gain
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = outBuf[ch];
for (i = 0; i < chunkLength; i++) { // measure max amp + adjust gain
f1 = Math.abs(convBuf1[i]);
convBuf1[i] *= gain;
if (f1 > maxAmp) {
maxAmp = f1;
}
}
}
outF.writeFrames(outBuf, 0, chunkLength);
}
framesWritten += chunkLength;
progOff += chunkLength;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// ---- shift buffers ----
for (ch = 0;
ch < inChanNum;
ch++) { // zero padding is performed after AudioFile.readFrames()!
System.arraycopy(inBuf[ch], chunkLength, inBuf[ch], 0, average);
}
if (extraAudioFile) {
for (ch = 0;
ch < envInChanNum;
ch++) { // zero padding is performed after AudioFile.readFrames()!
System.arraycopy(envInBuf[ch], chunkLength, envInBuf[ch], 0, average);
}
}
} // until framesWritten == outLength
// .... check running ....
if (!threadRunning) break topLevel;
// ---- normalize output ----
// sound file
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
peakGain = new Param((double) maxAmp, Param.ABS_AMP);
gain =
(float)
(Param.transform(
pr.para[PR_GAIN],
Param.ABS_AMP,
new Param(1.0 / peakGain.val, peakGain.unit),
null))
.val;
f1 = 1.0f;
if ((envOutF != null) && (pr.intg[PR_ENVGAINTYPE] == GAIN_UNITY)) { // leave prog space
f1 = (1.0f + getProgression()) / 2;
}
normalizeAudioFile(outFloatF, outF, outBuf, gain, f1);
for (ch = 0; ch < outChanNum; ch++) {
outFloatF[ch].cleanUp();
outFloatF[ch] = null;
outTempFile[ch].delete();
outTempFile[ch] = null;
}
}
// .... check running ....
if (!threadRunning) break topLevel;
// envelope file
if ((envOutF != null) && (pr.intg[PR_ENVGAINTYPE] == GAIN_UNITY)) {
peakGain = new Param((double) envMaxAmp, Param.ABS_AMP);
envGain =
(float)
(Param.transform(
pr.para[PR_ENVGAIN],
Param.ABS_AMP,
new Param(1.0 / peakGain.val, peakGain.unit),
null))
.val;
normalizeAudioFile(envFloatF, envOutF, inEnvBuf, envGain, 1.0f);
for (ch = 0; ch < envOutChanNum; ch++) {
envFloatF[ch].cleanUp();
envFloatF[ch] = null;
envTempFile[ch].delete();
envTempFile[ch] = null;
}
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Finish ----
outF.close();
outF = null;
outStream = null;
if (envOutF != null) {
envOutF.close();
envOutF = null;
envOutStream = null;
}
if (envInF != null) {
envInF.close();
envInF = null;
envInStream = null;
}
inF.close();
inF = null;
inStream = null;
outBuf = null;
inBuf = null;
inEnvBuf = null;
envInBuf = null;
shapeEnvBuf = null;
// inform about clipping/ low level
maxAmp *= gain;
handleClipping(maxAmp);
envMaxAmp *= envGain;
// handleClipping( envMaxAmp ); // ;( routine nicht flexibel genug!
} catch (IOException e1) {
setError(e1);
} catch (OutOfMemoryError e2) {
inStream = null;
outStream = null;
envInStream = null;
envOutStream = null;
inBuf = null;
outBuf = null;
inEnvBuf = null;
envInBuf = null;
shapeEnvBuf = null;
convBuf1 = null;
convBuf2 = null;
System.gc();
setError(new Exception(ERR_MEMORY));
;
}
// ---- cleanup (topLevel) ----
if (inF != null) {
inF.cleanUp();
inF = null;
}
if (outF != null) {
outF.cleanUp();
outF = null;
}
if (envInF != null) {
envInF.cleanUp();
envInF = null;
}
if (envOutF != null) {
envOutF.cleanUp();
envOutF = null;
}
if (outFloatF != null) {
for (ch = 0; ch < outFloatF.length; ch++) {
if (outFloatF[ch] != null) outFloatF[ch].cleanUp();
if (outTempFile[ch] != null) outTempFile[ch].delete();
}
}
if (envFloatF != null) {
for (ch = 0; ch < envFloatF.length; ch++) {
if (envFloatF[ch] != null) envFloatF[ch].cleanUp();
if (envTempFile[ch] != null) envTempFile[ch].delete();
}
}
} // process()
/** Translation durchfuehren */
public void process() {
int i, j, k;
int ch, len;
float f1;
double d1, d2, d3, d4, d5;
long progOff, progLen, lo;
// io
AudioFile reInF = null;
AudioFile imInF = null;
AudioFile reOutF = null;
AudioFile imOutF = null;
AudioFileDescr reInStream = null;
AudioFileDescr imInStream = null;
AudioFileDescr reOutStream = null;
AudioFileDescr imOutStream = null;
FloatFile reFloatF[] = null;
FloatFile imFloatF[] = null;
File reTempFile[] = null;
File imTempFile[] = null;
int outChanNum;
float[][] reInBuf; // [ch][i]
float[][] imInBuf; // [ch][i]
float[][] reOutBuf = null; // [ch][i]
float[][] imOutBuf = null; // [ch][i]
float[] convBuf1, convBuf2;
boolean complex;
PathField ggOutput;
// Synthesize
Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
float gain; // gain abs amp
float dryGain, wetGain;
float inGain;
float maxAmp = 0.0f;
Param peakGain;
int inLength, inOff;
int pre;
int post;
int length;
int framesRead, framesWritten, outLength;
boolean polarIn, polarOut;
// phase unwrapping
double[] phi;
int[] wrap;
double[] carry;
Param lenRef;
topLevel:
try {
complex = pr.bool[PR_HASIMINPUT] || pr.bool[PR_HASIMOUTPUT];
polarIn = pr.intg[PR_OPERATOR] == OP_POLAR2RECT;
polarOut = pr.intg[PR_OPERATOR] == OP_RECT2POLAR;
if ((polarIn || polarOut) && !complex) throw new IOException(ERR_NOTCOMPLEX);
// ---- open input ----
reInF = AudioFile.openAsRead(new File(pr.text[PR_REINPUTFILE]));
reInStream = reInF.getDescr();
inLength = (int) reInStream.length;
reInBuf = new float[reInStream.channels][8192];
imInBuf = new float[reInStream.channels][8192];
if (pr.bool[PR_HASIMINPUT]) {
imInF = AudioFile.openAsRead(new File(pr.text[PR_IMINPUTFILE]));
imInStream = imInF.getDescr();
if (imInStream.channels != reInStream.channels) throw new IOException(ERR_COMPLEX);
inLength = (int) Math.min(inLength, imInStream.length);
}
lenRef = new Param(AudioFileDescr.samplesToMillis(reInStream, inLength), Param.ABS_MS);
d1 =
AudioFileDescr.millisToSamples(
reInStream, (Param.transform(pr.para[PR_OFFSET], Param.ABS_MS, lenRef, null).value));
j = (int) (d1 >= 0.0 ? (d1 + 0.5) : (d1 - 0.5)); // correct rounding for negative values!
length =
(int)
(AudioFileDescr.millisToSamples(
reInStream,
(Param.transform(pr.para[PR_LENGTH], Param.ABS_MS, lenRef, null)).value)
+ 0.5);
// System.err.println( "offset = "+j );
if (j >= 0) {
inOff = Math.min(j, inLength);
if (!pr.bool[PR_REVERSE]) {
reInF.seekFrame(inOff);
if (pr.bool[PR_HASIMINPUT]) {
imInF.seekFrame(inOff);
}
}
inLength -= inOff;
pre = 0;
} else {
inOff = 0;
pre = Math.min(-j, length);
}
inLength = Math.min(inLength, length - pre);
post = length - pre - inLength;
if (pr.bool[PR_REVERSE]) {
i = pre;
pre = post;
post = i;
inOff += inLength;
}
// .... check running ....
if (!threadRunning) break topLevel;
// for( op = 0; op < 2; op++ ) {
// System.out.println( op +": pre "+pre[op]+" / len "+inLength[op]+" / post "+post[op] );
// }
// System.out.println( "tot "+length[0]);
outLength = length;
outChanNum = reInStream.channels;
// ---- open output ----
ggOutput = (PathField) gui.getItemObj(GG_REOUTPUTFILE);
if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
reOutStream = new AudioFileDescr(reInStream);
ggOutput.fillStream(reOutStream);
reOutStream.channels = outChanNum;
// well, more sophisticated code would
// move and truncate the markers...
if ((pre == 0) /* && (post == 0) */) {
reInF.readMarkers();
reOutStream.setProperty(
AudioFileDescr.KEY_MARKERS, reInStream.getProperty(AudioFileDescr.KEY_MARKERS));
}
reOutF = AudioFile.openAsWrite(reOutStream);
reOutBuf = new float[outChanNum][8192];
imOutBuf = new float[outChanNum][8192];
if (pr.bool[PR_HASIMOUTPUT]) {
imOutStream = new AudioFileDescr(reInStream);
ggOutput.fillStream(imOutStream);
imOutStream.channels = outChanNum;
imOutStream.file = new File(pr.text[PR_IMOUTPUTFILE]);
imOutF = AudioFile.openAsWrite(imOutStream);
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Further inits ----
phi = new double[outChanNum];
wrap = new int[outChanNum];
carry = new double[outChanNum];
for (ch = 0; ch < outChanNum; ch++) {
phi[ch] = 0.0;
wrap[ch] = 0;
carry[ch] = Double.NEGATIVE_INFINITY;
}
progOff = 0; // read, transform, write
progLen = (long) outLength * 3;
wetGain = (float) (Param.transform(pr.para[PR_WETMIX], Param.ABS_AMP, ampRef, null)).value;
dryGain = (float) (Param.transform(pr.para[PR_DRYMIX], Param.ABS_AMP, ampRef, null)).value;
if (pr.bool[PR_DRYINVERT]) {
dryGain = -dryGain;
}
inGain = (float) (Param.transform(pr.para[PR_INPUTGAIN], Param.ABS_AMP, ampRef, null)).value;
if (pr.bool[PR_INVERT]) {
inGain = -inGain;
}
// normalization requires temp files
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
reTempFile = new File[outChanNum];
reFloatF = new FloatFile[outChanNum];
for (ch = 0;
ch < outChanNum;
ch++) { // first zero them because an exception might be thrown
reTempFile[ch] = null;
reFloatF[ch] = null;
}
for (ch = 0; ch < outChanNum; ch++) {
reTempFile[ch] = IOUtil.createTempFile();
reFloatF[ch] = new FloatFile(reTempFile[ch], GenericFile.MODE_OUTPUT);
}
if (pr.bool[PR_HASIMOUTPUT]) {
imTempFile = new File[outChanNum];
imFloatF = new FloatFile[outChanNum];
for (ch = 0;
ch < outChanNum;
ch++) { // first zero them because an exception might be thrown
imTempFile[ch] = null;
imFloatF[ch] = null;
}
for (ch = 0; ch < outChanNum; ch++) {
imTempFile[ch] = IOUtil.createTempFile();
imFloatF[ch] = new FloatFile(imTempFile[ch], GenericFile.MODE_OUTPUT);
}
}
progLen += outLength;
} else {
gain = (float) (Param.transform(pr.para[PR_GAIN], Param.ABS_AMP, ampRef, null)).value;
wetGain *= gain;
dryGain *= gain;
}
// .... check running ....
if (!threadRunning) break topLevel;
// ----==================== the real stuff ====================----
framesRead = 0;
framesWritten = 0;
while (threadRunning && (framesWritten < outLength)) {
// ---- choose chunk len ----
len = Math.min(8192, outLength - framesWritten);
if (pre > 0) {
len = Math.min(len, pre);
} else if (inLength > 0) {
len = Math.min(len, inLength);
} else {
len = Math.min(len, post);
}
// ---- read input chunks ----
if (pre > 0) {
Util.clear(reInBuf);
if (complex) {
Util.clear(imInBuf);
}
pre -= len;
} else if (inLength > 0) {
if (pr.bool[PR_REVERSE]) { // ---- read reversed ----
reInF.seekFrame(inOff - framesRead - len);
reInF.readFrames(reInBuf, 0, len);
for (ch = 0; ch < reInStream.channels; ch++) {
convBuf1 = reInBuf[ch];
for (i = 0, j = len - 1; i < j; i++, j--) {
f1 = convBuf1[j];
convBuf1[j] = convBuf1[i];
convBuf1[i] = f1;
}
}
if (pr.bool[PR_HASIMINPUT]) {
imInF.seekFrame(inOff - framesRead - len);
imInF.readFrames(imInBuf, 0, len);
for (ch = 0; ch < imInStream.channels; ch++) {
convBuf1 = imInBuf[ch];
for (i = 0, j = len - 1; i < j; i++, j--) {
f1 = convBuf1[j];
convBuf1[j] = convBuf1[i];
convBuf1[i] = f1;
}
}
} else if (complex) {
Util.clear(imInBuf);
}
} else { // ---- read normal ----
reInF.readFrames(reInBuf, 0, len);
if (pr.bool[PR_HASIMINPUT]) {
imInF.readFrames(imInBuf, 0, len);
} else if (complex) {
Util.clear(imInBuf);
}
}
inLength -= len;
framesRead += len;
} else {
Util.clear(reInBuf);
if (complex) {
Util.clear(imInBuf);
}
post -= len;
}
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- save dry signal ----
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = reInBuf[ch];
convBuf2 = reOutBuf[ch];
for (i = 0; i < len; i++) {
convBuf2[i] = convBuf1[i] * dryGain;
}
if (complex) {
convBuf1 = imInBuf[ch];
convBuf2 = imOutBuf[ch];
for (i = 0; i < len; i++) {
convBuf2[i] = convBuf1[i] * dryGain;
}
}
}
// ---- rectify + apply input gain ----
for (ch = 0; ch < reInStream.channels; ch++) {
convBuf1 = reInBuf[ch];
convBuf2 = imInBuf[ch];
// ---- rectify ----
if (pr.bool[PR_RECTIFY]) {
if (complex) {
if (polarIn) {
for (i = 0; i < len; i++) {
convBuf2[i] = 0.0f;
}
} else {
for (i = 0; i < len; i++) {
d1 = convBuf1[i];
d2 = convBuf2[i];
convBuf1[i] = (float) Math.sqrt(d1 * d1 + d2 * d2);
convBuf2[i] = 0.0f;
}
}
} else {
for (i = 0; i < len; i++) {
convBuf1[i] = Math.abs(convBuf1[i]);
}
}
}
// ---- apply input gain ----
Util.mult(convBuf1, 0, len, inGain);
if (complex & !polarIn) {
Util.mult(convBuf2, 0, len, inGain);
}
}
// ---- heart of the dragon ----
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = reInBuf[ch];
convBuf2 = imInBuf[ch];
switch (pr.intg[PR_OPERATOR]) {
case OP_NONE: // ================ None ================
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * convBuf1[i];
}
if (complex) {
for (i = 0; i < len; i++) {
imOutBuf[ch][i] += wetGain * convBuf2[i];
}
}
break;
case OP_SIN: // ================ Cosinus ================
if (complex) {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf1[i] * Math.PI);
imOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf2[i] * Math.PI);
}
} else {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf1[i] * Math.PI);
}
}
break;
case OP_SQR: // ================ Square ================
if (complex) {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] +=
wetGain * (convBuf1[i] * convBuf1[i] - convBuf2[i] * convBuf2[i]);
imOutBuf[ch][i] -= wetGain * (convBuf1[i] * convBuf2[i] * 2);
}
} else {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (convBuf1[i] * convBuf1[i]);
}
}
break;
case OP_SQRT: // ================ Square root ================
if (complex) {
d3 = phi[ch];
k = wrap[ch];
d4 = k * Constants.PI2;
for (i = 0; i < len; i++) {
d1 =
wetGain
* Math.pow(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i], 0.25);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
if (d2 - d3 > Math.PI) {
k--;
d4 = k * Constants.PI2;
} else if (d3 - d2 > Math.PI) {
k++;
d4 = k * Constants.PI2;
}
d2 += d4;
d3 = d2;
d2 /= 2;
reOutBuf[ch][i] += (float) (d1 * Math.cos(d2));
imOutBuf[ch][i] += (float) (d1 * Math.sin(d2));
}
phi[ch] = d3;
wrap[ch] = k;
} else {
for (i = 0; i < len; i++) {
f1 = convBuf1[i];
if (f1 > 0) {
reOutBuf[ch][i] += wetGain * (float) Math.sqrt(f1);
} // else undefiniert
}
}
break;
case OP_RECT2POLARW: // ================ Rect->Polar (wrapped) ================
for (i = 0; i < len; i++) {
d1 = wetGain * Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
reOutBuf[ch][i] += (float) d1;
imOutBuf[ch][i] += (float) d2;
}
break;
case OP_RECT2POLAR: // ================ Rect->Polar ================
d3 = phi[ch];
k = wrap[ch];
d4 = k * Constants.PI2;
for (i = 0; i < len; i++) {
d1 = wetGain * Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
if (d2 - d3 > Math.PI) {
k--;
d4 = k * Constants.PI2;
} else if (d3 - d2 > Math.PI) {
k++;
d4 = k * Constants.PI2;
}
d2 += d4;
reOutBuf[ch][i] += (float) d1;
imOutBuf[ch][i] += (float) d2;
d3 = d2;
}
phi[ch] = d3;
wrap[ch] = k;
break;
case OP_POLAR2RECT: // ================ Polar->Rect ================
for (i = 0; i < len; i++) {
f1 = wetGain * convBuf1[i];
reOutBuf[ch][i] += f1 * (float) Math.cos(convBuf2[i]);
imOutBuf[ch][i] += f1 * (float) Math.sin(convBuf2[i]);
}
break;
case OP_LOG: // ================ Log ================
if (complex) {
d3 = phi[ch];
k = wrap[ch];
d4 = k * Constants.PI2;
d5 = carry[ch];
for (i = 0; i < len; i++) {
d1 = Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
if (d2 - d3 > Math.PI) {
k--;
d4 = k * Constants.PI2;
} else if (d3 - d2 > Math.PI) {
k++;
d4 = k * Constants.PI2;
}
if (d1 > 0.0) {
d5 = Math.log(d1);
}
d2 += d4;
reOutBuf[ch][i] += (float) d5;
imOutBuf[ch][i] += (float) d2;
d3 = d2;
}
phi[ch] = d3;
wrap[ch] = k;
carry[ch] = d5;
} else {
for (i = 0; i < len; i++) {
f1 = convBuf1[i];
if (f1 > 0) {
reOutBuf[ch][i] += wetGain * (float) Math.log(f1);
} // else undefiniert
}
}
break;
case OP_EXP: // ================ Exp ================
if (complex) {
for (i = 0; i < len; i++) {
d1 = wetGain * Math.exp(convBuf1[i]);
reOutBuf[ch][i] += (float) (d1 * Math.cos(convBuf2[i]));
imOutBuf[ch][i] += (float) (d1 * Math.sin(convBuf2[i]));
}
} else {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (float) Math.exp(convBuf1[i]);
}
}
break;
case OP_NOT: // ================ NOT ================
for (i = 0; i < len; i++) {
lo = ~((long) (convBuf1[i] * 2147483647.0));
reOutBuf[ch][i] += wetGain * (float) ((lo & 0xFFFFFFFFL) / 2147483647.0);
}
if (complex) {
for (i = 0; i < len; i++) {
lo = ~((long) (convBuf2[i] * 2147483647.0));
imOutBuf[ch][i] += wetGain * (float) ((lo & 0xFFFFFFFFL) / 2147483647.0);
}
}
break;
}
} // for outChan
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- write output chunk ----
if (reFloatF != null) {
for (ch = 0; ch < outChanNum; ch++) {
reFloatF[ch].writeFloats(reOutBuf[ch], 0, len);
if (pr.bool[PR_HASIMOUTPUT]) {
imFloatF[ch].writeFloats(imOutBuf[ch], 0, len);
}
}
} else {
reOutF.writeFrames(reOutBuf, 0, len);
if (pr.bool[PR_HASIMOUTPUT]) {
imOutF.writeFrames(imOutBuf, 0, len);
}
}
// check max amp
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = reOutBuf[ch];
for (i = 0; i < len; i++) {
f1 = Math.abs(convBuf1[i]);
if (f1 > maxAmp) {
maxAmp = f1;
}
}
if (pr.bool[PR_HASIMOUTPUT]) {
convBuf1 = imOutBuf[ch];
for (i = 0; i < len; i++) {
f1 = Math.abs(convBuf1[i]);
if (f1 > maxAmp) {
maxAmp = f1;
}
}
}
}
progOff += len;
framesWritten += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
} // while not framesWritten
// ----==================== normalize output ====================----
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
peakGain = new Param(maxAmp, Param.ABS_AMP);
gain =
(float)
(Param.transform(
pr.para[PR_GAIN],
Param.ABS_AMP,
new Param(1.0 / peakGain.value, peakGain.unit),
null))
.value;
f1 = pr.bool[PR_HASIMOUTPUT] ? ((1.0f + getProgression()) / 2) : 1.0f;
normalizeAudioFile(reFloatF, reOutF, reOutBuf, gain, f1);
if (pr.bool[PR_HASIMOUTPUT]) {
normalizeAudioFile(imFloatF, imOutF, imOutBuf, gain, 1.0f);
}
maxAmp *= gain;
for (ch = 0; ch < outChanNum; ch++) {
reFloatF[ch].cleanUp();
reFloatF[ch] = null;
reTempFile[ch].delete();
reTempFile[ch] = null;
if (pr.bool[PR_HASIMOUTPUT]) {
imFloatF[ch].cleanUp();
imFloatF[ch] = null;
imTempFile[ch].delete();
imTempFile[ch] = null;
}
}
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Finish ----
reOutF.close();
reOutF = null;
reOutStream = null;
if (imOutF != null) {
imOutF.close();
imOutF = null;
imOutStream = null;
}
reInF.close();
reInF = null;
reInStream = null;
if (pr.bool[PR_HASIMINPUT]) {
imInF.close();
imInF = null;
imInStream = null;
}
reOutBuf = null;
imOutBuf = null;
reInBuf = null;
imInBuf = null;
// inform about clipping/ low level
handleClipping(maxAmp);
} catch (IOException e1) {
setError(e1);
} catch (OutOfMemoryError e2) {
reOutBuf = null;
imOutBuf = null;
reInBuf = null;
imInBuf = null;
convBuf1 = null;
convBuf2 = null;
System.gc();
setError(new Exception(ERR_MEMORY));
}
// ---- cleanup (topLevel) ----
convBuf1 = null;
convBuf2 = null;
if (reInF != null) {
reInF.cleanUp();
reInF = null;
}
if (imInF != null) {
imInF.cleanUp();
imInF = null;
}
if (reOutF != null) {
reOutF.cleanUp();
reOutF = null;
}
if (imOutF != null) {
imOutF.cleanUp();
imOutF = null;
}
if (reFloatF != null) {
for (ch = 0; ch < reFloatF.length; ch++) {
if (reFloatF[ch] != null) {
reFloatF[ch].cleanUp();
reFloatF[ch] = null;
}
if (reTempFile[ch] != null) {
reTempFile[ch].delete();
reTempFile[ch] = null;
}
}
}
if (imFloatF != null) {
for (ch = 0; ch < imFloatF.length; ch++) {
if (imFloatF[ch] != null) {
imFloatF[ch].cleanUp();
imFloatF[ch] = null;
}
if (imTempFile[ch] != null) {
imTempFile[ch].delete();
imTempFile[ch] = null;
}
}
}
} // process()
public void run() {
runInit(); // superclass
// Haupt-Variablen fuer den Prozess
int ch, i;
float f1, f2, maxGain;
double exp;
Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
SpectStreamSlot runInSlot;
SpectStreamSlot runOutSlot;
SpectStream runInStream = null;
SpectStream runOutStream;
SpectFrame runInFr = null;
SpectFrame runOutFr = null;
// Ziel-Frame Berechnung
int srcBands, fftSize, fullFFTsize, winSize, winHalf;
float[] fftBuf, convBuf1, convBuf2, win;
topLevel:
try {
// ------------------------------ Input-Slot ------------------------------
runInSlot = slots.elementAt(SLOT_INPUT);
if (runInSlot.getLinked() == null) {
runStop(); // threadDead = true -> folgendes for() wird uebersprungen
}
// diese while Schleife ist noetig, da beim initReader ein Pause eingelegt werden kann
// und die InterruptException ausgeloest wird; danach versuchen wir es erneut
for (boolean initDone = false; !initDone && !threadDead; ) {
try {
runInStream = runInSlot.getDescr(); // throws InterruptedException
initDone = true;
} catch (InterruptedException ignored) {
}
runCheckPause();
}
if (threadDead) break topLevel;
// ------------------------------ Output-Slot ------------------------------
runOutSlot = slots.elementAt(SLOT_OUTPUT);
runOutStream = new SpectStream(runInStream);
runOutSlot.initWriter(runOutStream);
// ------------------------------ Vorberechnungen ------------------------------
srcBands = runInStream.bands;
winSize = srcBands - 1;
winHalf = winSize >> 1;
win = Filter.createFullWindow(winSize, Filter.WIN_BLACKMAN); // pr.intg[ PR_WINDOW ]);
fftSize = srcBands - 1;
fullFFTsize = fftSize << 1;
fftBuf = new float[fullFFTsize + 2];
exp = (Param.transform(pr.para[PR_CONTRAST], Param.ABS_AMP, ampRef, null)).value - 1.0;
maxGain = (float) (Param.transform(pr.para[PR_MAXBOOST], Param.ABS_AMP, ampRef, null)).value;
// System.out.println( "srcBands "+srcBands+"; fftSize "+fftSize+"; exp "+exp+"; maxGain
// "+maxGain );
// ------------------------------ Hauptschleife ------------------------------
runSlotsReady();
mainLoop:
while (!threadDead) {
// ---------- Frame einlesen ----------
for (boolean readDone = false; (!readDone) && !threadDead; ) {
try {
runInFr = runInSlot.readFrame(); // throws InterruptedException
readDone = true;
runOutFr = runOutStream.allocFrame();
} catch (InterruptedException ignored) {
} catch (EOFException e) {
break mainLoop;
}
runCheckPause();
}
if (threadDead) break mainLoop;
// ---------- Process: Ziel-Frame berechnen ----------
for (ch = 0; ch < runOutStream.chanNum; ch++) {
convBuf1 = runInFr.data[ch];
convBuf2 = runOutFr.data[ch];
fftBuf[0] = 1.0f;
fftBuf[1] = 0.0f;
for (i = 2; i < fullFFTsize; ) {
f2 = (convBuf1[i - 2] + convBuf1[i + 2]);
if (f2 > 0.0f) {
f1 = (float) Math.min(maxGain, Math.pow(2.0f * convBuf1[i] / f2, exp));
} else {
if (convBuf1[i] == 0.0f) {
f1 = 1.0f;
} else {
f1 = maxGain;
}
}
// System.out.println( f1 );
fftBuf[i++] = f1;
fftBuf[i++] = 0.0f;
}
fftBuf[i++] = 1.0f;
fftBuf[i++] = 0.0f;
Fourier.realTransform(fftBuf, fullFFTsize, Fourier.INVERSE);
Util.mult(win, winHalf, fftBuf, 0, winHalf);
for (i = winHalf; i < fullFFTsize - winHalf; ) {
fftBuf[i++] = 0.0f;
}
Util.mult(win, 0, fftBuf, i, winHalf);
// if( (runOutStream.framesWritten < 2) && (ch == 0) ) Debug.view( fftBuf, "time" );
Fourier.realTransform(fftBuf, fullFFTsize, Fourier.FORWARD);
// if( (runOutStream.framesWritten < 2) && (ch == 0) ) Debug.view( fftBuf, "freq" );
for (i = 0; i <= fullFFTsize; ) {
convBuf2[i] = convBuf1[i] * fftBuf[i];
i++;
convBuf2[i] = convBuf1[i];
i++;
}
}
// calculation done
// if( (runOutStream.framesWritten < 2) ) {
// Debug.view( fftBuf, "flt "+runOutStream.framesWritten );
// Debug.view( runInFr.data[0], "in "+runOutStream.framesWritten );
// Debug.view( runOutFr.data[0], "out "+runOutStream.framesWritten );
// }
runInSlot.freeFrame(runInFr);
for (boolean writeDone = false; (!writeDone) && !threadDead; ) {
try { // Unterbrechung
runOutSlot.writeFrame(runOutFr); // throws InterruptedException
writeDone = true;
runFrameDone(runOutSlot, runOutFr);
runOutStream.freeFrame(runOutFr);
} catch (InterruptedException ignored) {
} // mainLoop wird eh gleich verlassen
runCheckPause();
}
} // end of main loop
runInStream.closeReader();
runOutStream.closeWriter();
} // break topLevel
catch (IOException e) {
runQuit(e);
return;
} catch (SlotAlreadyConnectedException e) {
runQuit(e);
return;
}
// catch( OutOfMemoryError e ) {
// abort( e );
// return;
// }
runQuit(null);
}
protected void process() {
int len;
long progOff, progLen;
// io
AudioFile inF = null;
AudioFile outF = null;
AudioFileDescr inDescr = null;
AudioFileDescr outStream = null;
int chanNum;
float[][] inBuf = null;
// Synthesize
float gain = 1.0f; // gain abs amp
Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
// Smp Init
long inLength;
long framesRead;
float maxAmp;
PathField ggOutput;
topLevel:
try {
// ---- open input ----
inF = AudioFile.openAsRead(new File(pr.text[PR_INPUTFILE]));
inDescr = inF.getDescr();
chanNum = inDescr.channels;
inLength = (int) inDescr.length;
// this helps to prevent errors from empty files!
if (chanNum * inLength < 1) throw new EOFException(ERR_EMPTY);
inBuf = new float[chanNum][8192];
progLen = inLength * 3;
progOff = 0L;
// ---- open output ----
ggOutput = (PathField) gui.getItemObj(GG_OUTPUTFILE);
if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
outStream = new AudioFileDescr(inDescr);
ggOutput.fillStream(outStream);
outF = AudioFile.openAsWrite(outStream);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- first pass: get input gain peak ----
maxAmp = -1f;
if (pr.intg[PR_GAINTYPE] == GAIN_ABSOLUTE) {
gain = (float) (Param.transform(pr.para[PR_GAIN], Param.ABS_AMP, ampRef, null)).val;
}
// ---- process loop ----
for (framesRead = 0; (framesRead < inLength) && threadRunning; ) {
len = (int) Math.min(8192, inLength - framesRead);
inF.readFrames(inBuf, 0, len);
framesRead += len;
progOff += len;
// ---- adjust gain + write ----
for (int ch = 0; ch < chanNum; ch++) {
Util.mult(inBuf[ch], 0, len, gain);
}
outF.writeFrames(inBuf, 0, len);
// framesWritten += len;
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Finish ----
inF.close();
inF = null;
inDescr = null;
// ---- Finish ----
outF.close();
outF = null;
// inform about clipping/ low level
maxAmp *= gain;
handleClipping(maxAmp);
} catch (IOException e1) {
setError(e1);
} catch (OutOfMemoryError e2) {
inDescr = null;
outStream = null;
inBuf = null;
System.gc();
setError(new Exception(ERR_MEMORY));
}
// ---- cleanup (topLevel) ----
if (inF != null) {
inF.cleanUp();
}
if (outF != null) {
outF.cleanUp();
}
} // process()