package defpackage;

import com.sun.jna.Function;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.platform.win32.Ole32;
import com.sun.jna.platform.win32.Guid.CLSID;
import com.sun.jna.platform.win32.Guid.IID;
import com.sun.jna.platform.win32.WinNT.HRESULT;
import com.sun.jna.ptr.IntByReference;
import com.sun.jna.ptr.PointerByReference;
import java.util.Arrays;
import java.util.Locale;
import java.util.concurrent.atomic.AtomicBoolean;

public final class in {
   public static final int BAND_COUNT = 5;
   private static final int SAMPLE_COUNT = 1024;
   private static final int FFT_BITS = 10;
   private static final int HALF_SAMPLES = 512;
   private static final String THREAD_NAME = "evolution-audio-equalizer";
   private static final String OS_PROPERTY = "os.name";
   private static final String OS_WINDOWS_PREFIX = "win";
   private static final String CLSID_MM_DEVICE_ENUMERATOR = "{BCDE0395-E52F-467C-8E3D-C4579291692E}";
   private static final String IID_IMM_DEVICE_ENUMERATOR = "{A95664D2-9614-4F35-A746-DE8DB63617E6}";
   private static final String IID_IAUDIO_CLIENT = "{1CB9AD4C-DBFA-4C32-B178-C2F568A703B2}";
   private static final String IID_IAUDIO_CAPTURE_CLIENT = "{C8ADBD64-E71E-48A0-A4DE-185C395CD317}";
   private static final int DATA_FLOW_RENDER = 0;
   private static final int ROLE_CONSOLE = 0;
   private static final int AUDCLNT_SHAREMODE_SHARED = 0;
   private static final int AUDCLNT_STREAMFLAGS_LOOPBACK = 131072;
   private static final int AUDCLNT_BUFFERFLAGS_SILENT = 2;
   private static final long REFTIMES_BUFFER_DURATION = 10000000L;
   private static final long REFTIMES_PERIODICITY = 0L;
   private static final int VTBL_UNKNOWN_RELEASE = 2;
   private static final int VTBL_ENUM_GET_DEFAULT_ENDPOINT = 4;
   private static final int VTBL_DEVICE_ACTIVATE = 3;
   private static final int VTBL_CLIENT_INITIALIZE = 3;
   private static final int VTBL_CLIENT_GET_MIX_FORMAT = 8;
   private static final int VTBL_CLIENT_START = 10;
   private static final int VTBL_CLIENT_STOP = 11;
   private static final int VTBL_CLIENT_GET_SERVICE = 14;
   private static final int VTBL_CAPTURE_GET_BUFFER = 3;
   private static final int VTBL_CAPTURE_RELEASE_BUFFER = 4;
   private static final int VTBL_CAPTURE_GET_NEXT_PACKET = 5;
   private static final short FORMAT_TAG_PCM = 1;
   private static final short FORMAT_TAG_IEEE_FLOAT = 3;
   private static final short FORMAT_TAG_EXTENSIBLE = -2;
   private static final int OFFSET_FORMAT_TAG = 0;
   private static final int OFFSET_CHANNELS = 2;
   private static final int OFFSET_SAMPLES_PER_SEC = 4;
   private static final int OFFSET_BLOCK_ALIGN = 12;
   private static final int OFFSET_BITS_PER_SAMPLE = 14;
   private static final int OFFSET_CB_SIZE = 16;
   private static final int OFFSET_SUB_FORMAT = 24;
   private static final int HRESULT_OK = 0;
   private static final long CAPTURE_SLEEP_MILLIS = 15L;
   private static final long RECONNECT_SLEEP_MILLIS = 1000L;
   private static final long IDLE_SHUTDOWN_MILLIS = 3500L;
   private static final float FLOAT_SCALE_16BIT = 32768.0F;
   private static final float STEREO_DIVISOR = 2.0F;
   private static final float SILENCE_THRESHOLD = 5.0E-5F;
   private static final float INITIAL_ENVELOPE = 0.04F;
   private static final float MIN_ENVELOPE = 1.0E-4F;
   private static final float ENVELOPE_ATTACK = 0.5F;
   private static final float ENVELOPE_DECAY = 0.03F;
   private static final float INITIAL_BAND_PEAK = 0.05F;
   private static final float MIN_BAND_PEAK = 0.008F;
   private static final float BAND_PEAK_ATTACK = 0.7F;
   private static final float BAND_PEAK_DECAY = 0.012F;
   private static final float HEADROOM_FACTOR = 0.78F;
   private static final float EXPANSION_POWER = 1.35F;
   private static final float ATTACK_FACTOR = 0.72F;
   private static final float DECAY_FACTOR = 0.18F;
   private static final float LEVEL_MIN = 0.0F;
   private static final float LEVEL_MAX = 1.0F;
   private static final float[] BAND_MIN_FREQS;
   private static final float[] BAND_MAX_FREQS;
   private static final float[] BAND_WEIGHTS;
   private static final float[] HANN_WINDOW = new float[1024];
   private static final float[] COS_TABLE = new float[512];
   private static final float[] SIN_TABLE = new float[512];
   private static final int[] BIT_REVERSED = new int[1024];
   private final AtomicBoolean running = new AtomicBoolean();
   private final boolean windows = System.getProperty("os.name", "")
      .toLowerCase(Locale.ROOT)
      .startsWith("win");
   private static final String MAC_THREAD_NAME = "evolution-audio-macos";
   private static final int MAC_READ_SAMPLES = 12000;
   private static final int MAX_MAC_RESTARTS = 3;
   private static final String MAC_CAPTURE_FAILURE = "macOS audio capture failed";
   private final boolean mac = (boolean)(((!this.windows && iq.isAvailable()
      ? 1: (122664002 | -122664002) + (122664002 & -122664002))) != 0);
   private final float[] macSamples = new float[12000];
   private volatile boolean permissionDenied;
   private final float[] ringBuffer = new float[1024];
   private final float[] realBuffer = new float[1024];
   private final float[] imagBuffer = new float[1024];
   private final float[] smoothedLevels = new float[5];
   private final float[] rawWeighted = new float[5];
   private final float[] bandPeaks = new float[5];
   private float inputEnvelope = 0.04F;
   private volatile float[] publishedLevels = new float[5];
   private volatile jl pcmSink;
   private float[] tapBuffer = new float[1024];
   private volatile long lastRequestMillis;
   private volatile boolean capturing;
   private int ringWriteIndex;

   private in() {
      Arrays.fill(this.bandPeaks, 0.05F);
   }

   public static in getInstance() {
      return INSTANCE;
   }

   public boolean isCapturing() {
      return this.capturing;
   }

   public boolean isSupported() {
      int var2 = 0;
      int var1 = -313636491;

      while (true) {
         switch (var1) {
            case -2043074563:
               var2 = 1;
               var1 = -108489319;
               break;
            case -313636491:
            default:
               if (!this.windows) {
                  var1 = 462869334;
               } else {
                  var1 = -2043074563;
               }
               break;
            case -108489319:
               return (boolean)((var2) != 0);
            case 446180259:
               var2 = 0;
               var1 = -108489319;
               break;
            case 462869334:
               if (this.mac) {
                  var1 = -2043074563;
               } else {
                  var1 = 446180259;
               }
         }
      }
   }

   public boolean isPermissionDenied() {
      return this.permissionDenied;
   }

   public void setPcmSink(jl var1) {
      this.pcmSink = var1;
   }

   public float[] getLevels() {
      return this.publishedLevels;
   }

   public void requestUpdates() {
      Thread var1 = null;
      Thread var3 = null;
      int var2 = -186630927;

      while (true) {
         switch (var2) {
            case -1680472873:
               var1 = var3;
               var1.setDaemon((boolean)((((-1770584149 | 1770584150) + (-1770584149 & 1770584150))) != 0));
               var1.setPriority((1868945310 ^ -1868945308) + ((1868945310 & -1868945308) << 1));
               var1.start();
               var2 = 1121928812;
               break;
            case -330671618:
               if (this.permissionDenied) {
                  var2 = -251257404;
               } else {
                  var2 = 225468126;
               }
               break;
            case -260217876:
               if (this.mac) {
                  var2 = -330671618;
               } else {
                  var2 = -251257404;
               }
               break;
            case -251257404:
               return;
            case -186630927:
            default:
               this.lastRequestMillis = System.currentTimeMillis();
               if (!this.windows) {
                  var2 = -260217876;
               } else {
                  var2 = 225468126;
               }
               break;
            case 225468126:
               if (this.running
                  .compareAndSet(
                     (boolean)((((0)) != 0)), (boolean)((((31718635 ^ -31718634) + ((31718635 & -31718634) << 1))
                  ) != 0))) {
                  var2 = 1034732509;
               } else {
                  var2 = 1121928812;
               }
               break;
            case 779472441:
               var3 = new Thread(
                  this::runCaptureLoop, "evolution-audio-equalizer"
               );
               var2 = -1680472873;
               break;
            case 1034732509:
               if (this.windows) {
                  var2 = 779472441;
               } else {
                  var2 = 1579655120;
               }
               break;
            case 1121928812:
               return;
            case 1579655120:
               var3 = new Thread(
                  this::runMacCaptureLoop,
                  "evolution-audio-macos"
               );
               var2 = -1680472873;
         }
      }
   }

   // $VF: Could not verify finally blocks. A semaphore variable has been added to preserve control flow.
   // Please report this to the Vineflower issue tracker, at https://github.com/Vineflower/vineflower/issues with a copy of the class file (if you have the rights to distribute it!)
   private void runCaptureLoop() {
      HRESULT var1 = Ole32.INSTANCE.CoInitializeEx(null, (-1307305973 ^ 1307305973) + ((-1307305973 & 1307305973) << 1));

      while (true) {
         boolean var4 = false /* VF: Semaphore variable */;

         try {
            var4 = true;
            if (!this.running.get()) {
               var4 = false;
               break;
            }

            if (System.currentTimeMillis() - this.lastRequestMillis
               > (-1467586903413956123L | 1467586903413959623L) + (-1467586903413956123L & 1467586903413959623L)) {
               this.capturing = (boolean)(((0)) != 0);
               this.resetLevels();
               this.running.set((boolean)((((-576471101 ^ 576471101) + ((-576471101 & 576471101) << 1))) != 0));
               var4 = false;
               break;
            }

            this.captureSession();
         } finally {
            if (var4) {
               this.capturing = (boolean)(((0)) != 0);
               this.resetLevels();
               this.running.set((boolean)((((1597272969 | -1597272969) + (1597272969 & -1597272969))) != 0));
               if (var1 != null && var1.intValue() == 0) {
                  Ole32.INSTANCE.CoUninitialize();
               }
            }
         }
      }

      this.capturing = (boolean)(((0)) != 0);
      this.resetLevels();
      this.running.set((boolean)((((-1648759842 | 1648759842) + (-1648759842 & 1648759842))) != 0));
      if (var1 != null && var1.intValue() == 0) {
         Ole32.INSTANCE.CoUninitialize();
      }
   }

   // $VF: Could not verify finally blocks. A semaphore variable has been added to preserve control flow.
   // Please report this to the Vineflower issue tracker, at https://github.com/Vineflower/vineflower/issues with a copy of the class file (if you have the rights to distribute it!)
   private void runMacCaptureLoop() {
      iq var1 = null;
      int var2 = 0;

      while (true) {
         boolean var10 = false /* VF: Semaphore variable */;

         label143: {
            try {
               var10 = true;
               if (this.running.get()) {
                  if (System.currentTimeMillis() - this.lastRequestMillis
                     > (-8013551586692227380L ^ 8013551586692230880L) + ((-8013551586692227380L & 8013551586692230880L) << 1)) {
                     var10 = false;
                  } else {
                     label156: {
                        if (var1 == null || !var1.isAlive()) {
                           if (var1 != null) {
                              if (var1.permissionDenied()) {
                                 this.permissionDenied = (boolean)(((1)) != 0);
                                 var10 = false;
                                 break label156;
                              }

                              var1.close();
                              if (++var2 > (402074660 ^ -402074657) + ((402074660 & -402074657) << 1)) {
                                 var10 = false;
                                 break label156;
                              }

                              sleepQuietly((2589655016062673922L ^ -2589655016062672922L) + ((2589655016062673922L & -2589655016062672922L) << 1));
                           }

                           var1 = iq.start();
                        }

                        sleepQuietly((3028274378532280086L | -3028274378532280071L) + (3028274378532280086L & -3028274378532280071L));
                        int var3 = var1.read(this.macSamples);
                        int var4 = 0;

                        for (int var5 = 0; var5 < var3; var5++) {
                           float var6 = this.macSamples[var5];
                           var4 |= var6 != 0.0F
                              ? 1: 0;
                           this.ringBuffer[this.ringWriteIndex] = var6;
                           this.ringWriteIndex = (this.ringWriteIndex + (562022278 ^ -562022277) + ((562022278 & -562022277) << 1))
                              % ((-834897160 ^ 834898184) + ((-834897160 & 834898184) << 1));
                        }

                        this.capturing = (boolean)(((1)) != 0);
                        jl var13 = this.pcmSink;
                        if (var13 != null && var3 > 0) {
                           var13.accept(this.macSamples, var3, (1435527260 | -1435479260) + (1435527260 & -1435479260));
                        }

                        this.processSpectralAnalysis(48000, (boolean)((var4) != 0));
                        continue;
                     }
                  }
               } else {
                  var10 = false;
               }
            } catch (Exception var11) {
               id.warn(
                  Cif.MEDIA,
                  "macOS audio capture failed",
                  var11
               );
               var10 = false;
               break label143;
            } finally {
               if (var10) {
                  if (var1 != null) {
                     var1.close();
                  }

                  this.capturing = (boolean)(((0)) != 0);
                  this.resetLevels();
                  this.running.set((boolean)((((1612599839 | -1612599839) + (1612599839 & -1612599839))) != 0));
               }
            }

            if (var1 != null) {
               var1.close();
            }

            this.capturing = (boolean)(((0)) != 0);
            this.resetLevels();
            this.running.set((boolean)((((39458946 | -39458946) + (39458946 & -39458946))) != 0));
            break;
         }

         if (var1 != null) {
            var1.close();
         }

         this.capturing = (boolean)(((0)) != 0);
         this.resetLevels();
         this.running.set((boolean)((((-1165245689 ^ 1165245689) + ((-1165245689 & 1165245689) << 1))) != 0));
         break;
      }
   }

   // $VF: Could not verify finally blocks. A semaphore variable has been added to preserve control flow.
   // Please report this to the Vineflower issue tracker, at https://github.com/Vineflower/vineflower/issues with a copy of the class file (if you have the rights to distribute it!)
   private void captureSession() {
      CLSID var1 = new CLSID(
         "{BCDE0395-E52F-467C-8E3D-C4579291692E}"
      );
      IID var2 = new IID("{A95664D2-9614-4F35-A746-DE8DB63617E6}");
      PointerByReference var3 = new PointerByReference();
      HRESULT var4 = Ole32.INSTANCE.CoCreateInstance(var1, null, 7, var2, var3);
      if (var4 != null && var4.intValue() == 0) {
         Pointer var5 = var3.getValue();
         Pointer var6 = null;
         Pointer var7 = null;
         Pointer var8 = null;
         boolean var58 = false /* VF: Semaphore variable */;

         label253: {
            label252: {
               label251: {
                  label250: {
                     label249: {
                        try {
                           var58 = true;
                           Pointer var9 = var5.getPointer((-8869697290728664304L | 8869697290728664304L) + (-8869697290728664304L & 8869697290728664304L));
                           Function var10 = Function.getFunction(
                              var9.getPointer(
                                 ((-5198559126121333763L ^ 5198559126121333767L) + ((-5198559126121333763L & 5198559126121333767L) << 1)) * Native.POINTER_SIZE
                              ),
                              (-1686484027 | 1686484090) + (-1686484027 & 1686484090)
                           );
                           PointerByReference var11 = new PointerByReference();
                           Object[] var10001 = new Object[4];
                           var10001[0] = var5;
                           var10001[1] = 0;
                           var10001[2] = 0;
                           var10001[3] = var11;
                           int var12 = var10.invokeInt(var10001);
                           if (var12 != 0) {
                              sleepQuietly((-3586652288921551302L ^ 3586652288921552302L) + ((-3586652288921551302L & 3586652288921552302L) << 1));
                              var58 = false;
                              break label253;
                           }

                           var6 = var11.getValue();
                           Pointer var13 = var6.getPointer(
                              (-1859543808760685255L ^ 1859543808760685255L) + ((-1859543808760685255L & 1859543808760685255L) << 1)
                           );
                           Function var14 = Function.getFunction(
                              var13.getPointer(
                                 ((6772230852095147249L ^ -6772230852095147246L) + ((6772230852095147249L & -6772230852095147246L) << 1)) * Native.POINTER_SIZE
                              ),
                              (-818896913 ^ 818896976) + ((-818896913 & 818896976) << 1)
                           );
                           IID var15 = new IID(
                              "{1CB9AD4C-DBFA-4C32-B178-C2F568A703B2}"
                           );
                           PointerByReference var16 = new PointerByReference();
                           var10001 = new Object[5];
                           var10001[0] = var6;
                           var10001[1] = var15.getPointer();
                           var10001[2] = 7;
                           var10001[3] = null;
                           var10001[4] = var16;
                           var12 = var14.invokeInt(var10001);
                           if (var12 != 0) {
                              sleepQuietly((3336506912415997144L | -3336506912415996144L) + (3336506912415997144L & -3336506912415996144L));
                              var58 = false;
                              break label252;
                           }

                           var7 = var16.getValue();
                           Pointer var17 = var7.getPointer((4991801622914213544L | -4991801622914213544L) + (4991801622914213544L & -4991801622914213544L));
                           Function var18 = Function.getFunction(
                              var17.getPointer(
                                 ((-2850721200200959750L | 2850721200200959758L) + (-2850721200200959750L & 2850721200200959758L)) * Native.POINTER_SIZE
                              ),
                              (1982337751 ^ -1982337688) + ((1982337751 & -1982337688) << 1)
                           );
                           PointerByReference var19 = new PointerByReference();
                           var10001 = new Object[2];
                           var10001[0] = var7;
                           var10001[1] = var19;
                           var12 = var18.invokeInt(var10001);
                           if (var12 != 0) {
                              sleepQuietly((8725473133591328048L ^ -8725473133591327048L) + ((8725473133591328048L & -8725473133591327048L) << 1));
                              var58 = false;
                              break label251;
                           }

                           Pointer var20 = var19.getValue();
                           short var21 = var20.getShort((-787135885327333432L ^ 787135885327333432L) + ((-787135885327333432L & 787135885327333432L) << 1));
                           short var22 = var20.getShort((-2366505321244471785L | 2366505321244471787L) + (-2366505321244471785L & 2366505321244471787L));
                           int var23 = var20.getInt((8080463416067119742L | -8080463416067119738L) + (8080463416067119742L & -8080463416067119738L));
                           short var24 = var20.getShort((2998145670670132114L ^ -2998145670670132102L) + ((2998145670670132114L & -2998145670670132102L) << 1));
                           short var25 = var20.getShort((3428110830534667407L ^ -3428110830534667393L) + ((3428110830534667407L & -3428110830534667393L) << 1));
                           short var26 = var20.getShort((5676524849179215521L | -5676524849179215505L) + (5676524849179215521L & -5676524849179215505L));
                           short var27 = var21;
                           if (var21 == (-1512278512 ^ 1512278510) + ((-1512278512 & 1512278510) << 1)
                              && var26 >= (2099727531 | -2099727523) + (2099727531 & -2099727523)) {
                              var27 = var20.getShort((-698147285110261867L ^ 698147285110261891L) + ((-698147285110261867L & 698147285110261891L) << 1));
                           }

                           int var28 = var27 != (-642678834 | 642678837) + (-642678834 & 642678837)
                                 && var25 != 32? 0: 1;
                           Function var29 = Function.getFunction(
                              var17.getPointer(
                                 ((-1179143417675055669L | 1179143417675055672L) + (-1179143417675055669L & 1179143417675055672L)) * Native.POINTER_SIZE
                              ),
                              (532692026 ^ -532691963) + ((532692026 & -532691963) << 1)
                           );
                           var10001 = new Object[7];
                           var10001[0] = var7;
                           var10001[1] = 0;
                           var10001[2] = 131072;
                           var10001[3] = (7358636897776098140L | -7358636897766098140L)
                              + (7358636897776098140L & -7358636897766098140L);
                           var10001[4] = (-5826453627189730205L ^ 5826453627189730205L)
                              + ((-5826453627189730205L & 5826453627189730205L) << 1);
                           var10001[5] = var20;
                           var10001[6] = null;
                           var12 = var29.invokeInt(var10001);
                           if (var12 != 0) {
                              sleepQuietly((699671224920176657L | -699671224920175657L) + (699671224920176657L & -699671224920175657L));
                              var58 = false;
                              break label250;
                           }

                           IID var30 = new IID(
                              "{C8ADBD64-E71E-48A0-A4DE-185C395CD317}"
                           );
                           Function var31 = Function.getFunction(
                              var17.getPointer(
                                 ((8333650117374223678L | -8333650117374223664L) + (8333650117374223678L & -8333650117374223664L)) * Native.POINTER_SIZE
                              ),
                              (1264174685 | -1264174622) + (1264174685 & -1264174622)
                           );
                           PointerByReference var32 = new PointerByReference();
                           var10001 = new Object[3];
                           var10001[0] = var7;
                           var10001[1] = var30.getPointer();
                           var10001[2] = var32;
                           var12 = var31.invokeInt(var10001);
                           if (var12 != 0) {
                              sleepQuietly((-8932721553073369938L ^ 8932721553073370938L) + ((-8932721553073369938L & 8932721553073370938L) << 1));
                              var58 = false;
                              break label249;
                           }

                           var8 = var32.getValue();
                           Pointer var33 = var8.getPointer(
                              (-2632162585193409210L ^ 2632162585193409210L) + ((-2632162585193409210L & 2632162585193409210L) << 1)
                           );
                           Function var34 = Function.getFunction(
                              var17.getPointer(
                                 ((7046824768781160019L ^ -7046824768781160009L) + ((7046824768781160019L & -7046824768781160009L) << 1)) * Native.POINTER_SIZE
                              ),
                              (370751814 ^ -370751751) + ((370751814 & -370751751) << 1)
                           );
                           var10001 = new Object[1];
                           var10001[0] = var7;
                           var34.invokeInt(var10001);
                           Function var35 = Function.getFunction(
                              var33.getPointer(
                                 ((-8378604819745069501L ^ 8378604819745069506L) + ((-8378604819745069501L & 8378604819745069506L) << 1)) * Native.POINTER_SIZE
                              ),
                              (79793685 | -79793622) + (79793685 & -79793622)
                           );
                           Function var36 = Function.getFunction(
                              var33.getPointer(
                                 ((-660416885159534742L ^ 660416885159534745L) + ((-660416885159534742L & 660416885159534745L) << 1)) * Native.POINTER_SIZE
                              ),
                              (560772137 ^ -560772074) + ((560772137 & -560772074) << 1)
                           );
                           Function var37 = Function.getFunction(
                              var33.getPointer(
                                 ((4604441693053660559L ^ -4604441693053660555L) + ((4604441693053660559L & -4604441693053660555L) << 1)) * Native.POINTER_SIZE
                              ),
                              (-1051189838 ^ 1051189901) + ((-1051189838 & 1051189901) << 1)
                           );
                           Function var38 = Function.getFunction(
                              var17.getPointer(
                                 ((6255962901841813180L ^ -6255962901841813169L) + ((6255962901841813180L & -6255962901841813169L) << 1)) * Native.POINTER_SIZE
                              ),
                              (881222417 ^ -881222354) + ((881222417 & -881222354) << 1)
                           );
                           IntByReference var39 = new IntByReference();
                           PointerByReference var40 = new PointerByReference();
                           IntByReference var41 = new IntByReference();
                           IntByReference var42 = new IntByReference();
                           this.capturing = (boolean)(((1)) != 0);

                           while (
                              this.running.get()
                                 && System.currentTimeMillis() - this.lastRequestMillis
                                    <= (3646296176605471621L ^ -3646296176605468121L) + ((3646296176605471621L & -3646296176605468121L) << 1)
                           ) {
                              sleepQuietly((3445524868813974958L ^ -3445524868813974943L) + ((3445524868813974958L & -3445524868813974943L) << 1));
                              var10001 = new Object[2];
                              var10001[0] = var8;
                              var10001[1] = var39;
                              var12 = var35.invokeInt(var10001);
                              if (var12 != 0) {
                                 break;
                              }

                              int var43 = var39.getValue();
                              int var44 = 0;

                              while (true) {
                                 if (var43 > 0) {
                                    var10001 = new Object[6];
                                    var10001[0] = var8;
                                    var10001[1] = var40;
                                    var10001[2] = var41;
                                    var10001[3] = var42;
                                    var10001[4] = null;
                                    var10001[5] = null;
                                    var12 = var36.invokeInt(var10001);
                                    if (var12 == 0) {
                                       int var45 = var41.getValue();
                                       int var46 = var42.getValue();
                                       Pointer var47 = var40.getValue();
                                       jl var48 = this.pcmSink;
                                       if (var48 != null && this.tapBuffer.length < var45) {
                                          this.tapBuffer = new float[Math.max(
                                             var45, this.tapBuffer.length * ((-890225308 | 890225310) + (-890225308 & 890225310))
                                          )];
                                       }

                                       if ((var46 & (-1552832228 | 1552832230) + (-1552832228 & 1552832230)) == 0 && var47 != null) {
                                          var44 = 1;
                                          int var67 = var25 / (8);

                                          for (int var50 = 0; var50 < var45; var50++) {
                                             long var51 = (long)var50 * var24;
                                             float var53;
                                             if (var28 != 0) {
                                                float var54 = var47.getFloat(var51);
                                                float var55 = var22 > 1? var47.getFloat(var51 + var67)
                                                   : var54;
                                                var53 = (var54 + var55) / 2.0F;
                                             } else {
                                                short var68 = var47.getShort(var51);
                                                short var69 = var22 > 1? var47.getShort(var51 + var67)
                                                   : var68;
                                                var53 = (var68 + var69) / 2.0F / 32768.0F;
                                             }

                                             this.ringBuffer[this.ringWriteIndex] = var53;
                                             this.ringWriteIndex = (this.ringWriteIndex + (995143435 ^ -995143434) + ((995143435 & -995143434) << 1))
                                                % ((1691006378 | -1691005354) + (1691006378 & -1691005354));
                                             if (var48 != null) {
                                                this.tapBuffer[var50] = var53;
                                             }
                                          }

                                          if (var48 != null) {
                                             var48.accept(this.tapBuffer, var45, var23);
                                          }
                                       } else {
                                          for (int var49 = 0; var49 < var45; var49++) {
                                             this.ringBuffer[this.ringWriteIndex] = 0.0F;
                                             this.ringWriteIndex = (this.ringWriteIndex + (34529917 | -34529916) + (34529917 & -34529916))
                                                % ((2031064804 ^ -2031063780) + ((2031064804 & -2031063780) << 1));
                                          }

                                          if (var48 != null) {
                                             Arrays.fill(this.tapBuffer, 0, var45, 0.0F);
                                             var48.accept(this.tapBuffer, var45, var23);
                                          }
                                       }

                                       var10001 = new Object[2];
                                       var10001[0] = var8;
                                       var10001[1] = var45;
                                       var37.invokeInt(var10001);
                                       var10001 = new Object[2];
                                       var10001[0] = var8;
                                       var10001[1] = var39;
                                       var12 = var35.invokeInt(var10001);
                                       if (var12 == 0) {
                                          var43 = var39.getValue();
                                          continue;
                                       }
                                    }
                                 }

                                 this.processSpectralAnalysis(var23, (boolean)((var44) != 0));
                                 break;
                              }
                           }

                           var10001 = new Object[1];
                           var10001[0] = var7;
                           var38.invokeInt(var10001);
                           var58 = false;
                        } finally {
                           if (var58) {
                              this.capturing = (boolean)(((0)) != 0);
                              releaseComPointer(var8);
                              releaseComPointer(var7);
                              releaseComPointer(var6);
                              releaseComPointer(var5);
                           }
                        }

                        this.capturing = (boolean)(((0)) != 0);
                        releaseComPointer(var8);
                        releaseComPointer(var7);
                        releaseComPointer(var6);
                        releaseComPointer(var5);
                        return;
                     }

                     this.capturing = (boolean)(((0)) != 0);
                     releaseComPointer(var8);
                     releaseComPointer(var7);
                     releaseComPointer(var6);
                     releaseComPointer(var5);
                     return;
                  }

                  this.capturing = (boolean)(((0)) != 0);
                  releaseComPointer(var8);
                  releaseComPointer(var7);
                  releaseComPointer(var6);
                  releaseComPointer(var5);
                  return;
               }

               this.capturing = (boolean)(((0)) != 0);
               releaseComPointer(var8);
               releaseComPointer(var7);
               releaseComPointer(var6);
               releaseComPointer(var5);
               return;
            }

            this.capturing = (boolean)(((0)) != 0);
            releaseComPointer(var8);
            releaseComPointer(var7);
            releaseComPointer(var6);
            releaseComPointer(var5);
            return;
         }

         this.capturing = (boolean)(((0)) != 0);
         releaseComPointer(var8);
         releaseComPointer(var7);
         releaseComPointer(var6);
         releaseComPointer(var5);
      } else {
         sleepQuietly((7844939682892813280L ^ -7844939682892812280L) + ((7844939682892813280L & -7844939682892812280L) << 1));
      }
   }

   private void processSpectralAnalysis(int var1, boolean var2) {
      if (!var2) {
         this.decayLevels();
      } else {
         int var3 = this.ringWriteIndex;
         float var4 = 0.0F;

         for (int var5 = 0; var5 < 1024; var5++) {
            float var6 = Math.abs(this.ringBuffer[var5]);
            if (var6 > var4) {
               var4 = var6;
            }
         }

         if (var4 <= 5.0E-5F) {
            this.decayLevels();
         } else {
            if (var4 > this.inputEnvelope) {
               this.inputEnvelope = this.inputEnvelope + (var4 - this.inputEnvelope) * 0.5F;
            } else {
               this.inputEnvelope = this.inputEnvelope + (var4 - this.inputEnvelope) * 0.03F;
            }

            if (this.inputEnvelope < 1.0E-4F) {
               this.inputEnvelope = 1.0E-4F;
            }

            float var15 = 1.0F / this.inputEnvelope;

            for (int var16 = 0;
               var16 < 1024;
               var16++
            ) {
               this.realBuffer[var16] = this.ringBuffer[(var3 + var16) % (1024)]
                  * var15
                  * HANN_WINDOW[var16];
               this.imagBuffer[var16] = 0.0F;
            }

            computeFft(this.realBuffer, this.imagBuffer);
            float var17 = var1 / 1024.0F;

            for (int var7 = 0;
               var7 < 5;
               var7++
            ) {
               int var8 = Math.max(1, Math.round(BAND_MIN_FREQS[var7] / var17));
               int var9 = Math.min(511, Math.max(var8, Math.round(BAND_MAX_FREQS[var7] / var17)));
               float var10 = 0.0F;
               int var11 = 0;

               for (int var12 = var8; var12 <= var9; var12++) {
                  float var13 = this.realBuffer[var12];
                  float var14 = this.imagBuffer[var12];
                  var10 += var13 * var13 + var14 * var14;
                  var11++;
               }

               float var23 = var11 > 0 ? (float)Math.sqrt(var10 / var11) / 1024.0F : 0.0F;
               float var25 = var23 * BAND_WEIGHTS[var7];
               this.rawWeighted[var7] = var25;
               float var27 = this.bandPeaks[var7];
               if (var25 > var27) {
                  var27 += (var25 - var27) * 0.7F;
               } else {
                  var27 += (var25 - var27) * 0.012F;
               }

               if (var27 < 0.008F) {
                  var27 = 0.008F;
               }

               this.bandPeaks[var7] = var27;
            }

            float[] var18 = new float[5];

            for (int var19 = 0;
               var19 < 5;
               var19++
            ) {
               float var20 = this.rawWeighted[var19];
               float var21 = this.bandPeaks[var19];
               float var22 = Math.min(1.0F, var20 / (var21 * 0.78F));
               float var24 = (float)Math.pow(var22, 1.35F);
               float var26 = Math.max(0.0F, Math.min(1.0F, var24));
               float var29 = this.smoothedLevels[var19];
               if (var26 > var29) {
                  var29 += (var26 - var29) * 0.72F;
               } else {
                  var29 += (var26 - var29) * 0.18F;
               }

               this.smoothedLevels[var19] = var29;
               var18[var19] = var29;
            }

            this.publishedLevels = var18;
         }
      }
   }

   private void decayLevels() {
      float[] var1 = null;
      int var2 = 0;
      int var3 = -1110400220;

      while (true) {
         switch (var3) {
            case -2107707152:
               this.smoothedLevels[var2] = this.smoothedLevels[var2] + (0.0F - this.smoothedLevels[var2]) * 0.18F;
               var1[var2] = this.smoothedLevels[var2];
               var2++;
               var3 = -1544765381;
               break;
            case -1751640123:
               this.publishedLevels = var1;
               return;
            case -1544765381:
               if (var2 < (2057910106 ^ -2057910101) + ((2057910106 & -2057910101) << 1)) {
                  var3 = -2107707152;
               } else {
                  var3 = -1751640123;
               }
               break;
            case -1110400220:
            default:
               var1 = new float[5];
               var2 = 0;
               var3 = -1544765381;
         }
      }
   }

   private void resetLevels() {
      Arrays.fill(this.smoothedLevels, 0.0F);
      Arrays.fill(this.bandPeaks, 0.05F);
      this.publishedLevels = new float[5];
      this.inputEnvelope = 0.04F;
   }

   private static void computeFft(float[] var0, float[] var1) {
      for (int var2 = 0; var2 < 1024; var2++) {
         int var3 = BIT_REVERSED[var2];
         if (var3 > var2) {
            float var4 = var0[var2];
            var0[var2] = var0[var3];
            var0[var3] = var4;
            float var5 = var1[var2];
            var1[var2] = var1[var3];
            var1[var3] = var5;
         }
      }

      for (int var14 = 2;
         var14 <= 1024;
         var14 <<= (-936603861 | 936603862) + (-936603861 & 936603862)
      ) {
         int var15 = var14 >> 1;
         int var16 = ((-1737811163 | 1737812187) + (-1737811163 & 1737812187)) / var14;

         for (int var17 = 0;
            var17 < 1024;
            var17 += var14
         ) {
            for (int var6 = 0; var6 < var15; var6++) {
               int var7 = var6 * var16;
               float var8 = COS_TABLE[var7];
               float var9 = SIN_TABLE[var7];
               float var10 = var0[var17 + var6];
               float var11 = var1[var17 + var6];
               float var12 = var0[var17 + var6 + var15] * var8 - var1[var17 + var6 + var15] * var9;
               float var13 = var0[var17 + var6 + var15] * var9 + var1[var17 + var6 + var15] * var8;
               var0[var17 + var6] = var10 + var12;
               var1[var17 + var6] = var11 + var13;
               var0[var17 + var6 + var15] = var10 - var12;
               var1[var17 + var6 + var15] = var11 - var13;
            }
         }
      }
   }

   private static int computeBitReverse(int var0, int var1) {
      int var2 = 0;
      int var3 = 0;
      int var4 = -1596732315;

      while (true) {
         switch (var4) {
            case -1596732315:
            default:
               var2 = 0;
               var3 = 0;
               var4 = -1509337495;
               break;
            case -1509337495:
               if (var3 < var1) {
                  var4 = 320143698;
               } else {
                  var4 = -1225389293;
               }
               break;
            case -1225389293:
               return var2;
            case 320143698:
               var2 = var2 << (-1640340563 | 1640340564) + (-1640340563 & 1640340564) | var0 & 1;
               var0 >>= 1;
               var3++;
               var4 = -1509337495;
         }
      }
   }

   private static void releaseComPointer(Pointer var0) {
      if (var0 != null) {
         try {
            Pointer var1 = var0.getPointer((7827912314614732533L | -7827912314614732533L) + (7827912314614732533L & -7827912314614732533L));
            Function var2 = Function.getFunction(
               var1.getPointer(((-1656930714455703678L ^ 1656930714455703680L) + ((-1656930714455703678L & 1656930714455703680L) << 1)) * Native.POINTER_SIZE),
               (1014697166 | -1014697103) + (1014697166 & -1014697103)
            );
            Object[] var10001 = new Object[1];
            var10001[0] = var0;
            var2.invokeInt(var10001);
         } catch (Throwable var3) {
         }
      }
   }

   private static void sleepQuietly(long var0) {
      try {
         Thread.sleep(var0);
      } catch (InterruptedException var3) {
         Thread.currentThread().interrupt();
      }
   }

   static {
      float[] var10000 = new float[5];
      var10000[0] = 40.0F;
      var10000[1] = 120.0F;
      var10000[2] = 400.0F;
      var10000[3] = 1500.0F;
      var10000[4] = 5000.0F;
      BAND_MIN_FREQS = var10000;
      var10000 = new float[5];
      var10000[0] = 120.0F;
      var10000[1] = 400.0F;
      var10000[2] = 1500.0F;
      var10000[3] = 5000.0F;
      var10000[4] = 20000.0F;
      BAND_MAX_FREQS = var10000;
      var10000 = new float[5];
      var10000[0] = 1.0F;
      var10000[1] = 1.4F;
      var10000[2] = 2.2F;
      var10000[3] = 3.8F;
      var10000[4] = 6.0F;
      BAND_WEIGHTS = var10000;

      for (int var0 = 0; var0 < 1024; var0++) {
         HANN_WINDOW[var0] = (float)(0.5 * (1.0 - Math.cos((Math.PI * 2) * var0 / 1023.0)));
         BIT_REVERSED[var0] = computeBitReverse(var0, (825029969 | -825029959) + (825029969 & -825029959));
      }

      for (int var3 = 0; var3 < 512; var3++) {
         double var1 = (-Math.PI * 2) * var3 / 1024.0;
         COS_TABLE[var3] = (float)Math.cos(var1);
         SIN_TABLE[var3] = (float)Math.sin(var1);
      }
   }

   private static final in INSTANCE = new in();
}