protected void recalcOutFreq() {
if (inRate == 0f) return;
double omegaIn, omegaOut, warp;
ParamField ggOutFreq;
omegaIn = pr.para[PR_INFREQ].val / inRate * Constants.PI2;
warp = Math.max(-0.98, Math.min(0.98, pr.para[PR_WARP].val / 100)); // DAFx2000 'b'
omegaOut = omegaIn + 2 * Math.atan2(warp * Math.sin(omegaIn), 1.0 - warp * Math.cos(omegaIn));
ggOutFreq = (ParamField) gui.getItemObj(GG_OUTFREQ);
if (ggOutFreq != null) {
ggOutFreq.setParam(new Param(omegaOut / Constants.PI2 * inRate, Param.ABS_HZ));
}
}
protected void recalcWarpAmount() {
if (inRate == 0f) return;
double omegaIn, omegaOut, warp, d1;
ParamField ggWarp;
omegaIn = pr.para[PR_INFREQ].val / inRate * Constants.PI2;
omegaOut = pr.para[PR_OUTFREQ].val / inRate * Constants.PI2;
d1 = Math.tan((omegaOut - omegaIn) / 2);
warp =
Math.max(
-0.98,
Math.min(0.98, d1 / (Math.sin(omegaIn) + Math.cos(omegaIn) * d1))); // DAFx2000 'b'
ggWarp = (ParamField) gui.getItemObj(GG_WARP);
if (ggWarp != null) {
ggWarp.setParam(new Param(warp * 100, Param.FACTOR));
}
}
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()
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()