Ejemplo n.º 1
0
  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()
Ejemplo n.º 2
0
  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);
  }