1: //========================================================================================
     2: //  SoundSource.java
     3: //    en:Sound source -- It outputs mixed sound of the frequency modulation sound source and ADPCM sound source while converting the sampling frequency.
     4: //    ja:音源 -- FM音源とADPCM音源を合成してサンプリング周波数を変換しながら出力します。
     5: //  Copyright (C) 2003-2022 Makoto Kamada
     6: //
     7: //  This file is part of the XEiJ (X68000 Emulator in Java).
     8: //  You can use, modify and redistribute the XEiJ if the conditions are met.
     9: //  Read the XEiJ License for more details.
    10: //  https://stdkmd.net/xeij/
    11: //========================================================================================
    12: 
    13: //----------------------------------------------------------------------------------------
    14: //  内部のサンプリング周波数を62500Hzに固定し、周波数を変換しながら出力する
    15: //  音を出さないまたは出せないときも、タイマやレジスタは音が出ているときと同じように機能しなければならない
    16: //
    17: //  参考
    18: //    Java Sound API プログラマーズガイド
    19: //      http://docs.oracle.com/javase/jp/1.3/guide/sound/prog_guide/title.fm.html
    20: //! 非対応。PCMの入力は実装しない
    21: //----------------------------------------------------------------------------------------
    22: 
    23: package xeij;
    24: 
    25: import java.lang.*;  //Boolean,Character,Class,Comparable,Double,Exception,Float,IllegalArgumentException,Integer,Long,Math,Number,Object,Runnable,SecurityException,String,StringBuilder,System
    26: import java.nio.*;  //ByteBuffer,ByteOrder
    27: import java.util.*;  //ArrayList,Arrays,Calendar,GregorianCalendar,HashMap,Map,Map.Entry,Timer,TimerTask,TreeMap
    28: import javax.sound.sampled.*;  //AudioFormat,AudioSystem,DataLine,LineUnavailableException,SourceDataLine
    29: 
    30: public class SoundSource {
    31: 
    32:   //ソースデータライン
    33:   public static final boolean SND_ON = true;  //true=出力する
    34:   public static final int SND_SAMPLE_FREQ = 48000;  //サンプリング周波数(Hz)。22050,44100,48000のいずれか
    35:   public static final int SND_CHANNELS = 2;  //チャンネル数。1=モノラル,2=ステレオ
    36:   public static final int SND_SAMPLE_SHIFT = SND_CHANNELS == 1 ? 1 : 2;  //1サンプルのバイト数のシフトカウント
    37:   public static final int SND_SAMPLE_BYTES = 1 << SND_SAMPLE_SHIFT;  //1サンプルのバイト数
    38:   public static SourceDataLine sndLine;  //出力ライン。null=出力不可。SND_ONのときだけsndLine!=nullになる
    39: 
    40:   //動作モード
    41:   public static boolean sndPlayOn;  //true=出力する。sndLine!=nullのときだけtrueになる
    42: 
    43:   //ブロック
    44:   //  動作単位。1/25秒(0.04秒)ずつ出力する
    45:   //  SND_BLOCK_FREQはXEiJ.TMR_FREQとSND_SAMPLE_FREQとOPM.OPM_SAMPLE_FREQとADPCM.PCM_SAMPLE_FREQをすべて割り切らなければならない
    46:   public static final int SND_BLOCK_FREQ = 25;  //ブロック周波数(Hz)
    47:   public static final long SND_BLOCK_TIME = XEiJ.TMR_FREQ / SND_BLOCK_FREQ;  //1ブロックの時間(XEiJ.TMR_FREQ単位)
    48:   public static final int SND_BLOCK_SAMPLES = SND_SAMPLE_FREQ / SND_BLOCK_FREQ;  //1ブロックのサンプル数。882,1764,1920
    49:   public static final int SND_BLOCK_BYTES = SND_BLOCK_SAMPLES << SND_SAMPLE_SHIFT;  //1ブロックのバイト数
    50: 
    51:   //周波数変換
    52:   //  線形補間
    53:   //    62500Hzのサンプリングデータを線形補間したものを22050Hzまたは44100Hzまたは48000Hzのサンプリング間隔でサンプリングし直す
    54:   //
    55:   //    入力周波数=13Hz,出力周波数=10Hzのとき
    56:   //    aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeffffffffffgggggggggghhhhhhhhhhiiiiiiiiiijjjjjjjjjj 入力データ
    57:   //         01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234 サンプリング位置の端数
    58:   //         0            1            2            3            4            5            6            7    サンプリング位置
    59:   //        a*10       b*7+c*3      c*4+d*6      d*1+e*9      f*8+g*2      g*5+h*5      h*2+i*8      j*9+k*1 出力データ
    60:   //
    61:   public static final boolean SND_FREQ_TABLE = true;  //true=規定の周波数で出力するとき周波数変換テーブルを使う
    62:   public static final boolean SND_INTERPOLATION_ON = true;  //true=62500Hzから規定の周波数に変換するとき線形補間を行う
    63:   public static final int SND_INTERPOLATION_BIT = 8;  //線形補間の分解能。前後のデータに掛ける比率の合計のlog2。入力データが符号付き16bitに収まっていれば15以下だが溢れているとき割れてしまうので小さめにしておく
    64:   public static final int[] sndFreqConvIndex = new int[SND_BLOCK_SAMPLES];  //周波数変換のインデックス。0～OPM.OPM_BLOCK_SAMPLES-1(2500-1)
    65:   public static final int[] sndFreqConvFraction = new int[SND_BLOCK_SAMPLES];  //周波数変換の端数。0～(1<<SND_INTERPOLATION_BIT)-1
    66:   public static SNDRateConverter sndRateConverter;  //サンプリング周波数変換アルゴリズムの選択
    67: 
    68:   //バッファ
    69:   //  バッファを大きくしすぎると音声の遅延(画面とのずれ)が大きくなる
    70:   public static final int SND_BUFFER_SAMPLES = SND_BLOCK_SAMPLES * 3;  //バッファのサンプル数。ブロックの3倍
    71:   public static final int SND_BUFFER_BYTES = SND_BUFFER_SAMPLES << SND_SAMPLE_SHIFT;
    72:   public static final byte[] sndByteBlock = new byte[SND_BUFFER_BYTES];  //ブロックのbyte配列
    73: 
    74:   //タイマー
    75:   public static long sndBlockClock;  //次のブロックを出力する時刻。再生中はSND_BLOCK_TIMEずつ増える。再生開始時刻はSND_BLOCK_TIMEの倍数とは限らない
    76: 
    77:   //エンディアン制御
    78:   //  デフォルトはリトルエンディアン
    79:   //  ByteBufferでエンディアンを制御するときはネイティブのエンディアンになる
    80:   public static final boolean SND_BYTE_BUFFER_ENDIAN = false;  //true=ByteBufferでエンディアンを制御する
    81:   public static ByteOrder sndNativeEndian;  //ネイティブのエンディアン
    82:   public static short[] sndShortBlock;  //ブロックのshort配列
    83:   public static ByteBuffer sndByteBuffer;  //sndByteBlockをラップしたByteBuffer
    84:   public static ShortBuffer sndShortBuffer;  //sndByteBlockをラップしたShortBuffer
    85: 
    86:   //ボリュームコントロール
    87:   //  スピーカに負荷をかけたくないので2倍を上限とする
    88:   //  デフォルトは0.5倍
    89:   //  ボリュームを変更するとき、瞬時に変えるとプチノイズが出るので段階的に変える
    90:   public static final int SND_VOLUME_MAX = 40;  //8倍
    91:   public static final int SND_VOLUME_DEFAULT = 20;  //0.5倍
    92:   public static final int SND_VOLUME_STEP = 5;  //2倍になる差分
    93:   public static int sndVolume;  //ボリュームの設定値。5=1/16倍,10=1/8倍,15=1/4倍,20=1/2倍,25=1倍,30=2倍,35=4倍,40=8倍
    94:   public static int sndCurrentScale;  //ボリュームの現在のスケール。1倍は4096に固定。256=1/16倍,512=1/8倍,1024=1/4倍,2048=1/2倍,4096=1倍,8192=2倍,16384=4倍,32768=8倍
    95:   public static int sndTargetScale;  //ボリュームの変更後のスケール
    96: 
    97:   //ゼロレベルシフト
    98:   //  OPMとPCMの合成後のデータが範囲外のときゼロレベルをシフトしてなるべく音が割れないようにする
    99:   //  PCMを12ビットでマスクする必要があることに変わりはない
   100:   public static final boolean SND_ZERO_LEVEL_SHIFT = false;
   101:   public static int sndAdaptiveShiftM;
   102:   public static int sndAdaptiveShiftL;
   103:   public static int sndAdaptiveShiftR;
   104: 
   105:   //ライン出力
   106:   public static final TickerQueue.Ticker sndBlockTicker = new TickerQueue.Ticker () {
   107:     @Override protected void tick () {
   108:       //OPMのバッファを充填する
   109:       OPM.opmYM2151.generate (SND_CHANNELS * OPM.OPM_BLOCK_SAMPLES);
   110:       //PCMのバッファを充填する
   111:       if (ADPCM.pcmPointer < SND_CHANNELS * ADPCM.PCM_BLOCK_SAMPLES) {
   112:         ADPCM.pcmFillBuffer (SND_CHANNELS * ADPCM.PCM_BLOCK_SAMPLES);
   113:       }
   114:       if ((sndTargetScale | sndCurrentScale) != 0) {  //フェードインとフェードアウトの両方が必要。0以上なのでまとめてテストする
   115:         int outputSamples = SND_BLOCK_SAMPLES;
   116:         //周波数変換
   117:         (SND_FREQ_TABLE && outputSamples == SND_BLOCK_SAMPLES ? sndRateConverter : SNDRateConverter.ADAPTIVE).convert (outputSamples);
   118:         //ラインに出力する
   119:         //  sndLine.available()はバッファアンダーランが起きたとき0を返すことがある
   120:         //  ラインがダミーのデータで充填されているのかも知れない
   121:         //  その状態で出力しようとすると待たされるのでコアと音声出力の両方が止まってしまう
   122:         //  音声出力が止まるのは避けられないがコアを止めたくないので、
   123:         //  sndLine.available()が0を返したときは出力をキャンセルする
   124:         if (sndLine.available () != 0) {
   125:           try {
   126:             long t = System.nanoTime ();
   127:             sndLine.write (sndByteBlock, 0, outputSamples << SND_SAMPLE_SHIFT);
   128:             XEiJ.mpuTotalNano -= System.nanoTime () - t;  //ラインへの出力にかかった時間をコアが消費した時間から除く
   129:           } catch (Exception e) {
   130:           }
   131:         }
   132:       }
   133:       //音声モニタを更新する
   134:       if (SoundMonitor.smnIsVisible) {
   135:         SoundMonitor.smnUpdate ();
   136:       }
   137:       //OPMの出力ポインタを巻き戻す
   138:       OPM.opmYM2151.clear ();
   139:       //PCMの出力ポインタを巻き戻す
   140:       //  はみ出している部分を先頭にコピーするので周波数変換の前に行えない
   141:       ADPCM.pcmPointer = Math.max (0, ADPCM.pcmPointer - SND_CHANNELS * ADPCM.PCM_BLOCK_SAMPLES);
   142:       for (int i = 0; i < ADPCM.pcmPointer; i++) {
   143:         ADPCM.pcmBuffer[i] = ADPCM.pcmBuffer[i + SND_CHANNELS * ADPCM.PCM_BLOCK_SAMPLES];
   144:       }
   145:       //PCMの原発振周波数の切り替えを行う
   146:       if (ADPCM.pcmOSCFreqMode != ADPCM.pcmOSCFreqRequest) {
   147:         ADPCM.pcmOSCFreqMode = ADPCM.pcmOSCFreqRequest;
   148:         ADPCM.pcmUpdateRepeatInterval ();
   149:       }
   150:       //Arrays.fill (ADPCM.pcmBuffer, ADPCM.pcmPointer, SND_CHANNELS * (ADPCM.PCM_BLOCK_SAMPLES + ADPCM.PCM_MAX_REPEAT * 2 - 1), 0);
   151:       //次の割り込み時刻を設定する
   152:       sndBlockClock += SND_BLOCK_TIME;
   153:       TickerQueue.tkqAdd (sndBlockTicker, sndBlockClock);
   154:     }
   155:   };
   156: 
   157:   //PCM出力
   158:   public static final TickerQueue.Ticker sndPcmTicker = new TickerQueue.Ticker () {
   159:     @Override protected void tick () {
   160:       if (ADPCM.pcmEncodedData >= 0) {  //有効なPCMデータがあるとき
   161:         //PCMデータを引き取って変換テーブルの中を移動する
   162:         //  補間したときに中間の値を取れるようにするためにデータを4bitシフトする
   163:         int decoded = (ADPCM.PCM_MODIFY_ZERO_ZERO && (!ADPCM.PCM_MODIFY_ZERO_TWICE || ADPCM.pcmEncodedData == ADPCM.pcmZeroPreviousData) ?
   164:                        ADPCM.pcmDecodedData1 >= 0 ? ADPCM.pcmDecoderTableP : ADPCM.pcmDecoderTableM :
   165:                        ADPCM.pcmDecoderTable)[ADPCM.pcmDecoderPointer << 8 | ADPCM.pcmEncodedData];  //下位の差分<<19|(上位の差分&8191)<<6|次の予測指標
   166:         int delta1 = decoded       >> -13 << 4;  //下位の差分(符号あり13bit)
   167:         int delta2 = decoded << 13 >> -13 << 4;  //上位の差分(符号あり13bit)
   168:         ADPCM.pcmDecoderPointer = decoded & 63;  //次の予測指標(符号なし6bit)
   169:         if (ADPCM.PCM_MODIFY_ZERO_ZERO && ADPCM.PCM_MODIFY_ZERO_TWICE) {
   170:           ADPCM.pcmZeroPreviousData = ADPCM.pcmEncodedData == 0x00 || ADPCM.pcmEncodedData == 0x88 ? ADPCM.pcmEncodedData : -1;
   171:         }
   172:         ADPCM.pcmEncodedData = -1;
   173:         if (false) {  //下位4bitの飽和処理を行わない
   174:           //  クリッピングの範囲が0x8000..0x7ff0ではなく0x8000..0x7fffになる
   175:           int m = ADPCM.pcmDecodedData1 + delta1;
   176:           ADPCM.pcmInterpolationEngine.write ((short) m == m ? m : (m = m >> -1 ^ 32767));
   177:           m += delta2;
   178:           ADPCM.pcmInterpolationEngine.write ((short) m == m ? m :      m >> -1 ^ 32767);
   179:         } else {  //本来の範囲でクリッピングを行う
   180:           int m;
   181:           ADPCM.pcmInterpolationEngine.write (m = Math.max (-2048 << 4, Math.min (2047 << 4, ADPCM.pcmDecodedData1 + delta1)));
   182:           ADPCM.pcmInterpolationEngine.write (    Math.max (-2048 << 4, Math.min (2047 << 4, m               + delta2)));
   183:         }
   184:       } else {  //有効なPCMデータがないとき
   185:         int m = ADPCM.pcmDecodedData1;
   186:         if (ADPCM.PCM_DECAY_ON) {  //減衰させる
   187:           ADPCM.pcmInterpolationEngine.write (m += (m >>> 31) - (-m >>> 31));
   188:           ADPCM.pcmInterpolationEngine.write (m +  (m >>> 31) - (-m >>> 31));
   189:         } else {  //同じデータを繰り返す
   190:           ADPCM.pcmInterpolationEngine.write (m);
   191:           ADPCM.pcmInterpolationEngine.write (m);
   192:         }
   193:       }
   194:       //次の割り込み時刻を設定する
   195:       ADPCM.pcmClock += ADPCM.pcmInterval;
   196:       TickerQueue.tkqAdd (sndPcmTicker, ADPCM.pcmClock);
   197:       //DMAに次のデータを要求する
   198:       HD63450.dmaFallPCL (3);
   199:     }
   200:   };
   201: 
   202:   //sndInit ()
   203:   //  サウンドを初期化する
   204:   public static void sndInit () {
   205:     //ソースデータライン
   206:     sndNativeEndian = ByteOrder.nativeOrder ();
   207:     if (SND_ON) {
   208:       try {
   209:         AudioFormat audioFormat = new AudioFormat ((float) SND_SAMPLE_FREQ,
   210:                                                    16,
   211:                                                    SND_CHANNELS,
   212:                                                    true,
   213:                                                    SND_BYTE_BUFFER_ENDIAN ? sndNativeEndian == ByteOrder.BIG_ENDIAN : false);
   214:         //sndLine = (SourceDataLine) (AudioSystem.getLine (new DataLine.Info (SourceDataLine.class, audioFormat)));
   215:         sndLine = AudioSystem.getSourceDataLine (audioFormat);  //AudioSystem.getSourceDataLine()は1.5から
   216:         sndLine.open (audioFormat, SND_BUFFER_BYTES);
   217:         sndLine.start ();
   218:       } catch (Exception e) {
   219:         sndLine = null;  //出力不可
   220:         sndPlayOn = false;
   221:       }
   222:     } else {
   223:       sndLine = null;  //出力不可
   224:       sndPlayOn = false;
   225:     }
   226:     //ブロック
   227:     //sndByteBlock = new byte[SND_BUFFER_BYTES];
   228:     if (SND_BYTE_BUFFER_ENDIAN) {
   229:       //エンディアン制御
   230:       sndShortBlock = new short[SND_CHANNELS * SND_BUFFER_SAMPLES];
   231:       sndByteBuffer = ByteBuffer.wrap (sndByteBlock);
   232:       sndByteBuffer.order (sndNativeEndian);
   233:       sndShortBuffer = sndByteBuffer.asShortBuffer ();
   234:     }
   235:     //周波数変換
   236:     if (SND_FREQ_TABLE) {
   237:       //sndFreqConvIndex = new int[SND_BLOCK_SAMPLES];
   238:       for (int i = 0; i < SND_BLOCK_SAMPLES; i++) {
   239:         if (!SND_INTERPOLATION_ON) {  //間引き
   240:           sndFreqConvIndex[i] = SND_CHANNELS * i * OPM.OPM_BLOCK_SAMPLES / SND_BLOCK_SAMPLES;
   241:         } else {  //線形補間
   242:           int t = i * OPM.OPM_BLOCK_SAMPLES;  //0～(882-1)*62500,(1764-1)*62500,(1920-1)*62500
   243:           int q = t / SND_BLOCK_SAMPLES;  //サンプリング位置。入力周波数の62500Hzよりも出力周波数の22050Hz,44100Hz,48000Hzの方が小さく、サンプリング位置の最大値が2498になるため、インデックスに1を加えても溢れない
   244:           sndFreqConvIndex[i] = SND_CHANNELS * q;  //インデックス
   245:           sndFreqConvFraction[i] = (t - q * SND_BLOCK_SAMPLES << SND_INTERPOLATION_BIT) / SND_BLOCK_SAMPLES;  //端数
   246:         }
   247:       }
   248:     }
   249:     //sndRateConverter = SND_CHANNELS == 1 ? SNDRateConverter.LINEAR_MONO : SNDRateConverter.LINEAR_STEREO;  //線形補間
   250:     //ボリュームコントロール
   251:     sndCurrentScale = 0;
   252:     sndTargetScale = sndPlayOn && sndVolume > 0 ? (int) (Math.pow (2.0, 12 - 1 + (double) (sndVolume - SND_VOLUME_DEFAULT) / SND_VOLUME_STEP) + 0.5) : 0;
   253:     if (SND_ZERO_LEVEL_SHIFT) {
   254:       //ゼロレベルシフト
   255:       if (SND_CHANNELS == 1) {  //モノラル
   256:         sndAdaptiveShiftM = 0;
   257:       } else {  //ステレオ
   258:         sndAdaptiveShiftL = 0;
   259:         sndAdaptiveShiftR = 0;
   260:       }
   261:     }
   262:   }  //sndInit
   263: 
   264:   //sndTini ()
   265:   //  サウンドの後始末
   266:   //  ラインを閉じる
   267:   public static void sndTini () {
   268:     if (sndLine != null) {
   269:       sndLine.stop ();
   270:       sndLine.close ();
   271:     }
   272:   }  //sndTini()
   273: 
   274:   //sndStart ()
   275:   //  サウンドの動作を開始する
   276:   public static void sndStart () {
   277:     sndReset ();
   278:     OPM.opmReset ();
   279:     ADPCM.pcmReset ();
   280:   }  //sndStart
   281: 
   282:   //リセット
   283:   public static void sndReset () {
   284:     ADPCM.pcmClock = XEiJ.FAR_FUTURE;
   285:     sndBlockClock = XEiJ.mpuClockTime + SND_BLOCK_TIME;
   286:     TickerQueue.tkqRemove (sndPcmTicker);
   287:     TickerQueue.tkqAdd (sndBlockTicker, sndBlockClock);
   288:   }  //sndReset
   289: 
   290:   //sndSetPlayOn (mode)
   291:   //  音声出力
   292:   public static void sndSetPlayOn (boolean on) {
   293:     if (sndLine != null && sndPlayOn != on) {
   294:       if (on) {
   295:         System.out.println (Multilingual.mlnJapanese ?
   296:                             "音声を出力します" :
   297:                             "Sound is output");
   298:       } else {
   299:         System.out.println (Multilingual.mlnJapanese ?
   300:                             "音声を出力しません" :
   301:                             "Sound is not output");
   302:       }
   303:       sndPlayOn = on;
   304:       sndSetVolume (sndVolume);
   305:       //コアが動いていたら再起動する
   306:       if (XEiJ.mpuTask != null) {
   307:         XEiJ.mpuStart ();
   308:       }
   309:     }
   310:   }  //sndSetPlayOn(boolean)
   311: 
   312:   //sndSetVolume (volume)
   313:   //  音量
   314:   public static void sndSetVolume (int volume) {
   315:     sndVolume = Math.max (0, Math.min (SND_VOLUME_MAX, volume));
   316:     sndTargetScale = sndPlayOn && sndVolume > 0 ? (int) (Math.pow (2.0, 12 - 1 + (double) (sndVolume - SND_VOLUME_DEFAULT) / SND_VOLUME_STEP) + 0.5) : 0;
   317:     if (XEiJ.mnbVolumeLabel != null) {
   318:       XEiJ.mnbVolumeLabel.setText (String.valueOf (sndVolume));
   319:     }
   320:   }  //sndSetVolume(int)
   321: 
   322: 
   323: 
   324:   //enum SNDRateConverter
   325:   //  サンプリング周波数変換
   326:   //  入力サンプリング周波数と出力サンプリング周波数が両方高いとどの変換も同じように聞こえる
   327:   public static enum SNDRateConverter {
   328: 
   329:     //規定の周波数で出力しないとき
   330:     ADAPTIVE {
   331:       @Override public void convert (int outputSamples) {
   332:         final int inputSamples = OPM.OPM_BLOCK_SAMPLES;
   333:         int src = 0;
   334:         int dst = 0;
   335:         int balance = (inputSamples >> 1) - outputSamples;
   336:         if (balance >= 0) {
   337:           do {
   338:             src++;
   339:           } while ((balance -= outputSamples) >= 0);
   340:         }
   341:       outputLoop:
   342:         for (;;) {
   343:           if (SND_CHANNELS == 1) {  //モノラル
   344:             int m = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src] + ADPCM.pcmBuffer[src] :
   345:                      OPM.OPM_ON           ? OPM.opmBuffer[src]                  :
   346:                      ADPCM.PCM_ON           ?                  ADPCM.pcmBuffer[src] :
   347:                      0) * sndCurrentScale >> 12;
   348:             if (SND_ZERO_LEVEL_SHIFT) {  //ゼロレベルシフトあり
   349:               m += sndAdaptiveShiftM;
   350:               if ((short) m != m) {  //オーバーフローしたとき
   351:                 int t = m >> 31 ^ 0x7fff;
   352:                 sndAdaptiveShiftM -= m - t;
   353:                 m = t;
   354:               }
   355:               sndAdaptiveShiftM += (sndAdaptiveShiftM >>> 31) - (-sndAdaptiveShiftM >>> 31);
   356:             } else {  //ゼロレベルシフトなし
   357:               m = XEiJ.SHORT_SATURATION_CAST ? (short) m == m ? m : m >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, m));
   358:             }
   359:             do {
   360:               if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   361:                 sndShortBlock[dst] = (short) m;
   362:               } else {  //ByteBufferでエンディアンを制御しないとき
   363:                 int dst2 = dst << 1;
   364:                 sndByteBlock[dst2    ] = (byte) m;
   365:                 sndByteBlock[dst2 + 1] = (byte) (m >> 8);
   366:               }
   367:               sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   368:               dst++;
   369:               if (dst >= outputSamples) {
   370:                 break outputLoop;
   371:               }
   372:             } while ((balance += inputSamples) < 0);
   373:           } else {  //ステレオ
   374:             int src2 = src << 1;
   375:             int l = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src2    ] + ADPCM.pcmBuffer[src2    ] :
   376:                      OPM.OPM_ON           ? OPM.opmBuffer[src2    ]                       :
   377:                      ADPCM.PCM_ON           ?                       ADPCM.pcmBuffer[src2    ] :
   378:                      0) * sndCurrentScale >> 12;
   379:             int r = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src2 + 1] + ADPCM.pcmBuffer[src2 + 1] :
   380:                      OPM.OPM_ON           ? OPM.opmBuffer[src2 + 1]                       :
   381:                      ADPCM.PCM_ON           ?                       ADPCM.pcmBuffer[src2 + 1] :
   382:                      0) * sndCurrentScale >> 12;
   383:             if (SND_ZERO_LEVEL_SHIFT) {  //ゼロレベルシフトあり
   384:               l += sndAdaptiveShiftL;
   385:               r += sndAdaptiveShiftR;
   386:               if ((short) l != l) {  //オーバーフローしたとき
   387:                 int t = l >> 31 ^ 0x7fff;
   388:                 sndAdaptiveShiftL -= l - t;
   389:                 l = t;
   390:               }
   391:               if ((short) r != r) {  //オーバーフローしたとき
   392:                 int t = r >> 31 ^ 0x7fff;
   393:                 sndAdaptiveShiftR -= r - t;
   394:                 r = t;
   395:               }
   396:               sndAdaptiveShiftL += (sndAdaptiveShiftL >>> 31) - (-sndAdaptiveShiftL >>> 31);
   397:               sndAdaptiveShiftR += (sndAdaptiveShiftR >>> 31) - (-sndAdaptiveShiftR >>> 31);
   398:             } else {  //ゼロレベルシフトなし
   399:               l = XEiJ.SHORT_SATURATION_CAST ? (short) l == l ? l : l >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, l));
   400:               r = XEiJ.SHORT_SATURATION_CAST ? (short) r == r ? r : r >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, r));
   401:             }
   402:             do {
   403:               if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   404:                 int dst2 = dst << 1;
   405:                 sndShortBlock[dst2    ] = (short) l;
   406:                 sndShortBlock[dst2 + 1] = (short) r;
   407:               } else {  //ByteBufferでエンディアンを制御しないとき
   408:                 int dst4 = dst << 2;
   409:                 sndByteBlock[dst4    ] = (byte) l;
   410:                 sndByteBlock[dst4 + 1] = (byte) (l >> 8);
   411:                 sndByteBlock[dst4 + 2] = (byte) r;
   412:                 sndByteBlock[dst4 + 3] = (byte) (r >> 8);
   413:               }
   414:               sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   415:               dst++;
   416:               if (dst >= outputSamples) {
   417:                 break outputLoop;
   418:               }
   419:             } while ((balance += inputSamples) < 0);
   420:           }  //if モノラル/ステレオ
   421:           do {
   422:             src++;
   423:           } while ((balance -= outputSamples) >= 0);
   424:         }  //outputLoop
   425:         if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   426:           //sndByteBlockにsndShortBlockを上書きする
   427:           sndShortBuffer.rewind ();
   428:           sndShortBuffer.put (sndShortBlock, 0, outputSamples << SND_SAMPLE_SHIFT - 1);
   429:         }
   430:       }  //convert(int)
   431:     },  //SNDRateConverter.ADAPTIVE
   432: 
   433:     //間引き,モノラル
   434:     THINNING_MONO {
   435:       @Override public void convert (int outputSamples) {
   436:         for (int dst = 0; dst < SND_BLOCK_SAMPLES; dst++) {
   437:           int src = sndFreqConvIndex[dst];
   438:           int m = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src] + ADPCM.pcmBuffer[src] :
   439:                    OPM.OPM_ON           ? OPM.opmBuffer[src]                  :
   440:                    ADPCM.PCM_ON           ?                  ADPCM.pcmBuffer[src] :
   441:                    0) * sndCurrentScale >> 12;
   442:           if (SND_ZERO_LEVEL_SHIFT) {  //ゼロレベルシフトあり
   443:             m += sndAdaptiveShiftM;
   444:             if ((short) m != m) {  //オーバーフローしたとき
   445:               int t = m >> 31 ^ 0x7fff;
   446:               sndAdaptiveShiftM -= m - t;
   447:               m = t;
   448:             }
   449:             sndAdaptiveShiftM += (sndAdaptiveShiftM >>> 31) - (-sndAdaptiveShiftM >>> 31);
   450:           } else {  //ゼロレベルシフトなし
   451:             m = XEiJ.SHORT_SATURATION_CAST ? (short) m == m ? m : m >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, m));
   452:           }
   453:           if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   454:             sndShortBlock[dst] = (short) m;
   455:           } else {  //ByteBufferでエンディアンを制御しないとき
   456:             int dst2 = dst << 1;
   457:             sndByteBlock[dst2    ] = (byte) m;
   458:             sndByteBlock[dst2 + 1] = (byte) (m >> 8);
   459:           }
   460:           sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   461:         }  //for dst
   462:         if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   463:           //sndByteBlockにsndShortBlockを上書きする
   464:           sndShortBuffer.rewind ();
   465:           sndShortBuffer.put (sndShortBlock, 0, outputSamples << SND_SAMPLE_SHIFT - 1);
   466:         }
   467:       }  //convert(int)
   468:     },  //SNDRateConverter.THINNING_MONO
   469: 
   470:     //間引き,ステレオ
   471:     THINNING_STEREO {
   472:       @Override public void convert (int outputSamples) {
   473:         for (int dst = 0; dst < SND_BLOCK_SAMPLES; dst++) {
   474:           int src = sndFreqConvIndex[dst];
   475:           int l = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src    ] + ADPCM.pcmBuffer[src    ] :
   476:                    OPM.OPM_ON           ? OPM.opmBuffer[src    ]                      :
   477:                    ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src    ] :
   478:                    0) * sndCurrentScale >> 12;
   479:           int r = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src + 1] + ADPCM.pcmBuffer[src + 1] :
   480:                    OPM.OPM_ON           ? OPM.opmBuffer[src + 1]                      :
   481:                    ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src + 1] :
   482:                    0) * sndCurrentScale >> 12;
   483:           if (SND_ZERO_LEVEL_SHIFT) {  //ゼロレベルシフトあり
   484:             l += sndAdaptiveShiftL;
   485:             r += sndAdaptiveShiftR;
   486:             if ((short) l != l) {  //オーバーフローしたとき
   487:               int t = l >> 31 ^ 0x7fff;
   488:               sndAdaptiveShiftL -= l - t;
   489:               l = t;
   490:             }
   491:             if ((short) r != r) {  //オーバーフローしたとき
   492:               int t = r >> 31 ^ 0x7fff;
   493:               sndAdaptiveShiftR -= r - t;
   494:               r = t;
   495:             }
   496:             sndAdaptiveShiftL += (sndAdaptiveShiftL >>> 31) - (-sndAdaptiveShiftL >>> 31);
   497:             sndAdaptiveShiftR += (sndAdaptiveShiftR >>> 31) - (-sndAdaptiveShiftR >>> 31);
   498:           } else {  //ゼロレベルシフトなし
   499:             l = XEiJ.SHORT_SATURATION_CAST ? (short) l == l ? l : l >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, l));
   500:             r = XEiJ.SHORT_SATURATION_CAST ? (short) r == r ? r : r >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, r));
   501:           }
   502:           if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   503:             int dst2 = dst << 1;
   504:             sndShortBlock[dst2    ] = (short) l;
   505:             sndShortBlock[dst2 + 1] = (short) r;
   506:           } else {  //ByteBufferでエンディアンを制御しないとき
   507:             int dst4 = dst << 2;
   508:             sndByteBlock[dst4    ] = (byte) l;
   509:             sndByteBlock[dst4 + 1] = (byte) (l >> 8);
   510:             sndByteBlock[dst4 + 2] = (byte) r;
   511:             sndByteBlock[dst4 + 3] = (byte) (r >> 8);
   512:           }
   513:           sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   514:         }  //for dst
   515:         if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   516:           //sndByteBlockにsndShortBlockを上書きする
   517:           sndShortBuffer.rewind ();
   518:           sndShortBuffer.put (sndShortBlock, 0, outputSamples << SND_SAMPLE_SHIFT - 1);
   519:         }
   520:       }  //convert(int)
   521:     },  //SNDRateConverter.THINNING_STEREO
   522: 
   523:     //線形補間,モノラル
   524:     LINEAR_MONO {
   525:       @Override public void convert (int outputSamples) {
   526:         for (int dst = 0; dst < SND_BLOCK_SAMPLES; dst++) {
   527:           int src = sndFreqConvIndex[dst];
   528:           int rat2 = sndFreqConvFraction[dst];
   529:           int rat1 = (1 << SND_INTERPOLATION_BIT) - rat2;
   530:           int m = ((OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src    ] + ADPCM.pcmBuffer[src    ] :
   531:                     OPM.OPM_ON           ? OPM.opmBuffer[src    ]                      :
   532:                     ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src    ] :
   533:                     0) * rat1 +
   534:                    (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src + 1] + ADPCM.pcmBuffer[src + 1] :
   535:                     OPM.OPM_ON           ? OPM.opmBuffer[src + 1]                      :
   536:                     ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src + 1] :
   537:                     0) * rat2 >> SND_INTERPOLATION_BIT) * sndCurrentScale >> 12;
   538:           if (SND_ZERO_LEVEL_SHIFT) {  //ゼロレベルシフトあり
   539:             m += sndAdaptiveShiftM;
   540:             if ((short) m != m) {  //オーバーフローしたとき
   541:               int t = m >> 31 ^ 0x7fff;
   542:               sndAdaptiveShiftM -= m - t;
   543:               m = t;
   544:             }
   545:             sndAdaptiveShiftM += (sndAdaptiveShiftM >>> 31) - (-sndAdaptiveShiftM >>> 31);
   546:           } else {  //ゼロレベルシフトなし
   547:             m = XEiJ.SHORT_SATURATION_CAST ? (short) m == m ? m : m >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, m));
   548:           }
   549:           if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   550:             sndShortBlock[dst] = (short) m;
   551:           } else {  //ByteBufferでエンディアンを制御しないとき
   552:             int dst2 = dst << 1;
   553:             sndByteBlock[dst2    ] = (byte) m;
   554:             sndByteBlock[dst2 + 1] = (byte) (m >> 8);
   555:           }
   556:           sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   557:         }  //for dst
   558:         if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   559:           //sndByteBlockにsndShortBlockを上書きする
   560:           sndShortBuffer.rewind ();
   561:           sndShortBuffer.put (sndShortBlock, 0, outputSamples << SND_SAMPLE_SHIFT - 1);
   562:         }
   563:       }  //convert(int)
   564:     },  //SNDRateConverter.LINEAR_MONO
   565: 
   566:     //線形補間,ステレオ
   567:     LINEAR_STEREO {
   568:       @Override public void convert (int outputSamples) {
   569:         for (int dst = 0; dst < SND_BLOCK_SAMPLES; dst++) {
   570:           int src2 = sndFreqConvIndex[dst];
   571:           int rat2 = sndFreqConvFraction[dst];
   572:           int rat1 = (1 << SND_INTERPOLATION_BIT) - rat2;
   573:           int l = ((OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src2    ] + ADPCM.pcmBuffer[src2    ] :
   574:                     OPM.OPM_ON           ? OPM.opmBuffer[src2    ]                       :
   575:                     ADPCM.PCM_ON           ?                       ADPCM.pcmBuffer[src2    ] :
   576:                     0) * rat1 +
   577:                    (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src2 + 2] + ADPCM.pcmBuffer[src2 + 2] :
   578:                     OPM.OPM_ON           ? OPM.opmBuffer[src2 + 2]                       :
   579:                     ADPCM.PCM_ON           ?                       ADPCM.pcmBuffer[src2 + 2] :
   580:                     0) * rat2 >> SND_INTERPOLATION_BIT) * sndCurrentScale >> 12;
   581:           int r = ((OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src2 + 1] + ADPCM.pcmBuffer[src2 + 1] :
   582:                     OPM.OPM_ON           ? OPM.opmBuffer[src2 + 1]                       :
   583:                     ADPCM.PCM_ON           ?                       ADPCM.pcmBuffer[src2 + 1] :
   584:                     0) * rat1 +
   585:                    (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src2 + 3] + ADPCM.pcmBuffer[src2 + 3] :
   586:                     OPM.OPM_ON           ? OPM.opmBuffer[src2 + 3]                       :
   587:                     ADPCM.PCM_ON           ?                       ADPCM.pcmBuffer[src2 + 3] :
   588:                     0) * rat2 >> SND_INTERPOLATION_BIT) * sndCurrentScale >> 12;
   589:           if (SND_ZERO_LEVEL_SHIFT) {  //ゼロレベルシフトあり
   590:             l += sndAdaptiveShiftL;
   591:             r += sndAdaptiveShiftR;
   592:             if ((short) l != l) {  //オーバーフローしたとき
   593:               int t = l >> 31 ^ 0x7fff;
   594:               sndAdaptiveShiftL -= l - t;
   595:               l = t;
   596:             }
   597:             if ((short) r != r) {  //オーバーフローしたとき
   598:               int t = r >> 31 ^ 0x7fff;
   599:               sndAdaptiveShiftR -= r - t;
   600:               r = t;
   601:             }
   602:             sndAdaptiveShiftL += (sndAdaptiveShiftL >>> 31) - (-sndAdaptiveShiftL >>> 31);
   603:             sndAdaptiveShiftR += (sndAdaptiveShiftR >>> 31) - (-sndAdaptiveShiftR >>> 31);
   604:           } else {  //ゼロレベルシフトなし
   605:             l = XEiJ.SHORT_SATURATION_CAST ? (short) l == l ? l : l >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, l));
   606:             r = XEiJ.SHORT_SATURATION_CAST ? (short) r == r ? r : r >> 31 ^ 32767 : Math.max (-32768, Math.min (32767, r));
   607:           }
   608:           if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   609:             int dst2 = dst << 1;
   610:             sndShortBlock[dst2    ] = (short) l;
   611:             sndShortBlock[dst2 + 1] = (short) r;
   612:           } else {  //ByteBufferでエンディアンを制御しないとき
   613:             int dst4 = dst << 2;
   614:             sndByteBlock[dst4    ] = (byte) l;
   615:             sndByteBlock[dst4 + 1] = (byte) (l >> 8);
   616:             sndByteBlock[dst4 + 2] = (byte) r;
   617:             sndByteBlock[dst4 + 3] = (byte) (r >> 8);
   618:           }
   619:           sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   620:         }  //for dst
   621:         if (SND_BYTE_BUFFER_ENDIAN) {  //ByteBufferでエンディアンを制御するとき
   622:           //sndByteBlockにsndShortBlockを上書きする
   623:           sndShortBuffer.rewind ();
   624:           sndShortBuffer.put (sndShortBlock, 0, outputSamples << SND_SAMPLE_SHIFT - 1);
   625:         }
   626:       }  //convert(int)
   627:     },  //SNDRateConverter.LINEAR_STEREO
   628: 
   629:     //区分定数面積補間
   630:     //  入力データを区分定数補間した波形を出力サンプリング間隔で刻み、各断片の平均の変位(断片の面積に比例する)を出力データとする
   631:     //  出力周波数が入力周波数の1/2倍～1倍のとき、1個の出力データを求めるために2個または3個の入力データが必要になる
   632:     //  7Hz→5Hzの場合
   633:     //    aaaaabbbbbcccccdddddeeeeefffffggggg
   634:     //    AAAAAAABBBBBBBCCCCCCCDDDDDDDEEEEEEE
   635:     //      A=(5*a+2*b)/7
   636:     //      B=(3*b+4*c)/7
   637:     //      C=(1*c+5*d+1*e)/7
   638:     //      D=(4*e+3*f)/7
   639:     //      E=(2*f+5*g)/7
   640:     //    perl -e "$m=7;$n=5;$k=0;for$i(0..$n-1){$j0=int($i*$m/$n);$c0=$n-$i*$m+$j0*$n;$c1=$m-$c0;if($c1>$n){$c2=$c1-$n;$c1=$n}elsif($c0<=$c1){$c2=0}else{$c2=$c1;$c1=$c0;$c0=0;$j0--}printf'    //      d[%2d] = (',$i;if($c0){if($c0==1){print'    '}else{printf'%2d *',$c0};printf' s[%3d] +',$j0}else{print'             '};printf' %2d * s[%3d] ',$c1,$j0+1;if($c2){print'+ ';if($c2==1){print'    '}else{printf'%2d *',$c2};printf' s[%3d]',$j0+2}else{print'             '};printf') / %d;%c',$m,10}"
   641:     //      d[ 0] = (               5 * s[  0] +  2 * s[  1]) / 7;
   642:     //      d[ 1] = ( 3 * s[  1] +  4 * s[  2]              ) / 7;
   643:     //      d[ 2] = (     s[  2] +  5 * s[  3] +      s[  4]) / 7;
   644:     //      d[ 3] = (               4 * s[  4] +  3 * s[  5]) / 7;
   645:     //      d[ 4] = ( 2 * s[  5] +  5 * s[  6]              ) / 7;
   646: 
   647:     //区分定数面積補間,ステレオ,48kHz
   648:     CONSTANT_AREA_STEREO_48000 {
   649:       @Override public void convert (int outputSamples) {
   650:         //OPMとPCMを合わせてボリュームを掛ける
   651:         for (int src = 0; src < 2 * OPM.OPM_BLOCK_SAMPLES; src += 2) {
   652:           OPM.opmBuffer[src    ] = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src    ] + ADPCM.pcmBuffer[src    ] :
   653:                                 OPM.OPM_ON           ? OPM.opmBuffer[src    ]                      :
   654:                                 ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src    ] :
   655:                                 0) * sndCurrentScale >> 12;
   656:           OPM.opmBuffer[src + 1] = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src + 1] + ADPCM.pcmBuffer[src + 1] :
   657:                                 OPM.OPM_ON           ? OPM.opmBuffer[src + 1]                      :
   658:                                 ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src + 1] :
   659:                                 0) * sndCurrentScale >> 12;
   660:         }
   661:         //区分定数面積補間
   662:         //  通分したときの分母は125だが、125≒128=1<<7なので、125で割る代わりに右7bitシフトで済ませている
   663:         //  本来の値よりもわずかに小さい値(125/128倍)が出力される
   664:         for (int src = 0, dst = 0; src < 2 * OPM.OPM_BLOCK_SAMPLES; src += 2 * 125, dst += 4 * 96) {
   665:           int l, r;
   666:                 //  perl -e "$m=125;$n=96;$k=0;for$i(0..$n-1){$j0=int($i*$m/$n);$c0=$n-$i*$m+$j0*$n;$c1=$m-$c0;if($c1>$n){$c2=$c1-$n;$c1=$n}elsif($c0<=$c1){$c2=0}else{$c2=$c1;$c1=$c0;$c0=0;$j0--}printf'%16sl = Math.max (-32768, Math.min (32767, ','',$i;if($c0){if($c0==1){print'    '}else{printf'%2d *',$c0};printf' OPM.opmBuffer[src + %3d] +',$j0<<1|0}else{printf'%27s',''};printf' %2d * OPM.opmBuffer[src + %3d] ',$c1,$j0+1<<1|0;if($c2){print'+ ';if($c2==1){print'    '}else{printf'%2d *',$c2};printf' OPM.opmBuffer[src + %3d]',$j0+2<<1|0}else{printf'%27s',''};printf' + 64 >> 7));%c',10;printf'%16sr = Math.max (-32768, Math.min (32767, ','',$i;if($c0){if($c0==1){print'    '}else{printf'%2d *',$c0};printf' OPM.opmBuffer[src + %3d] +',$j0<<1|1}else{printf'%27s',''};printf' %2d * OPM.opmBuffer[src + %3d] ',$c1,$j0+1<<1|1;if($c2){print'+ ';if($c2==1){print'    '}else{printf'%2d *',$c2};printf' OPM.opmBuffer[src + %3d]',$j0+2<<1|1}else{printf'%27s',''};printf' + 64 >> 7));%c',10;printf'%16ssndByteBlock[dst + %2d] = (byte) l;%c','',$i<<2|0,10;printf'%16ssndByteBlock[dst + %2d] = (byte) (l >> 8);%c','',$i<<2|1,10;printf'%16ssndByteBlock[dst + %2d] = (byte) r;%c','',$i<<2|2,10;printf'%16ssndByteBlock[dst + %2d] = (byte) (r >> 8);%c','',$i<<2|3,10;printf'%16ssndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);%c','',10}"
   667:                 l = Math.max (-32768, Math.min (32767,                             96 * OPM.opmBuffer[src +   0] + 29 * OPM.opmBuffer[src +   2] + 64 >> 7));
   668:                 r = Math.max (-32768, Math.min (32767,                             96 * OPM.opmBuffer[src +   1] + 29 * OPM.opmBuffer[src +   3] + 64 >> 7));
   669:                 sndByteBlock[dst +  0] = (byte) l;
   670:                 sndByteBlock[dst +  1] = (byte) (l >> 8);
   671:                 sndByteBlock[dst +  2] = (byte) r;
   672:                 sndByteBlock[dst +  3] = (byte) (r >> 8);
   673:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   674:                 l = Math.max (-32768, Math.min (32767,                             67 * OPM.opmBuffer[src +   2] + 58 * OPM.opmBuffer[src +   4] + 64 >> 7));
   675:                 r = Math.max (-32768, Math.min (32767,                             67 * OPM.opmBuffer[src +   3] + 58 * OPM.opmBuffer[src +   5] + 64 >> 7));
   676:                 sndByteBlock[dst +  4] = (byte) l;
   677:                 sndByteBlock[dst +  5] = (byte) (l >> 8);
   678:                 sndByteBlock[dst +  6] = (byte) r;
   679:                 sndByteBlock[dst +  7] = (byte) (r >> 8);
   680:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   681:                 l = Math.max (-32768, Math.min (32767, 38 * OPM.opmBuffer[src +   4] + 87 * OPM.opmBuffer[src +   6]                             + 64 >> 7));
   682:                 r = Math.max (-32768, Math.min (32767, 38 * OPM.opmBuffer[src +   5] + 87 * OPM.opmBuffer[src +   7]                             + 64 >> 7));
   683:                 sndByteBlock[dst +  8] = (byte) l;
   684:                 sndByteBlock[dst +  9] = (byte) (l >> 8);
   685:                 sndByteBlock[dst + 10] = (byte) r;
   686:                 sndByteBlock[dst + 11] = (byte) (r >> 8);
   687:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   688:                 l = Math.max (-32768, Math.min (32767,  9 * OPM.opmBuffer[src +   6] + 96 * OPM.opmBuffer[src +   8] + 20 * OPM.opmBuffer[src +  10] + 64 >> 7));
   689:                 r = Math.max (-32768, Math.min (32767,  9 * OPM.opmBuffer[src +   7] + 96 * OPM.opmBuffer[src +   9] + 20 * OPM.opmBuffer[src +  11] + 64 >> 7));
   690:                 sndByteBlock[dst + 12] = (byte) l;
   691:                 sndByteBlock[dst + 13] = (byte) (l >> 8);
   692:                 sndByteBlock[dst + 14] = (byte) r;
   693:                 sndByteBlock[dst + 15] = (byte) (r >> 8);
   694:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   695:                 l = Math.max (-32768, Math.min (32767,                             76 * OPM.opmBuffer[src +  10] + 49 * OPM.opmBuffer[src +  12] + 64 >> 7));
   696:                 r = Math.max (-32768, Math.min (32767,                             76 * OPM.opmBuffer[src +  11] + 49 * OPM.opmBuffer[src +  13] + 64 >> 7));
   697:                 sndByteBlock[dst + 16] = (byte) l;
   698:                 sndByteBlock[dst + 17] = (byte) (l >> 8);
   699:                 sndByteBlock[dst + 18] = (byte) r;
   700:                 sndByteBlock[dst + 19] = (byte) (r >> 8);
   701:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   702:                 l = Math.max (-32768, Math.min (32767, 47 * OPM.opmBuffer[src +  12] + 78 * OPM.opmBuffer[src +  14]                             + 64 >> 7));
   703:                 r = Math.max (-32768, Math.min (32767, 47 * OPM.opmBuffer[src +  13] + 78 * OPM.opmBuffer[src +  15]                             + 64 >> 7));
   704:                 sndByteBlock[dst + 20] = (byte) l;
   705:                 sndByteBlock[dst + 21] = (byte) (l >> 8);
   706:                 sndByteBlock[dst + 22] = (byte) r;
   707:                 sndByteBlock[dst + 23] = (byte) (r >> 8);
   708:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   709:                 l = Math.max (-32768, Math.min (32767, 18 * OPM.opmBuffer[src +  14] + 96 * OPM.opmBuffer[src +  16] + 11 * OPM.opmBuffer[src +  18] + 64 >> 7));
   710:                 r = Math.max (-32768, Math.min (32767, 18 * OPM.opmBuffer[src +  15] + 96 * OPM.opmBuffer[src +  17] + 11 * OPM.opmBuffer[src +  19] + 64 >> 7));
   711:                 sndByteBlock[dst + 24] = (byte) l;
   712:                 sndByteBlock[dst + 25] = (byte) (l >> 8);
   713:                 sndByteBlock[dst + 26] = (byte) r;
   714:                 sndByteBlock[dst + 27] = (byte) (r >> 8);
   715:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   716:                 l = Math.max (-32768, Math.min (32767,                             85 * OPM.opmBuffer[src +  18] + 40 * OPM.opmBuffer[src +  20] + 64 >> 7));
   717:                 r = Math.max (-32768, Math.min (32767,                             85 * OPM.opmBuffer[src +  19] + 40 * OPM.opmBuffer[src +  21] + 64 >> 7));
   718:                 sndByteBlock[dst + 28] = (byte) l;
   719:                 sndByteBlock[dst + 29] = (byte) (l >> 8);
   720:                 sndByteBlock[dst + 30] = (byte) r;
   721:                 sndByteBlock[dst + 31] = (byte) (r >> 8);
   722:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   723:                 l = Math.max (-32768, Math.min (32767, 56 * OPM.opmBuffer[src +  20] + 69 * OPM.opmBuffer[src +  22]                             + 64 >> 7));
   724:                 r = Math.max (-32768, Math.min (32767, 56 * OPM.opmBuffer[src +  21] + 69 * OPM.opmBuffer[src +  23]                             + 64 >> 7));
   725:                 sndByteBlock[dst + 32] = (byte) l;
   726:                 sndByteBlock[dst + 33] = (byte) (l >> 8);
   727:                 sndByteBlock[dst + 34] = (byte) r;
   728:                 sndByteBlock[dst + 35] = (byte) (r >> 8);
   729:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   730:                 l = Math.max (-32768, Math.min (32767, 27 * OPM.opmBuffer[src +  22] + 96 * OPM.opmBuffer[src +  24] +  2 * OPM.opmBuffer[src +  26] + 64 >> 7));
   731:                 r = Math.max (-32768, Math.min (32767, 27 * OPM.opmBuffer[src +  23] + 96 * OPM.opmBuffer[src +  25] +  2 * OPM.opmBuffer[src +  27] + 64 >> 7));
   732:                 sndByteBlock[dst + 36] = (byte) l;
   733:                 sndByteBlock[dst + 37] = (byte) (l >> 8);
   734:                 sndByteBlock[dst + 38] = (byte) r;
   735:                 sndByteBlock[dst + 39] = (byte) (r >> 8);
   736:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   737:                 l = Math.max (-32768, Math.min (32767,                             94 * OPM.opmBuffer[src +  26] + 31 * OPM.opmBuffer[src +  28] + 64 >> 7));
   738:                 r = Math.max (-32768, Math.min (32767,                             94 * OPM.opmBuffer[src +  27] + 31 * OPM.opmBuffer[src +  29] + 64 >> 7));
   739:                 sndByteBlock[dst + 40] = (byte) l;
   740:                 sndByteBlock[dst + 41] = (byte) (l >> 8);
   741:                 sndByteBlock[dst + 42] = (byte) r;
   742:                 sndByteBlock[dst + 43] = (byte) (r >> 8);
   743:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   744:                 l = Math.max (-32768, Math.min (32767,                             65 * OPM.opmBuffer[src +  28] + 60 * OPM.opmBuffer[src +  30] + 64 >> 7));
   745:                 r = Math.max (-32768, Math.min (32767,                             65 * OPM.opmBuffer[src +  29] + 60 * OPM.opmBuffer[src +  31] + 64 >> 7));
   746:                 sndByteBlock[dst + 44] = (byte) l;
   747:                 sndByteBlock[dst + 45] = (byte) (l >> 8);
   748:                 sndByteBlock[dst + 46] = (byte) r;
   749:                 sndByteBlock[dst + 47] = (byte) (r >> 8);
   750:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   751:                 l = Math.max (-32768, Math.min (32767, 36 * OPM.opmBuffer[src +  30] + 89 * OPM.opmBuffer[src +  32]                             + 64 >> 7));
   752:                 r = Math.max (-32768, Math.min (32767, 36 * OPM.opmBuffer[src +  31] + 89 * OPM.opmBuffer[src +  33]                             + 64 >> 7));
   753:                 sndByteBlock[dst + 48] = (byte) l;
   754:                 sndByteBlock[dst + 49] = (byte) (l >> 8);
   755:                 sndByteBlock[dst + 50] = (byte) r;
   756:                 sndByteBlock[dst + 51] = (byte) (r >> 8);
   757:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   758:                 l = Math.max (-32768, Math.min (32767,  7 * OPM.opmBuffer[src +  32] + 96 * OPM.opmBuffer[src +  34] + 22 * OPM.opmBuffer[src +  36] + 64 >> 7));
   759:                 r = Math.max (-32768, Math.min (32767,  7 * OPM.opmBuffer[src +  33] + 96 * OPM.opmBuffer[src +  35] + 22 * OPM.opmBuffer[src +  37] + 64 >> 7));
   760:                 sndByteBlock[dst + 52] = (byte) l;
   761:                 sndByteBlock[dst + 53] = (byte) (l >> 8);
   762:                 sndByteBlock[dst + 54] = (byte) r;
   763:                 sndByteBlock[dst + 55] = (byte) (r >> 8);
   764:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   765:                 l = Math.max (-32768, Math.min (32767,                             74 * OPM.opmBuffer[src +  36] + 51 * OPM.opmBuffer[src +  38] + 64 >> 7));
   766:                 r = Math.max (-32768, Math.min (32767,                             74 * OPM.opmBuffer[src +  37] + 51 * OPM.opmBuffer[src +  39] + 64 >> 7));
   767:                 sndByteBlock[dst + 56] = (byte) l;
   768:                 sndByteBlock[dst + 57] = (byte) (l >> 8);
   769:                 sndByteBlock[dst + 58] = (byte) r;
   770:                 sndByteBlock[dst + 59] = (byte) (r >> 8);
   771:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   772:                 l = Math.max (-32768, Math.min (32767, 45 * OPM.opmBuffer[src +  38] + 80 * OPM.opmBuffer[src +  40]                             + 64 >> 7));
   773:                 r = Math.max (-32768, Math.min (32767, 45 * OPM.opmBuffer[src +  39] + 80 * OPM.opmBuffer[src +  41]                             + 64 >> 7));
   774:                 sndByteBlock[dst + 60] = (byte) l;
   775:                 sndByteBlock[dst + 61] = (byte) (l >> 8);
   776:                 sndByteBlock[dst + 62] = (byte) r;
   777:                 sndByteBlock[dst + 63] = (byte) (r >> 8);
   778:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   779:                 l = Math.max (-32768, Math.min (32767, 16 * OPM.opmBuffer[src +  40] + 96 * OPM.opmBuffer[src +  42] + 13 * OPM.opmBuffer[src +  44] + 64 >> 7));
   780:                 r = Math.max (-32768, Math.min (32767, 16 * OPM.opmBuffer[src +  41] + 96 * OPM.opmBuffer[src +  43] + 13 * OPM.opmBuffer[src +  45] + 64 >> 7));
   781:                 sndByteBlock[dst + 64] = (byte) l;
   782:                 sndByteBlock[dst + 65] = (byte) (l >> 8);
   783:                 sndByteBlock[dst + 66] = (byte) r;
   784:                 sndByteBlock[dst + 67] = (byte) (r >> 8);
   785:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   786:                 l = Math.max (-32768, Math.min (32767,                             83 * OPM.opmBuffer[src +  44] + 42 * OPM.opmBuffer[src +  46] + 64 >> 7));
   787:                 r = Math.max (-32768, Math.min (32767,                             83 * OPM.opmBuffer[src +  45] + 42 * OPM.opmBuffer[src +  47] + 64 >> 7));
   788:                 sndByteBlock[dst + 68] = (byte) l;
   789:                 sndByteBlock[dst + 69] = (byte) (l >> 8);
   790:                 sndByteBlock[dst + 70] = (byte) r;
   791:                 sndByteBlock[dst + 71] = (byte) (r >> 8);
   792:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   793:                 l = Math.max (-32768, Math.min (32767, 54 * OPM.opmBuffer[src +  46] + 71 * OPM.opmBuffer[src +  48]                             + 64 >> 7));
   794:                 r = Math.max (-32768, Math.min (32767, 54 * OPM.opmBuffer[src +  47] + 71 * OPM.opmBuffer[src +  49]                             + 64 >> 7));
   795:                 sndByteBlock[dst + 72] = (byte) l;
   796:                 sndByteBlock[dst + 73] = (byte) (l >> 8);
   797:                 sndByteBlock[dst + 74] = (byte) r;
   798:                 sndByteBlock[dst + 75] = (byte) (r >> 8);
   799:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   800:                 l = Math.max (-32768, Math.min (32767, 25 * OPM.opmBuffer[src +  48] + 96 * OPM.opmBuffer[src +  50] +  4 * OPM.opmBuffer[src +  52] + 64 >> 7));
   801:                 r = Math.max (-32768, Math.min (32767, 25 * OPM.opmBuffer[src +  49] + 96 * OPM.opmBuffer[src +  51] +  4 * OPM.opmBuffer[src +  53] + 64 >> 7));
   802:                 sndByteBlock[dst + 76] = (byte) l;
   803:                 sndByteBlock[dst + 77] = (byte) (l >> 8);
   804:                 sndByteBlock[dst + 78] = (byte) r;
   805:                 sndByteBlock[dst + 79] = (byte) (r >> 8);
   806:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   807:                 l = Math.max (-32768, Math.min (32767,                             92 * OPM.opmBuffer[src +  52] + 33 * OPM.opmBuffer[src +  54] + 64 >> 7));
   808:                 r = Math.max (-32768, Math.min (32767,                             92 * OPM.opmBuffer[src +  53] + 33 * OPM.opmBuffer[src +  55] + 64 >> 7));
   809:                 sndByteBlock[dst + 80] = (byte) l;
   810:                 sndByteBlock[dst + 81] = (byte) (l >> 8);
   811:                 sndByteBlock[dst + 82] = (byte) r;
   812:                 sndByteBlock[dst + 83] = (byte) (r >> 8);
   813:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   814:                 l = Math.max (-32768, Math.min (32767,                             63 * OPM.opmBuffer[src +  54] + 62 * OPM.opmBuffer[src +  56] + 64 >> 7));
   815:                 r = Math.max (-32768, Math.min (32767,                             63 * OPM.opmBuffer[src +  55] + 62 * OPM.opmBuffer[src +  57] + 64 >> 7));
   816:                 sndByteBlock[dst + 84] = (byte) l;
   817:                 sndByteBlock[dst + 85] = (byte) (l >> 8);
   818:                 sndByteBlock[dst + 86] = (byte) r;
   819:                 sndByteBlock[dst + 87] = (byte) (r >> 8);
   820:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   821:                 l = Math.max (-32768, Math.min (32767, 34 * OPM.opmBuffer[src +  56] + 91 * OPM.opmBuffer[src +  58]                             + 64 >> 7));
   822:                 r = Math.max (-32768, Math.min (32767, 34 * OPM.opmBuffer[src +  57] + 91 * OPM.opmBuffer[src +  59]                             + 64 >> 7));
   823:                 sndByteBlock[dst + 88] = (byte) l;
   824:                 sndByteBlock[dst + 89] = (byte) (l >> 8);
   825:                 sndByteBlock[dst + 90] = (byte) r;
   826:                 sndByteBlock[dst + 91] = (byte) (r >> 8);
   827:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   828:                 l = Math.max (-32768, Math.min (32767,  5 * OPM.opmBuffer[src +  58] + 96 * OPM.opmBuffer[src +  60] + 24 * OPM.opmBuffer[src +  62] + 64 >> 7));
   829:                 r = Math.max (-32768, Math.min (32767,  5 * OPM.opmBuffer[src +  59] + 96 * OPM.opmBuffer[src +  61] + 24 * OPM.opmBuffer[src +  63] + 64 >> 7));
   830:                 sndByteBlock[dst + 92] = (byte) l;
   831:                 sndByteBlock[dst + 93] = (byte) (l >> 8);
   832:                 sndByteBlock[dst + 94] = (byte) r;
   833:                 sndByteBlock[dst + 95] = (byte) (r >> 8);
   834:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   835:                 l = Math.max (-32768, Math.min (32767,                             72 * OPM.opmBuffer[src +  62] + 53 * OPM.opmBuffer[src +  64] + 64 >> 7));
   836:                 r = Math.max (-32768, Math.min (32767,                             72 * OPM.opmBuffer[src +  63] + 53 * OPM.opmBuffer[src +  65] + 64 >> 7));
   837:                 sndByteBlock[dst + 96] = (byte) l;
   838:                 sndByteBlock[dst + 97] = (byte) (l >> 8);
   839:                 sndByteBlock[dst + 98] = (byte) r;
   840:                 sndByteBlock[dst + 99] = (byte) (r >> 8);
   841:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   842:                 l = Math.max (-32768, Math.min (32767, 43 * OPM.opmBuffer[src +  64] + 82 * OPM.opmBuffer[src +  66]                             + 64 >> 7));
   843:                 r = Math.max (-32768, Math.min (32767, 43 * OPM.opmBuffer[src +  65] + 82 * OPM.opmBuffer[src +  67]                             + 64 >> 7));
   844:                 sndByteBlock[dst + 100] = (byte) l;
   845:                 sndByteBlock[dst + 101] = (byte) (l >> 8);
   846:                 sndByteBlock[dst + 102] = (byte) r;
   847:                 sndByteBlock[dst + 103] = (byte) (r >> 8);
   848:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   849:                 l = Math.max (-32768, Math.min (32767, 14 * OPM.opmBuffer[src +  66] + 96 * OPM.opmBuffer[src +  68] + 15 * OPM.opmBuffer[src +  70] + 64 >> 7));
   850:                 r = Math.max (-32768, Math.min (32767, 14 * OPM.opmBuffer[src +  67] + 96 * OPM.opmBuffer[src +  69] + 15 * OPM.opmBuffer[src +  71] + 64 >> 7));
   851:                 sndByteBlock[dst + 104] = (byte) l;
   852:                 sndByteBlock[dst + 105] = (byte) (l >> 8);
   853:                 sndByteBlock[dst + 106] = (byte) r;
   854:                 sndByteBlock[dst + 107] = (byte) (r >> 8);
   855:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   856:                 l = Math.max (-32768, Math.min (32767,                             81 * OPM.opmBuffer[src +  70] + 44 * OPM.opmBuffer[src +  72] + 64 >> 7));
   857:                 r = Math.max (-32768, Math.min (32767,                             81 * OPM.opmBuffer[src +  71] + 44 * OPM.opmBuffer[src +  73] + 64 >> 7));
   858:                 sndByteBlock[dst + 108] = (byte) l;
   859:                 sndByteBlock[dst + 109] = (byte) (l >> 8);
   860:                 sndByteBlock[dst + 110] = (byte) r;
   861:                 sndByteBlock[dst + 111] = (byte) (r >> 8);
   862:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   863:                 l = Math.max (-32768, Math.min (32767, 52 * OPM.opmBuffer[src +  72] + 73 * OPM.opmBuffer[src +  74]                             + 64 >> 7));
   864:                 r = Math.max (-32768, Math.min (32767, 52 * OPM.opmBuffer[src +  73] + 73 * OPM.opmBuffer[src +  75]                             + 64 >> 7));
   865:                 sndByteBlock[dst + 112] = (byte) l;
   866:                 sndByteBlock[dst + 113] = (byte) (l >> 8);
   867:                 sndByteBlock[dst + 114] = (byte) r;
   868:                 sndByteBlock[dst + 115] = (byte) (r >> 8);
   869:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   870:                 l = Math.max (-32768, Math.min (32767, 23 * OPM.opmBuffer[src +  74] + 96 * OPM.opmBuffer[src +  76] +  6 * OPM.opmBuffer[src +  78] + 64 >> 7));
   871:                 r = Math.max (-32768, Math.min (32767, 23 * OPM.opmBuffer[src +  75] + 96 * OPM.opmBuffer[src +  77] +  6 * OPM.opmBuffer[src +  79] + 64 >> 7));
   872:                 sndByteBlock[dst + 116] = (byte) l;
   873:                 sndByteBlock[dst + 117] = (byte) (l >> 8);
   874:                 sndByteBlock[dst + 118] = (byte) r;
   875:                 sndByteBlock[dst + 119] = (byte) (r >> 8);
   876:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   877:                 l = Math.max (-32768, Math.min (32767,                             90 * OPM.opmBuffer[src +  78] + 35 * OPM.opmBuffer[src +  80] + 64 >> 7));
   878:                 r = Math.max (-32768, Math.min (32767,                             90 * OPM.opmBuffer[src +  79] + 35 * OPM.opmBuffer[src +  81] + 64 >> 7));
   879:                 sndByteBlock[dst + 120] = (byte) l;
   880:                 sndByteBlock[dst + 121] = (byte) (l >> 8);
   881:                 sndByteBlock[dst + 122] = (byte) r;
   882:                 sndByteBlock[dst + 123] = (byte) (r >> 8);
   883:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   884:                 l = Math.max (-32768, Math.min (32767, 61 * OPM.opmBuffer[src +  80] + 64 * OPM.opmBuffer[src +  82]                             + 64 >> 7));
   885:                 r = Math.max (-32768, Math.min (32767, 61 * OPM.opmBuffer[src +  81] + 64 * OPM.opmBuffer[src +  83]                             + 64 >> 7));
   886:                 sndByteBlock[dst + 124] = (byte) l;
   887:                 sndByteBlock[dst + 125] = (byte) (l >> 8);
   888:                 sndByteBlock[dst + 126] = (byte) r;
   889:                 sndByteBlock[dst + 127] = (byte) (r >> 8);
   890:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   891:                 l = Math.max (-32768, Math.min (32767, 32 * OPM.opmBuffer[src +  82] + 93 * OPM.opmBuffer[src +  84]                             + 64 >> 7));
   892:                 r = Math.max (-32768, Math.min (32767, 32 * OPM.opmBuffer[src +  83] + 93 * OPM.opmBuffer[src +  85]                             + 64 >> 7));
   893:                 sndByteBlock[dst + 128] = (byte) l;
   894:                 sndByteBlock[dst + 129] = (byte) (l >> 8);
   895:                 sndByteBlock[dst + 130] = (byte) r;
   896:                 sndByteBlock[dst + 131] = (byte) (r >> 8);
   897:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   898:                 l = Math.max (-32768, Math.min (32767,  3 * OPM.opmBuffer[src +  84] + 96 * OPM.opmBuffer[src +  86] + 26 * OPM.opmBuffer[src +  88] + 64 >> 7));
   899:                 r = Math.max (-32768, Math.min (32767,  3 * OPM.opmBuffer[src +  85] + 96 * OPM.opmBuffer[src +  87] + 26 * OPM.opmBuffer[src +  89] + 64 >> 7));
   900:                 sndByteBlock[dst + 132] = (byte) l;
   901:                 sndByteBlock[dst + 133] = (byte) (l >> 8);
   902:                 sndByteBlock[dst + 134] = (byte) r;
   903:                 sndByteBlock[dst + 135] = (byte) (r >> 8);
   904:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   905:                 l = Math.max (-32768, Math.min (32767,                             70 * OPM.opmBuffer[src +  88] + 55 * OPM.opmBuffer[src +  90] + 64 >> 7));
   906:                 r = Math.max (-32768, Math.min (32767,                             70 * OPM.opmBuffer[src +  89] + 55 * OPM.opmBuffer[src +  91] + 64 >> 7));
   907:                 sndByteBlock[dst + 136] = (byte) l;
   908:                 sndByteBlock[dst + 137] = (byte) (l >> 8);
   909:                 sndByteBlock[dst + 138] = (byte) r;
   910:                 sndByteBlock[dst + 139] = (byte) (r >> 8);
   911:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   912:                 l = Math.max (-32768, Math.min (32767, 41 * OPM.opmBuffer[src +  90] + 84 * OPM.opmBuffer[src +  92]                             + 64 >> 7));
   913:                 r = Math.max (-32768, Math.min (32767, 41 * OPM.opmBuffer[src +  91] + 84 * OPM.opmBuffer[src +  93]                             + 64 >> 7));
   914:                 sndByteBlock[dst + 140] = (byte) l;
   915:                 sndByteBlock[dst + 141] = (byte) (l >> 8);
   916:                 sndByteBlock[dst + 142] = (byte) r;
   917:                 sndByteBlock[dst + 143] = (byte) (r >> 8);
   918:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   919:                 l = Math.max (-32768, Math.min (32767, 12 * OPM.opmBuffer[src +  92] + 96 * OPM.opmBuffer[src +  94] + 17 * OPM.opmBuffer[src +  96] + 64 >> 7));
   920:                 r = Math.max (-32768, Math.min (32767, 12 * OPM.opmBuffer[src +  93] + 96 * OPM.opmBuffer[src +  95] + 17 * OPM.opmBuffer[src +  97] + 64 >> 7));
   921:                 sndByteBlock[dst + 144] = (byte) l;
   922:                 sndByteBlock[dst + 145] = (byte) (l >> 8);
   923:                 sndByteBlock[dst + 146] = (byte) r;
   924:                 sndByteBlock[dst + 147] = (byte) (r >> 8);
   925:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   926:                 l = Math.max (-32768, Math.min (32767,                             79 * OPM.opmBuffer[src +  96] + 46 * OPM.opmBuffer[src +  98] + 64 >> 7));
   927:                 r = Math.max (-32768, Math.min (32767,                             79 * OPM.opmBuffer[src +  97] + 46 * OPM.opmBuffer[src +  99] + 64 >> 7));
   928:                 sndByteBlock[dst + 148] = (byte) l;
   929:                 sndByteBlock[dst + 149] = (byte) (l >> 8);
   930:                 sndByteBlock[dst + 150] = (byte) r;
   931:                 sndByteBlock[dst + 151] = (byte) (r >> 8);
   932:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   933:                 l = Math.max (-32768, Math.min (32767, 50 * OPM.opmBuffer[src +  98] + 75 * OPM.opmBuffer[src + 100]                             + 64 >> 7));
   934:                 r = Math.max (-32768, Math.min (32767, 50 * OPM.opmBuffer[src +  99] + 75 * OPM.opmBuffer[src + 101]                             + 64 >> 7));
   935:                 sndByteBlock[dst + 152] = (byte) l;
   936:                 sndByteBlock[dst + 153] = (byte) (l >> 8);
   937:                 sndByteBlock[dst + 154] = (byte) r;
   938:                 sndByteBlock[dst + 155] = (byte) (r >> 8);
   939:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   940:                 l = Math.max (-32768, Math.min (32767, 21 * OPM.opmBuffer[src + 100] + 96 * OPM.opmBuffer[src + 102] +  8 * OPM.opmBuffer[src + 104] + 64 >> 7));
   941:                 r = Math.max (-32768, Math.min (32767, 21 * OPM.opmBuffer[src + 101] + 96 * OPM.opmBuffer[src + 103] +  8 * OPM.opmBuffer[src + 105] + 64 >> 7));
   942:                 sndByteBlock[dst + 156] = (byte) l;
   943:                 sndByteBlock[dst + 157] = (byte) (l >> 8);
   944:                 sndByteBlock[dst + 158] = (byte) r;
   945:                 sndByteBlock[dst + 159] = (byte) (r >> 8);
   946:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   947:                 l = Math.max (-32768, Math.min (32767,                             88 * OPM.opmBuffer[src + 104] + 37 * OPM.opmBuffer[src + 106] + 64 >> 7));
   948:                 r = Math.max (-32768, Math.min (32767,                             88 * OPM.opmBuffer[src + 105] + 37 * OPM.opmBuffer[src + 107] + 64 >> 7));
   949:                 sndByteBlock[dst + 160] = (byte) l;
   950:                 sndByteBlock[dst + 161] = (byte) (l >> 8);
   951:                 sndByteBlock[dst + 162] = (byte) r;
   952:                 sndByteBlock[dst + 163] = (byte) (r >> 8);
   953:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   954:                 l = Math.max (-32768, Math.min (32767, 59 * OPM.opmBuffer[src + 106] + 66 * OPM.opmBuffer[src + 108]                             + 64 >> 7));
   955:                 r = Math.max (-32768, Math.min (32767, 59 * OPM.opmBuffer[src + 107] + 66 * OPM.opmBuffer[src + 109]                             + 64 >> 7));
   956:                 sndByteBlock[dst + 164] = (byte) l;
   957:                 sndByteBlock[dst + 165] = (byte) (l >> 8);
   958:                 sndByteBlock[dst + 166] = (byte) r;
   959:                 sndByteBlock[dst + 167] = (byte) (r >> 8);
   960:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   961:                 l = Math.max (-32768, Math.min (32767, 30 * OPM.opmBuffer[src + 108] + 95 * OPM.opmBuffer[src + 110]                             + 64 >> 7));
   962:                 r = Math.max (-32768, Math.min (32767, 30 * OPM.opmBuffer[src + 109] + 95 * OPM.opmBuffer[src + 111]                             + 64 >> 7));
   963:                 sndByteBlock[dst + 168] = (byte) l;
   964:                 sndByteBlock[dst + 169] = (byte) (l >> 8);
   965:                 sndByteBlock[dst + 170] = (byte) r;
   966:                 sndByteBlock[dst + 171] = (byte) (r >> 8);
   967:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   968:                 l = Math.max (-32768, Math.min (32767,      OPM.opmBuffer[src + 110] + 96 * OPM.opmBuffer[src + 112] + 28 * OPM.opmBuffer[src + 114] + 64 >> 7));
   969:                 r = Math.max (-32768, Math.min (32767,      OPM.opmBuffer[src + 111] + 96 * OPM.opmBuffer[src + 113] + 28 * OPM.opmBuffer[src + 115] + 64 >> 7));
   970:                 sndByteBlock[dst + 172] = (byte) l;
   971:                 sndByteBlock[dst + 173] = (byte) (l >> 8);
   972:                 sndByteBlock[dst + 174] = (byte) r;
   973:                 sndByteBlock[dst + 175] = (byte) (r >> 8);
   974:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   975:                 l = Math.max (-32768, Math.min (32767,                             68 * OPM.opmBuffer[src + 114] + 57 * OPM.opmBuffer[src + 116] + 64 >> 7));
   976:                 r = Math.max (-32768, Math.min (32767,                             68 * OPM.opmBuffer[src + 115] + 57 * OPM.opmBuffer[src + 117] + 64 >> 7));
   977:                 sndByteBlock[dst + 176] = (byte) l;
   978:                 sndByteBlock[dst + 177] = (byte) (l >> 8);
   979:                 sndByteBlock[dst + 178] = (byte) r;
   980:                 sndByteBlock[dst + 179] = (byte) (r >> 8);
   981:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   982:                 l = Math.max (-32768, Math.min (32767, 39 * OPM.opmBuffer[src + 116] + 86 * OPM.opmBuffer[src + 118]                             + 64 >> 7));
   983:                 r = Math.max (-32768, Math.min (32767, 39 * OPM.opmBuffer[src + 117] + 86 * OPM.opmBuffer[src + 119]                             + 64 >> 7));
   984:                 sndByteBlock[dst + 180] = (byte) l;
   985:                 sndByteBlock[dst + 181] = (byte) (l >> 8);
   986:                 sndByteBlock[dst + 182] = (byte) r;
   987:                 sndByteBlock[dst + 183] = (byte) (r >> 8);
   988:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   989:                 l = Math.max (-32768, Math.min (32767, 10 * OPM.opmBuffer[src + 118] + 96 * OPM.opmBuffer[src + 120] + 19 * OPM.opmBuffer[src + 122] + 64 >> 7));
   990:                 r = Math.max (-32768, Math.min (32767, 10 * OPM.opmBuffer[src + 119] + 96 * OPM.opmBuffer[src + 121] + 19 * OPM.opmBuffer[src + 123] + 64 >> 7));
   991:                 sndByteBlock[dst + 184] = (byte) l;
   992:                 sndByteBlock[dst + 185] = (byte) (l >> 8);
   993:                 sndByteBlock[dst + 186] = (byte) r;
   994:                 sndByteBlock[dst + 187] = (byte) (r >> 8);
   995:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
   996:                 l = Math.max (-32768, Math.min (32767,                             77 * OPM.opmBuffer[src + 122] + 48 * OPM.opmBuffer[src + 124] + 64 >> 7));
   997:                 r = Math.max (-32768, Math.min (32767,                             77 * OPM.opmBuffer[src + 123] + 48 * OPM.opmBuffer[src + 125] + 64 >> 7));
   998:                 sndByteBlock[dst + 188] = (byte) l;
   999:                 sndByteBlock[dst + 189] = (byte) (l >> 8);
  1000:                 sndByteBlock[dst + 190] = (byte) r;
  1001:                 sndByteBlock[dst + 191] = (byte) (r >> 8);
  1002:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1003:                 l = Math.max (-32768, Math.min (32767, 48 * OPM.opmBuffer[src + 124] + 77 * OPM.opmBuffer[src + 126]                             + 64 >> 7));
  1004:                 r = Math.max (-32768, Math.min (32767, 48 * OPM.opmBuffer[src + 125] + 77 * OPM.opmBuffer[src + 127]                             + 64 >> 7));
  1005:                 sndByteBlock[dst + 192] = (byte) l;
  1006:                 sndByteBlock[dst + 193] = (byte) (l >> 8);
  1007:                 sndByteBlock[dst + 194] = (byte) r;
  1008:                 sndByteBlock[dst + 195] = (byte) (r >> 8);
  1009:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1010:                 l = Math.max (-32768, Math.min (32767, 19 * OPM.opmBuffer[src + 126] + 96 * OPM.opmBuffer[src + 128] + 10 * OPM.opmBuffer[src + 130] + 64 >> 7));
  1011:                 r = Math.max (-32768, Math.min (32767, 19 * OPM.opmBuffer[src + 127] + 96 * OPM.opmBuffer[src + 129] + 10 * OPM.opmBuffer[src + 131] + 64 >> 7));
  1012:                 sndByteBlock[dst + 196] = (byte) l;
  1013:                 sndByteBlock[dst + 197] = (byte) (l >> 8);
  1014:                 sndByteBlock[dst + 198] = (byte) r;
  1015:                 sndByteBlock[dst + 199] = (byte) (r >> 8);
  1016:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1017:                 l = Math.max (-32768, Math.min (32767,                             86 * OPM.opmBuffer[src + 130] + 39 * OPM.opmBuffer[src + 132] + 64 >> 7));
  1018:                 r = Math.max (-32768, Math.min (32767,                             86 * OPM.opmBuffer[src + 131] + 39 * OPM.opmBuffer[src + 133] + 64 >> 7));
  1019:                 sndByteBlock[dst + 200] = (byte) l;
  1020:                 sndByteBlock[dst + 201] = (byte) (l >> 8);
  1021:                 sndByteBlock[dst + 202] = (byte) r;
  1022:                 sndByteBlock[dst + 203] = (byte) (r >> 8);
  1023:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1024:                 l = Math.max (-32768, Math.min (32767, 57 * OPM.opmBuffer[src + 132] + 68 * OPM.opmBuffer[src + 134]                             + 64 >> 7));
  1025:                 r = Math.max (-32768, Math.min (32767, 57 * OPM.opmBuffer[src + 133] + 68 * OPM.opmBuffer[src + 135]                             + 64 >> 7));
  1026:                 sndByteBlock[dst + 204] = (byte) l;
  1027:                 sndByteBlock[dst + 205] = (byte) (l >> 8);
  1028:                 sndByteBlock[dst + 206] = (byte) r;
  1029:                 sndByteBlock[dst + 207] = (byte) (r >> 8);
  1030:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1031:                 l = Math.max (-32768, Math.min (32767, 28 * OPM.opmBuffer[src + 134] + 96 * OPM.opmBuffer[src + 136] +      OPM.opmBuffer[src + 138] + 64 >> 7));
  1032:                 r = Math.max (-32768, Math.min (32767, 28 * OPM.opmBuffer[src + 135] + 96 * OPM.opmBuffer[src + 137] +      OPM.opmBuffer[src + 139] + 64 >> 7));
  1033:                 sndByteBlock[dst + 208] = (byte) l;
  1034:                 sndByteBlock[dst + 209] = (byte) (l >> 8);
  1035:                 sndByteBlock[dst + 210] = (byte) r;
  1036:                 sndByteBlock[dst + 211] = (byte) (r >> 8);
  1037:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1038:                 l = Math.max (-32768, Math.min (32767,                             95 * OPM.opmBuffer[src + 138] + 30 * OPM.opmBuffer[src + 140] + 64 >> 7));
  1039:                 r = Math.max (-32768, Math.min (32767,                             95 * OPM.opmBuffer[src + 139] + 30 * OPM.opmBuffer[src + 141] + 64 >> 7));
  1040:                 sndByteBlock[dst + 212] = (byte) l;
  1041:                 sndByteBlock[dst + 213] = (byte) (l >> 8);
  1042:                 sndByteBlock[dst + 214] = (byte) r;
  1043:                 sndByteBlock[dst + 215] = (byte) (r >> 8);
  1044:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1045:                 l = Math.max (-32768, Math.min (32767,                             66 * OPM.opmBuffer[src + 140] + 59 * OPM.opmBuffer[src + 142] + 64 >> 7));
  1046:                 r = Math.max (-32768, Math.min (32767,                             66 * OPM.opmBuffer[src + 141] + 59 * OPM.opmBuffer[src + 143] + 64 >> 7));
  1047:                 sndByteBlock[dst + 216] = (byte) l;
  1048:                 sndByteBlock[dst + 217] = (byte) (l >> 8);
  1049:                 sndByteBlock[dst + 218] = (byte) r;
  1050:                 sndByteBlock[dst + 219] = (byte) (r >> 8);
  1051:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1052:                 l = Math.max (-32768, Math.min (32767, 37 * OPM.opmBuffer[src + 142] + 88 * OPM.opmBuffer[src + 144]                             + 64 >> 7));
  1053:                 r = Math.max (-32768, Math.min (32767, 37 * OPM.opmBuffer[src + 143] + 88 * OPM.opmBuffer[src + 145]                             + 64 >> 7));
  1054:                 sndByteBlock[dst + 220] = (byte) l;
  1055:                 sndByteBlock[dst + 221] = (byte) (l >> 8);
  1056:                 sndByteBlock[dst + 222] = (byte) r;
  1057:                 sndByteBlock[dst + 223] = (byte) (r >> 8);
  1058:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1059:                 l = Math.max (-32768, Math.min (32767,  8 * OPM.opmBuffer[src + 144] + 96 * OPM.opmBuffer[src + 146] + 21 * OPM.opmBuffer[src + 148] + 64 >> 7));
  1060:                 r = Math.max (-32768, Math.min (32767,  8 * OPM.opmBuffer[src + 145] + 96 * OPM.opmBuffer[src + 147] + 21 * OPM.opmBuffer[src + 149] + 64 >> 7));
  1061:                 sndByteBlock[dst + 224] = (byte) l;
  1062:                 sndByteBlock[dst + 225] = (byte) (l >> 8);
  1063:                 sndByteBlock[dst + 226] = (byte) r;
  1064:                 sndByteBlock[dst + 227] = (byte) (r >> 8);
  1065:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1066:                 l = Math.max (-32768, Math.min (32767,                             75 * OPM.opmBuffer[src + 148] + 50 * OPM.opmBuffer[src + 150] + 64 >> 7));
  1067:                 r = Math.max (-32768, Math.min (32767,                             75 * OPM.opmBuffer[src + 149] + 50 * OPM.opmBuffer[src + 151] + 64 >> 7));
  1068:                 sndByteBlock[dst + 228] = (byte) l;
  1069:                 sndByteBlock[dst + 229] = (byte) (l >> 8);
  1070:                 sndByteBlock[dst + 230] = (byte) r;
  1071:                 sndByteBlock[dst + 231] = (byte) (r >> 8);
  1072:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1073:                 l = Math.max (-32768, Math.min (32767, 46 * OPM.opmBuffer[src + 150] + 79 * OPM.opmBuffer[src + 152]                             + 64 >> 7));
  1074:                 r = Math.max (-32768, Math.min (32767, 46 * OPM.opmBuffer[src + 151] + 79 * OPM.opmBuffer[src + 153]                             + 64 >> 7));
  1075:                 sndByteBlock[dst + 232] = (byte) l;
  1076:                 sndByteBlock[dst + 233] = (byte) (l >> 8);
  1077:                 sndByteBlock[dst + 234] = (byte) r;
  1078:                 sndByteBlock[dst + 235] = (byte) (r >> 8);
  1079:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1080:                 l = Math.max (-32768, Math.min (32767, 17 * OPM.opmBuffer[src + 152] + 96 * OPM.opmBuffer[src + 154] + 12 * OPM.opmBuffer[src + 156] + 64 >> 7));
  1081:                 r = Math.max (-32768, Math.min (32767, 17 * OPM.opmBuffer[src + 153] + 96 * OPM.opmBuffer[src + 155] + 12 * OPM.opmBuffer[src + 157] + 64 >> 7));
  1082:                 sndByteBlock[dst + 236] = (byte) l;
  1083:                 sndByteBlock[dst + 237] = (byte) (l >> 8);
  1084:                 sndByteBlock[dst + 238] = (byte) r;
  1085:                 sndByteBlock[dst + 239] = (byte) (r >> 8);
  1086:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1087:                 l = Math.max (-32768, Math.min (32767,                             84 * OPM.opmBuffer[src + 156] + 41 * OPM.opmBuffer[src + 158] + 64 >> 7));
  1088:                 r = Math.max (-32768, Math.min (32767,                             84 * OPM.opmBuffer[src + 157] + 41 * OPM.opmBuffer[src + 159] + 64 >> 7));
  1089:                 sndByteBlock[dst + 240] = (byte) l;
  1090:                 sndByteBlock[dst + 241] = (byte) (l >> 8);
  1091:                 sndByteBlock[dst + 242] = (byte) r;
  1092:                 sndByteBlock[dst + 243] = (byte) (r >> 8);
  1093:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1094:                 l = Math.max (-32768, Math.min (32767, 55 * OPM.opmBuffer[src + 158] + 70 * OPM.opmBuffer[src + 160]                             + 64 >> 7));
  1095:                 r = Math.max (-32768, Math.min (32767, 55 * OPM.opmBuffer[src + 159] + 70 * OPM.opmBuffer[src + 161]                             + 64 >> 7));
  1096:                 sndByteBlock[dst + 244] = (byte) l;
  1097:                 sndByteBlock[dst + 245] = (byte) (l >> 8);
  1098:                 sndByteBlock[dst + 246] = (byte) r;
  1099:                 sndByteBlock[dst + 247] = (byte) (r >> 8);
  1100:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1101:                 l = Math.max (-32768, Math.min (32767, 26 * OPM.opmBuffer[src + 160] + 96 * OPM.opmBuffer[src + 162] +  3 * OPM.opmBuffer[src + 164] + 64 >> 7));
  1102:                 r = Math.max (-32768, Math.min (32767, 26 * OPM.opmBuffer[src + 161] + 96 * OPM.opmBuffer[src + 163] +  3 * OPM.opmBuffer[src + 165] + 64 >> 7));
  1103:                 sndByteBlock[dst + 248] = (byte) l;
  1104:                 sndByteBlock[dst + 249] = (byte) (l >> 8);
  1105:                 sndByteBlock[dst + 250] = (byte) r;
  1106:                 sndByteBlock[dst + 251] = (byte) (r >> 8);
  1107:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1108:                 l = Math.max (-32768, Math.min (32767,                             93 * OPM.opmBuffer[src + 164] + 32 * OPM.opmBuffer[src + 166] + 64 >> 7));
  1109:                 r = Math.max (-32768, Math.min (32767,                             93 * OPM.opmBuffer[src + 165] + 32 * OPM.opmBuffer[src + 167] + 64 >> 7));
  1110:                 sndByteBlock[dst + 252] = (byte) l;
  1111:                 sndByteBlock[dst + 253] = (byte) (l >> 8);
  1112:                 sndByteBlock[dst + 254] = (byte) r;
  1113:                 sndByteBlock[dst + 255] = (byte) (r >> 8);
  1114:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1115:                 l = Math.max (-32768, Math.min (32767,                             64 * OPM.opmBuffer[src + 166] + 61 * OPM.opmBuffer[src + 168] + 64 >> 7));
  1116:                 r = Math.max (-32768, Math.min (32767,                             64 * OPM.opmBuffer[src + 167] + 61 * OPM.opmBuffer[src + 169] + 64 >> 7));
  1117:                 sndByteBlock[dst + 256] = (byte) l;
  1118:                 sndByteBlock[dst + 257] = (byte) (l >> 8);
  1119:                 sndByteBlock[dst + 258] = (byte) r;
  1120:                 sndByteBlock[dst + 259] = (byte) (r >> 8);
  1121:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1122:                 l = Math.max (-32768, Math.min (32767, 35 * OPM.opmBuffer[src + 168] + 90 * OPM.opmBuffer[src + 170]                             + 64 >> 7));
  1123:                 r = Math.max (-32768, Math.min (32767, 35 * OPM.opmBuffer[src + 169] + 90 * OPM.opmBuffer[src + 171]                             + 64 >> 7));
  1124:                 sndByteBlock[dst + 260] = (byte) l;
  1125:                 sndByteBlock[dst + 261] = (byte) (l >> 8);
  1126:                 sndByteBlock[dst + 262] = (byte) r;
  1127:                 sndByteBlock[dst + 263] = (byte) (r >> 8);
  1128:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1129:                 l = Math.max (-32768, Math.min (32767,  6 * OPM.opmBuffer[src + 170] + 96 * OPM.opmBuffer[src + 172] + 23 * OPM.opmBuffer[src + 174] + 64 >> 7));
  1130:                 r = Math.max (-32768, Math.min (32767,  6 * OPM.opmBuffer[src + 171] + 96 * OPM.opmBuffer[src + 173] + 23 * OPM.opmBuffer[src + 175] + 64 >> 7));
  1131:                 sndByteBlock[dst + 264] = (byte) l;
  1132:                 sndByteBlock[dst + 265] = (byte) (l >> 8);
  1133:                 sndByteBlock[dst + 266] = (byte) r;
  1134:                 sndByteBlock[dst + 267] = (byte) (r >> 8);
  1135:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1136:                 l = Math.max (-32768, Math.min (32767,                             73 * OPM.opmBuffer[src + 174] + 52 * OPM.opmBuffer[src + 176] + 64 >> 7));
  1137:                 r = Math.max (-32768, Math.min (32767,                             73 * OPM.opmBuffer[src + 175] + 52 * OPM.opmBuffer[src + 177] + 64 >> 7));
  1138:                 sndByteBlock[dst + 268] = (byte) l;
  1139:                 sndByteBlock[dst + 269] = (byte) (l >> 8);
  1140:                 sndByteBlock[dst + 270] = (byte) r;
  1141:                 sndByteBlock[dst + 271] = (byte) (r >> 8);
  1142:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1143:                 l = Math.max (-32768, Math.min (32767, 44 * OPM.opmBuffer[src + 176] + 81 * OPM.opmBuffer[src + 178]                             + 64 >> 7));
  1144:                 r = Math.max (-32768, Math.min (32767, 44 * OPM.opmBuffer[src + 177] + 81 * OPM.opmBuffer[src + 179]                             + 64 >> 7));
  1145:                 sndByteBlock[dst + 272] = (byte) l;
  1146:                 sndByteBlock[dst + 273] = (byte) (l >> 8);
  1147:                 sndByteBlock[dst + 274] = (byte) r;
  1148:                 sndByteBlock[dst + 275] = (byte) (r >> 8);
  1149:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1150:                 l = Math.max (-32768, Math.min (32767, 15 * OPM.opmBuffer[src + 178] + 96 * OPM.opmBuffer[src + 180] + 14 * OPM.opmBuffer[src + 182] + 64 >> 7));
  1151:                 r = Math.max (-32768, Math.min (32767, 15 * OPM.opmBuffer[src + 179] + 96 * OPM.opmBuffer[src + 181] + 14 * OPM.opmBuffer[src + 183] + 64 >> 7));
  1152:                 sndByteBlock[dst + 276] = (byte) l;
  1153:                 sndByteBlock[dst + 277] = (byte) (l >> 8);
  1154:                 sndByteBlock[dst + 278] = (byte) r;
  1155:                 sndByteBlock[dst + 279] = (byte) (r >> 8);
  1156:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1157:                 l = Math.max (-32768, Math.min (32767,                             82 * OPM.opmBuffer[src + 182] + 43 * OPM.opmBuffer[src + 184] + 64 >> 7));
  1158:                 r = Math.max (-32768, Math.min (32767,                             82 * OPM.opmBuffer[src + 183] + 43 * OPM.opmBuffer[src + 185] + 64 >> 7));
  1159:                 sndByteBlock[dst + 280] = (byte) l;
  1160:                 sndByteBlock[dst + 281] = (byte) (l >> 8);
  1161:                 sndByteBlock[dst + 282] = (byte) r;
  1162:                 sndByteBlock[dst + 283] = (byte) (r >> 8);
  1163:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1164:                 l = Math.max (-32768, Math.min (32767, 53 * OPM.opmBuffer[src + 184] + 72 * OPM.opmBuffer[src + 186]                             + 64 >> 7));
  1165:                 r = Math.max (-32768, Math.min (32767, 53 * OPM.opmBuffer[src + 185] + 72 * OPM.opmBuffer[src + 187]                             + 64 >> 7));
  1166:                 sndByteBlock[dst + 284] = (byte) l;
  1167:                 sndByteBlock[dst + 285] = (byte) (l >> 8);
  1168:                 sndByteBlock[dst + 286] = (byte) r;
  1169:                 sndByteBlock[dst + 287] = (byte) (r >> 8);
  1170:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1171:                 l = Math.max (-32768, Math.min (32767, 24 * OPM.opmBuffer[src + 186] + 96 * OPM.opmBuffer[src + 188] +  5 * OPM.opmBuffer[src + 190] + 64 >> 7));
  1172:                 r = Math.max (-32768, Math.min (32767, 24 * OPM.opmBuffer[src + 187] + 96 * OPM.opmBuffer[src + 189] +  5 * OPM.opmBuffer[src + 191] + 64 >> 7));
  1173:                 sndByteBlock[dst + 288] = (byte) l;
  1174:                 sndByteBlock[dst + 289] = (byte) (l >> 8);
  1175:                 sndByteBlock[dst + 290] = (byte) r;
  1176:                 sndByteBlock[dst + 291] = (byte) (r >> 8);
  1177:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1178:                 l = Math.max (-32768, Math.min (32767,                             91 * OPM.opmBuffer[src + 190] + 34 * OPM.opmBuffer[src + 192] + 64 >> 7));
  1179:                 r = Math.max (-32768, Math.min (32767,                             91 * OPM.opmBuffer[src + 191] + 34 * OPM.opmBuffer[src + 193] + 64 >> 7));
  1180:                 sndByteBlock[dst + 292] = (byte) l;
  1181:                 sndByteBlock[dst + 293] = (byte) (l >> 8);
  1182:                 sndByteBlock[dst + 294] = (byte) r;
  1183:                 sndByteBlock[dst + 295] = (byte) (r >> 8);
  1184:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1185:                 l = Math.max (-32768, Math.min (32767, 62 * OPM.opmBuffer[src + 192] + 63 * OPM.opmBuffer[src + 194]                             + 64 >> 7));
  1186:                 r = Math.max (-32768, Math.min (32767, 62 * OPM.opmBuffer[src + 193] + 63 * OPM.opmBuffer[src + 195]                             + 64 >> 7));
  1187:                 sndByteBlock[dst + 296] = (byte) l;
  1188:                 sndByteBlock[dst + 297] = (byte) (l >> 8);
  1189:                 sndByteBlock[dst + 298] = (byte) r;
  1190:                 sndByteBlock[dst + 299] = (byte) (r >> 8);
  1191:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1192:                 l = Math.max (-32768, Math.min (32767, 33 * OPM.opmBuffer[src + 194] + 92 * OPM.opmBuffer[src + 196]                             + 64 >> 7));
  1193:                 r = Math.max (-32768, Math.min (32767, 33 * OPM.opmBuffer[src + 195] + 92 * OPM.opmBuffer[src + 197]                             + 64 >> 7));
  1194:                 sndByteBlock[dst + 300] = (byte) l;
  1195:                 sndByteBlock[dst + 301] = (byte) (l >> 8);
  1196:                 sndByteBlock[dst + 302] = (byte) r;
  1197:                 sndByteBlock[dst + 303] = (byte) (r >> 8);
  1198:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1199:                 l = Math.max (-32768, Math.min (32767,  4 * OPM.opmBuffer[src + 196] + 96 * OPM.opmBuffer[src + 198] + 25 * OPM.opmBuffer[src + 200] + 64 >> 7));
  1200:                 r = Math.max (-32768, Math.min (32767,  4 * OPM.opmBuffer[src + 197] + 96 * OPM.opmBuffer[src + 199] + 25 * OPM.opmBuffer[src + 201] + 64 >> 7));
  1201:                 sndByteBlock[dst + 304] = (byte) l;
  1202:                 sndByteBlock[dst + 305] = (byte) (l >> 8);
  1203:                 sndByteBlock[dst + 306] = (byte) r;
  1204:                 sndByteBlock[dst + 307] = (byte) (r >> 8);
  1205:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1206:                 l = Math.max (-32768, Math.min (32767,                             71 * OPM.opmBuffer[src + 200] + 54 * OPM.opmBuffer[src + 202] + 64 >> 7));
  1207:                 r = Math.max (-32768, Math.min (32767,                             71 * OPM.opmBuffer[src + 201] + 54 * OPM.opmBuffer[src + 203] + 64 >> 7));
  1208:                 sndByteBlock[dst + 308] = (byte) l;
  1209:                 sndByteBlock[dst + 309] = (byte) (l >> 8);
  1210:                 sndByteBlock[dst + 310] = (byte) r;
  1211:                 sndByteBlock[dst + 311] = (byte) (r >> 8);
  1212:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1213:                 l = Math.max (-32768, Math.min (32767, 42 * OPM.opmBuffer[src + 202] + 83 * OPM.opmBuffer[src + 204]                             + 64 >> 7));
  1214:                 r = Math.max (-32768, Math.min (32767, 42 * OPM.opmBuffer[src + 203] + 83 * OPM.opmBuffer[src + 205]                             + 64 >> 7));
  1215:                 sndByteBlock[dst + 312] = (byte) l;
  1216:                 sndByteBlock[dst + 313] = (byte) (l >> 8);
  1217:                 sndByteBlock[dst + 314] = (byte) r;
  1218:                 sndByteBlock[dst + 315] = (byte) (r >> 8);
  1219:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1220:                 l = Math.max (-32768, Math.min (32767, 13 * OPM.opmBuffer[src + 204] + 96 * OPM.opmBuffer[src + 206] + 16 * OPM.opmBuffer[src + 208] + 64 >> 7));
  1221:                 r = Math.max (-32768, Math.min (32767, 13 * OPM.opmBuffer[src + 205] + 96 * OPM.opmBuffer[src + 207] + 16 * OPM.opmBuffer[src + 209] + 64 >> 7));
  1222:                 sndByteBlock[dst + 316] = (byte) l;
  1223:                 sndByteBlock[dst + 317] = (byte) (l >> 8);
  1224:                 sndByteBlock[dst + 318] = (byte) r;
  1225:                 sndByteBlock[dst + 319] = (byte) (r >> 8);
  1226:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1227:                 l = Math.max (-32768, Math.min (32767,                             80 * OPM.opmBuffer[src + 208] + 45 * OPM.opmBuffer[src + 210] + 64 >> 7));
  1228:                 r = Math.max (-32768, Math.min (32767,                             80 * OPM.opmBuffer[src + 209] + 45 * OPM.opmBuffer[src + 211] + 64 >> 7));
  1229:                 sndByteBlock[dst + 320] = (byte) l;
  1230:                 sndByteBlock[dst + 321] = (byte) (l >> 8);
  1231:                 sndByteBlock[dst + 322] = (byte) r;
  1232:                 sndByteBlock[dst + 323] = (byte) (r >> 8);
  1233:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1234:                 l = Math.max (-32768, Math.min (32767, 51 * OPM.opmBuffer[src + 210] + 74 * OPM.opmBuffer[src + 212]                             + 64 >> 7));
  1235:                 r = Math.max (-32768, Math.min (32767, 51 * OPM.opmBuffer[src + 211] + 74 * OPM.opmBuffer[src + 213]                             + 64 >> 7));
  1236:                 sndByteBlock[dst + 324] = (byte) l;
  1237:                 sndByteBlock[dst + 325] = (byte) (l >> 8);
  1238:                 sndByteBlock[dst + 326] = (byte) r;
  1239:                 sndByteBlock[dst + 327] = (byte) (r >> 8);
  1240:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1241:                 l = Math.max (-32768, Math.min (32767, 22 * OPM.opmBuffer[src + 212] + 96 * OPM.opmBuffer[src + 214] +  7 * OPM.opmBuffer[src + 216] + 64 >> 7));
  1242:                 r = Math.max (-32768, Math.min (32767, 22 * OPM.opmBuffer[src + 213] + 96 * OPM.opmBuffer[src + 215] +  7 * OPM.opmBuffer[src + 217] + 64 >> 7));
  1243:                 sndByteBlock[dst + 328] = (byte) l;
  1244:                 sndByteBlock[dst + 329] = (byte) (l >> 8);
  1245:                 sndByteBlock[dst + 330] = (byte) r;
  1246:                 sndByteBlock[dst + 331] = (byte) (r >> 8);
  1247:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1248:                 l = Math.max (-32768, Math.min (32767,                             89 * OPM.opmBuffer[src + 216] + 36 * OPM.opmBuffer[src + 218] + 64 >> 7));
  1249:                 r = Math.max (-32768, Math.min (32767,                             89 * OPM.opmBuffer[src + 217] + 36 * OPM.opmBuffer[src + 219] + 64 >> 7));
  1250:                 sndByteBlock[dst + 332] = (byte) l;
  1251:                 sndByteBlock[dst + 333] = (byte) (l >> 8);
  1252:                 sndByteBlock[dst + 334] = (byte) r;
  1253:                 sndByteBlock[dst + 335] = (byte) (r >> 8);
  1254:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1255:                 l = Math.max (-32768, Math.min (32767, 60 * OPM.opmBuffer[src + 218] + 65 * OPM.opmBuffer[src + 220]                             + 64 >> 7));
  1256:                 r = Math.max (-32768, Math.min (32767, 60 * OPM.opmBuffer[src + 219] + 65 * OPM.opmBuffer[src + 221]                             + 64 >> 7));
  1257:                 sndByteBlock[dst + 336] = (byte) l;
  1258:                 sndByteBlock[dst + 337] = (byte) (l >> 8);
  1259:                 sndByteBlock[dst + 338] = (byte) r;
  1260:                 sndByteBlock[dst + 339] = (byte) (r >> 8);
  1261:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1262:                 l = Math.max (-32768, Math.min (32767, 31 * OPM.opmBuffer[src + 220] + 94 * OPM.opmBuffer[src + 222]                             + 64 >> 7));
  1263:                 r = Math.max (-32768, Math.min (32767, 31 * OPM.opmBuffer[src + 221] + 94 * OPM.opmBuffer[src + 223]                             + 64 >> 7));
  1264:                 sndByteBlock[dst + 340] = (byte) l;
  1265:                 sndByteBlock[dst + 341] = (byte) (l >> 8);
  1266:                 sndByteBlock[dst + 342] = (byte) r;
  1267:                 sndByteBlock[dst + 343] = (byte) (r >> 8);
  1268:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1269:                 l = Math.max (-32768, Math.min (32767,  2 * OPM.opmBuffer[src + 222] + 96 * OPM.opmBuffer[src + 224] + 27 * OPM.opmBuffer[src + 226] + 64 >> 7));
  1270:                 r = Math.max (-32768, Math.min (32767,  2 * OPM.opmBuffer[src + 223] + 96 * OPM.opmBuffer[src + 225] + 27 * OPM.opmBuffer[src + 227] + 64 >> 7));
  1271:                 sndByteBlock[dst + 344] = (byte) l;
  1272:                 sndByteBlock[dst + 345] = (byte) (l >> 8);
  1273:                 sndByteBlock[dst + 346] = (byte) r;
  1274:                 sndByteBlock[dst + 347] = (byte) (r >> 8);
  1275:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1276:                 l = Math.max (-32768, Math.min (32767,                             69 * OPM.opmBuffer[src + 226] + 56 * OPM.opmBuffer[src + 228] + 64 >> 7));
  1277:                 r = Math.max (-32768, Math.min (32767,                             69 * OPM.opmBuffer[src + 227] + 56 * OPM.opmBuffer[src + 229] + 64 >> 7));
  1278:                 sndByteBlock[dst + 348] = (byte) l;
  1279:                 sndByteBlock[dst + 349] = (byte) (l >> 8);
  1280:                 sndByteBlock[dst + 350] = (byte) r;
  1281:                 sndByteBlock[dst + 351] = (byte) (r >> 8);
  1282:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1283:                 l = Math.max (-32768, Math.min (32767, 40 * OPM.opmBuffer[src + 228] + 85 * OPM.opmBuffer[src + 230]                             + 64 >> 7));
  1284:                 r = Math.max (-32768, Math.min (32767, 40 * OPM.opmBuffer[src + 229] + 85 * OPM.opmBuffer[src + 231]                             + 64 >> 7));
  1285:                 sndByteBlock[dst + 352] = (byte) l;
  1286:                 sndByteBlock[dst + 353] = (byte) (l >> 8);
  1287:                 sndByteBlock[dst + 354] = (byte) r;
  1288:                 sndByteBlock[dst + 355] = (byte) (r >> 8);
  1289:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1290:                 l = Math.max (-32768, Math.min (32767, 11 * OPM.opmBuffer[src + 230] + 96 * OPM.opmBuffer[src + 232] + 18 * OPM.opmBuffer[src + 234] + 64 >> 7));
  1291:                 r = Math.max (-32768, Math.min (32767, 11 * OPM.opmBuffer[src + 231] + 96 * OPM.opmBuffer[src + 233] + 18 * OPM.opmBuffer[src + 235] + 64 >> 7));
  1292:                 sndByteBlock[dst + 356] = (byte) l;
  1293:                 sndByteBlock[dst + 357] = (byte) (l >> 8);
  1294:                 sndByteBlock[dst + 358] = (byte) r;
  1295:                 sndByteBlock[dst + 359] = (byte) (r >> 8);
  1296:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1297:                 l = Math.max (-32768, Math.min (32767,                             78 * OPM.opmBuffer[src + 234] + 47 * OPM.opmBuffer[src + 236] + 64 >> 7));
  1298:                 r = Math.max (-32768, Math.min (32767,                             78 * OPM.opmBuffer[src + 235] + 47 * OPM.opmBuffer[src + 237] + 64 >> 7));
  1299:                 sndByteBlock[dst + 360] = (byte) l;
  1300:                 sndByteBlock[dst + 361] = (byte) (l >> 8);
  1301:                 sndByteBlock[dst + 362] = (byte) r;
  1302:                 sndByteBlock[dst + 363] = (byte) (r >> 8);
  1303:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1304:                 l = Math.max (-32768, Math.min (32767, 49 * OPM.opmBuffer[src + 236] + 76 * OPM.opmBuffer[src + 238]                             + 64 >> 7));
  1305:                 r = Math.max (-32768, Math.min (32767, 49 * OPM.opmBuffer[src + 237] + 76 * OPM.opmBuffer[src + 239]                             + 64 >> 7));
  1306:                 sndByteBlock[dst + 364] = (byte) l;
  1307:                 sndByteBlock[dst + 365] = (byte) (l >> 8);
  1308:                 sndByteBlock[dst + 366] = (byte) r;
  1309:                 sndByteBlock[dst + 367] = (byte) (r >> 8);
  1310:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1311:                 l = Math.max (-32768, Math.min (32767, 20 * OPM.opmBuffer[src + 238] + 96 * OPM.opmBuffer[src + 240] +  9 * OPM.opmBuffer[src + 242] + 64 >> 7));
  1312:                 r = Math.max (-32768, Math.min (32767, 20 * OPM.opmBuffer[src + 239] + 96 * OPM.opmBuffer[src + 241] +  9 * OPM.opmBuffer[src + 243] + 64 >> 7));
  1313:                 sndByteBlock[dst + 368] = (byte) l;
  1314:                 sndByteBlock[dst + 369] = (byte) (l >> 8);
  1315:                 sndByteBlock[dst + 370] = (byte) r;
  1316:                 sndByteBlock[dst + 371] = (byte) (r >> 8);
  1317:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1318:                 l = Math.max (-32768, Math.min (32767,                             87 * OPM.opmBuffer[src + 242] + 38 * OPM.opmBuffer[src + 244] + 64 >> 7));
  1319:                 r = Math.max (-32768, Math.min (32767,                             87 * OPM.opmBuffer[src + 243] + 38 * OPM.opmBuffer[src + 245] + 64 >> 7));
  1320:                 sndByteBlock[dst + 372] = (byte) l;
  1321:                 sndByteBlock[dst + 373] = (byte) (l >> 8);
  1322:                 sndByteBlock[dst + 374] = (byte) r;
  1323:                 sndByteBlock[dst + 375] = (byte) (r >> 8);
  1324:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1325:                 l = Math.max (-32768, Math.min (32767, 58 * OPM.opmBuffer[src + 244] + 67 * OPM.opmBuffer[src + 246]                             + 64 >> 7));
  1326:                 r = Math.max (-32768, Math.min (32767, 58 * OPM.opmBuffer[src + 245] + 67 * OPM.opmBuffer[src + 247]                             + 64 >> 7));
  1327:                 sndByteBlock[dst + 376] = (byte) l;
  1328:                 sndByteBlock[dst + 377] = (byte) (l >> 8);
  1329:                 sndByteBlock[dst + 378] = (byte) r;
  1330:                 sndByteBlock[dst + 379] = (byte) (r >> 8);
  1331:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1332:                 l = Math.max (-32768, Math.min (32767, 29 * OPM.opmBuffer[src + 246] + 96 * OPM.opmBuffer[src + 248]                             + 64 >> 7));
  1333:                 r = Math.max (-32768, Math.min (32767, 29 * OPM.opmBuffer[src + 247] + 96 * OPM.opmBuffer[src + 249]                             + 64 >> 7));
  1334:                 sndByteBlock[dst + 380] = (byte) l;
  1335:                 sndByteBlock[dst + 381] = (byte) (l >> 8);
  1336:                 sndByteBlock[dst + 382] = (byte) r;
  1337:                 sndByteBlock[dst + 383] = (byte) (r >> 8);
  1338:                 sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1339:         }  //for src,dst
  1340:       }  //convert(int)
  1341:     },  //SNDRateConverter.CONSTANT_AREA_STEREO_48000
  1342: 
  1343:     //線形面積補間
  1344:     //  S44PLAY.Xの-sqの方法
  1345:     //    S44PLAY.Xで-hqよりも-sqのほうが綺麗に聞こえた(ような気がした)のは線形補間よりも面積補間の方がローパスフィルタとしての性能が高かったからかも知れない
  1346:     //  入力データを線形補間した波形を出力サンプリング間隔で刻み、各断片の平均の変位(断片の面積に比例する)を出力データとする
  1347:     //  入力サンプリング位置における入力データと出力サンプリング位置における線形補間された入力データを台形の上辺または下辺と見なすと、
  1348:     //  線形補間された入力データを出力サンプリング間隔で刻んだ各断片は複数の台形を繋ぎ合わせた形になる
  1349:     //  台形の面積は(上辺+下辺)×高さ÷2であるから、断片の面積は近隣の入力データの線形結合で表現できる
  1350:     //  出力周波数が入力周波数の1/2倍～1倍のとき、1個の出力データを求めるために3個または4個の入力データが必要になる
  1351:     //  末尾のデータを作るために次のブロックの先頭のデータが必要になるが、代わりに前のブロックの末尾のデータをブロックの先頭に加える
  1352:     //  OPMとPCMを合成するときにずらせばオーバーヘッドは最小限で済む
  1353:     //  7Hz→5Hzの場合
  1354:     //    a....b....c....d....e....f....g....h
  1355:     //    AAAAAAABBBBBBBCCCCCCCDDDDDDDEEEEEEE
  1356:     //      A=(( a + b )* 5 /2+( b + (3*b+2*c)/5 )* 2 /2)/7                           = 5/14*a + 41/70*b + 2/35*c
  1357:     //      B=(( (3*b+2*c)/5 + c )* 3 /2+( c + (1*c+4*d)/5 )* 4 /2)/7                 = 9/70*b + 9/14*c + 8/35*d
  1358:     //      C=(( (1*c+4*d)/5 + d )* 1 /2+( d + e )* 5 /2+( e + (4*e+1*f)/5 )* 1 /2)/7 = 1/70*c + 17/35*d + 17/35*e + 1/70*f
  1359:     //      D=(( (4*e+1*f)/5 + f )* 4 /2+( f + (2*f+3*g)/5 )* 3 /2)/7                 = 8/35*e + 9/14*f + 9/70*g
  1360:     //      E=(( (2*f+3*g)/5 + g )* 2 /2+( g + h )* 5 /2)/7                           = 2/35*f + 41/70*g + 5/14*h
  1361:     //    perl -e "$m=7;$n=5;@w=();for$i(0..$m){$k=$n*$i;push@w,[$k,'s['.$i.']']}for$j(0..$n-1){$k=$m*$j;$r=$k%$n;$r or next;$q=($k-$r)/$n;push@w,[$k,'('.($n-$r).'*s['.$q.']+'.$r.'*s['.($q+1).'])/'.$n]}@w=sort{$a->[0]<=>$b->[0]}@w;for$j(0..$n-1){$k=$m*$j;@v=grep{$k<=$_->[0]&&$_->[0]<=$k+$m}@w;@d=();for$i(0..@v-2){push@d,'('.$v[$i]->[1].'+'.$v[$i+1]->[1].')*'.($v[$i+1]->[0]-$v[$i]->[0]).'/2'}printf'    //      d[%d]=(%s)/%d;%c',$j,join('+',@d),$m,10}"
  1362:     //      d[0]=((s[0]+s[1])*5/2+(s[1]+(3*s[1]+2*s[2])/5)*2/2)/7;
  1363:     //      d[1]=(((3*s[1]+2*s[2])/5+s[2])*3/2+(s[2]+(1*s[2]+4*s[3])/5)*4/2)/7;
  1364:     //      d[2]=(((1*s[2]+4*s[3])/5+s[3])*1/2+(s[3]+s[4])*5/2+(s[4]+(4*s[4]+1*s[5])/5)*1/2)/7;
  1365:     //      d[3]=(((4*s[4]+1*s[5])/5+s[5])*4/2+(s[5]+(2*s[5]+3*s[6])/5)*3/2)/7;
  1366:     //      d[4]=(((2*s[5]+3*s[6])/5+s[6])*2/2+(s[6]+s[7])*5/2)/7;
  1367:     //    perl -e "$m=7;$n=5;sub str{my($t)=@_;my@s=();for my$k(sort{$a<=>$b}keys%$t){push@s,$t->{$k}.'*s['.$k.']'}join'+',@s}sub mul{my($t,$m)=@_;my$p={};for my$k(keys%$t){$p->{$k}=$t->{$k}*$m}$p}sub add{my($t,$u)=@_;my$s={};for my$k(keys%$t){$s->{$k}=$t->{$k}};for my$k(keys%$u){$s->{$k}=($s->{$k}//0)+$u->{$k}}$s}@w=();for$i(0..$m){$k=$n*$i;$t={};$t->{$i}=1;push@w,[$k,$t]}for$j(0..$n-1){$k=$m*$j;$r=$k%$n;$r or next;$q=($k-$r)/$n;$t={};$t->{$q}=($n-$r)/$n;$t->{$q+1}=$r/$n;push@w,[$k,$t];}@w=sort{$a->[0]<=>$b->[0]}@w;for$j(0..$n-1){$k=$m*$j;@v=grep{$k<=$_->[0]&&$_->[0]<=$k+$m}@w;$d={};for$i(0..@v-2){$d=add($d,mul(add($v[$i]->[1],$v[$i+1]->[1]),($v[$i+1]->[0]-$v[$i]->[0])))}$d=mul($d,1/(2*$m));printf'    //      d[%d]=%s;%c',$j,str($d),10}"
  1368:     //      d[0]=0.357142857142857*s[0]+0.585714285714286*s[1]+0.0571428571428571*s[2];
  1369:     //      d[1]=0.128571428571429*s[1]+0.642857142857143*s[2]+0.228571428571429*s[3];
  1370:     //      d[2]=0.0142857142857143*s[2]+0.485714285714286*s[3]+0.485714285714286*s[4]+0.0142857142857143*s[5];
  1371:     //      d[3]=0.228571428571429*s[4]+0.642857142857143*s[5]+0.128571428571429*s[6];
  1372:     //      d[4]=0.0571428571428571*s[5]+0.585714285714286*s[6]+0.357142857142857*s[7];
  1373: 
  1374:     //線形面積補間,ステレオ,48kHz
  1375:     LINEAR_AREA_STEREO_48000 {
  1376:       @Override public void convert (int outputSamples) {
  1377:         if (false) {  //long
  1378:           //OPMとPCMを合わせてボリュームを掛ける。ついでに後ろに1サンプルずらす
  1379:           int l = OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES    ];  //前回の最後のデータ
  1380:           int r = OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES + 1];
  1381:           for (int src = 0; src < 2 * OPM.OPM_BLOCK_SAMPLES; src += 2) {
  1382:             int t;
  1383:             t = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src    ] + ADPCM.pcmBuffer[src    ] :
  1384:                  OPM.OPM_ON           ? OPM.opmBuffer[src    ]                      :
  1385:                  ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src    ] :
  1386:                  0) * sndCurrentScale >> 12;
  1387:             OPM.opmBuffer[src    ] = l;
  1388:             l = t;
  1389:             t = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src + 1] + ADPCM.pcmBuffer[src + 1] :
  1390:                  OPM.OPM_ON           ? OPM.opmBuffer[src + 1]                      :
  1391:                  ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src + 1] :
  1392:                  0) * sndCurrentScale >> 12;
  1393:             OPM.opmBuffer[src + 1] = r;
  1394:             r = t;
  1395:             sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  1396:           }
  1397:           OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES    ] = l;  //今回の最後のデータ
  1398:           OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES + 1] = r;
  1399:           //線形面積補間(long)
  1400:           //  通分したときの分母は2*125*96=24000だが、24000*11=264000≒262144=1<<18なので、
  1401:           //  24000で割る代わりに係数を11倍して除算を右18bitシフトで済ませている
  1402:           //  本来の値よりもわずかに大きい値(264000/242144倍)が出力される
  1403:           for (int src = 0, dst = 0; src < 2 * OPM.OPM_BLOCK_SAMPLES; src += 2 * 125, dst += 4 * 96) {
  1404:             int t;
  1405:             long u, v;
  1406:             //  perl -e "$m=125;$n=96;$CH=2;$I=12;sub str{my($t,$lr)=@_;my@s=();for my$k(sort{$a<=>$b}keys%$t){push@s,$t->{$k}.'L * OPM.opmBuffer[src'.($CH*$k+$lr?' + '.($CH*$k+$lr):'').']'}join' + ',@s}sub mul{my($t,$m)=@_;my$p={};for my$k(keys%$t){$p->{$k}=$t->{$k}*$m}$p}sub add{my($t,$u)=@_;my$s={};for my$k(keys%$t){$s->{$k}=$t->{$k}};for my$k(keys%$u){$s->{$k}=($s->{$k}//0)+$u->{$k}}$s}@out=();@w=();for$i(0..$m){$k=$n*$i;$t={};$t->{$i}=1;push@w,[$k,$t]}for$j(0..$n-1){$k=$m*$j;$r=$k%$n;$r or next;$q=($k-$r)/$n;$t={};$t->{$q}=($n-$r)/$n;$t->{$q+1}=$r/$n;push@w,[$k,$t];}@w=sort{$a->[0]<=>$b->[0]}@w;for$lr(0..$CH-1){push@out,sprintf'%*s//%s%c',$I,'',$CH==1?'mid':$lr?'right':'left',10;for$j(0..$n-1){$k=$m*$j;@v=grep{$k<=$_->[0]&&$_->[0]<=$k+$m}@w;$d={};for$i(0..@v-2){$d=add($d,mul(add($v[$i]->[1],$v[$i+1]->[1]),($v[$i+1]->[0]-$v[$i]->[0])))}$d=mul($d,11*$n);push@out,sprintf'%*st = Math.max (-32768, Math.min (32767, (int) (%s + 131072L >> 18)));%c',$I,'',str($d,$lr),10;push@out,sprintf'%*ssndByteBlock[dst'.(2*($CH*$j+$lr)+0?' + '.(2*($CH*$j+$lr)+0):'').'] = (byte) t;%c',$I,'',10;push@out,sprintf'%*ssndByteBlock[dst + '.(2*($CH*$j+$lr)+1).'] = (byte) (t >> 8);%c',$I,'',10;}}$out=join'',@out;$out2='';%flag=();while($out=~/OPM.opmBuffer\[src(?: \+ (\d+))?\]/){$out2.=$`;$out=$';$s=$&;$i=int(($1//0)/$CH);if($i==0||$i==$m){$out2.='(long) '.$s}else{$uv=$i%2?'v':'u';if(exists$flag{$s}){$out2.=$uv}else{$flag{$s}=1;$out2.='('.$uv.' = (long) '.$s.')'}}}$out2.=$out;print$out2"
  1407:             //left
  1408:             t = Math.max (-32768, Math.min (32767, (int) (101376L * (long) OPM.opmBuffer[src] + 153373L * (v = (long) OPM.opmBuffer[src + 2]) + 9251L * (u = (long) OPM.opmBuffer[src + 4]) + 131072L >> 18)));
  1409:             sndByteBlock[dst] = (byte) t;
  1410:             sndByteBlock[dst + 1] = (byte) (t >> 8);
  1411:             t = Math.max (-32768, Math.min (32767, (int) (49379L * v + 177617L * u + 37004L * (v = (long) OPM.opmBuffer[src + 6]) + 131072L >> 18)));
  1412:             sndByteBlock[dst + 4] = (byte) t;
  1413:             sndByteBlock[dst + 5] = (byte) (t >> 8);
  1414:             t = Math.max (-32768, Math.min (32767, (int) (15884L * u + 164857L * v + 83259L * (u = (long) OPM.opmBuffer[src + 8]) + 131072L >> 18)));
  1415:             sndByteBlock[dst + 8] = (byte) t;
  1416:             sndByteBlock[dst + 9] = (byte) (t >> 8);
  1417:             t = Math.max (-32768, Math.min (32767, (int) (891L * v + 119493L * u + 139216L * (v = (long) OPM.opmBuffer[src + 10]) + 4400L * (u = (long) OPM.opmBuffer[src + 12]) + 131072L >> 18)));
  1418:             sndByteBlock[dst + 12] = (byte) t;
  1419:             sndByteBlock[dst + 13] = (byte) (t >> 8);
  1420:             t = Math.max (-32768, Math.min (32767, (int) (63536L * v + 174053L * u + 26411L * (v = (long) OPM.opmBuffer[src + 14]) + 131072L >> 18)));
  1421:             sndByteBlock[dst + 16] = (byte) t;
  1422:             sndByteBlock[dst + 17] = (byte) (t >> 8);
  1423:             t = Math.max (-32768, Math.min (32767, (int) (24299L * u + 172777L * v + 66924L * (u = (long) OPM.opmBuffer[src + 16]) + 131072L >> 18)));
  1424:             sndByteBlock[dst + 20] = (byte) t;
  1425:             sndByteBlock[dst + 21] = (byte) (t >> 8);
  1426:             t = Math.max (-32768, Math.min (32767, (int) (3564L * v + 135828L * u + 123277L * (v = (long) OPM.opmBuffer[src + 18]) + 1331L * (u = (long) OPM.opmBuffer[src + 20]) + 131072L >> 18)));
  1427:             sndByteBlock[dst + 24] = (byte) t;
  1428:             sndByteBlock[dst + 25] = (byte) (t >> 8);
  1429:             t = Math.max (-32768, Math.min (32767, (int) (79475L * v + 166925L * u + 17600L * (v = (long) OPM.opmBuffer[src + 22]) + 131072L >> 18)));
  1430:             sndByteBlock[dst + 28] = (byte) t;
  1431:             sndByteBlock[dst + 29] = (byte) (t >> 8);
  1432:             t = Math.max (-32768, Math.min (32767, (int) (34496L * u + 177133L * v + 52371L * (u = (long) OPM.opmBuffer[src + 24]) + 131072L >> 18)));
  1433:             sndByteBlock[dst + 32] = (byte) t;
  1434:             sndByteBlock[dst + 33] = (byte) (t >> 8);
  1435:             t = Math.max (-32768, Math.min (32767, (int) (8019L * v + 150381L * u + 105556L * (v = (long) OPM.opmBuffer[src + 26]) + 44L * (u = (long) OPM.opmBuffer[src + 28]) + 131072L >> 18)));
  1436:             sndByteBlock[dst + 36] = (byte) t;
  1437:             sndByteBlock[dst + 37] = (byte) (t >> 8);
  1438:             t = Math.max (-32768, Math.min (32767, (int) (97196L * v + 156233L * u + 10571L * (v = (long) OPM.opmBuffer[src + 30]) + 131072L >> 18)));
  1439:             sndByteBlock[dst + 40] = (byte) t;
  1440:             sndByteBlock[dst + 41] = (byte) (t >> 8);
  1441:             t = Math.max (-32768, Math.min (32767, (int) (46475L * u + 177925L * v + 39600L * (u = (long) OPM.opmBuffer[src + 32]) + 131072L >> 18)));
  1442:             sndByteBlock[dst + 44] = (byte) t;
  1443:             sndByteBlock[dst + 45] = (byte) (t >> 8);
  1444:             t = Math.max (-32768, Math.min (32767, (int) (14256L * v + 162613L * u + 87131L * (v = (long) OPM.opmBuffer[src + 34]) + 131072L >> 18)));
  1445:             sndByteBlock[dst + 48] = (byte) t;
  1446:             sndByteBlock[dst + 49] = (byte) (t >> 8);
  1447:             t = Math.max (-32768, Math.min (32767, (int) (539L * u + 115621L * v + 142516L * (u = (long) OPM.opmBuffer[src + 36]) + 5324L * (v = (long) OPM.opmBuffer[src + 38]) + 131072L >> 18)));
  1448:             sndByteBlock[dst + 52] = (byte) t;
  1449:             sndByteBlock[dst + 53] = (byte) (t >> 8);
  1450:             t = Math.max (-32768, Math.min (32767, (int) (60236L * u + 175153L * v + 28611L * (u = (long) OPM.opmBuffer[src + 40]) + 131072L >> 18)));
  1451:             sndByteBlock[dst + 56] = (byte) t;
  1452:             sndByteBlock[dst + 57] = (byte) (t >> 8);
  1453:             t = Math.max (-32768, Math.min (32767, (int) (22275L * v + 171325L * u + 70400L * (v = (long) OPM.opmBuffer[src + 42]) + 131072L >> 18)));
  1454:             sndByteBlock[dst + 60] = (byte) t;
  1455:             sndByteBlock[dst + 61] = (byte) (t >> 8);
  1456:             t = Math.max (-32768, Math.min (32767, (int) (2816L * u + 132352L * v + 126973L * (u = (long) OPM.opmBuffer[src + 44]) + 1859L * (v = (long) OPM.opmBuffer[src + 46]) + 131072L >> 18)));
  1457:             sndByteBlock[dst + 64] = (byte) t;
  1458:             sndByteBlock[dst + 65] = (byte) (t >> 8);
  1459:             t = Math.max (-32768, Math.min (32767, (int) (75779L * u + 168817L * v + 19404L * (u = (long) OPM.opmBuffer[src + 48]) + 131072L >> 18)));
  1460:             sndByteBlock[dst + 68] = (byte) t;
  1461:             sndByteBlock[dst + 69] = (byte) (t >> 8);
  1462:             t = Math.max (-32768, Math.min (32767, (int) (32076L * v + 176473L * u + 55451L * (v = (long) OPM.opmBuffer[src + 50]) + 131072L >> 18)));
  1463:             sndByteBlock[dst + 72] = (byte) t;
  1464:             sndByteBlock[dst + 73] = (byte) (t >> 8);
  1465:             t = Math.max (-32768, Math.min (32767, (int) (6875L * u + 147301L * v + 109648L * (u = (long) OPM.opmBuffer[src + 52]) + 176L * (v = (long) OPM.opmBuffer[src + 54]) + 131072L >> 18)));
  1466:             sndByteBlock[dst + 76] = (byte) t;
  1467:             sndByteBlock[dst + 77] = (byte) (t >> 8);
  1468:             t = Math.max (-32768, Math.min (32767, (int) (93104L * u + 158917L * v + 11979L * (u = (long) OPM.opmBuffer[src + 56]) + 131072L >> 18)));
  1469:             sndByteBlock[dst + 80] = (byte) t;
  1470:             sndByteBlock[dst + 81] = (byte) (t >> 8);
  1471:             t = Math.max (-32768, Math.min (32767, (int) (43659L * v + 178057L * u + 42284L * (v = (long) OPM.opmBuffer[src + 58]) + 131072L >> 18)));
  1472:             sndByteBlock[dst + 84] = (byte) t;
  1473:             sndByteBlock[dst + 85] = (byte) (t >> 8);
  1474:             t = Math.max (-32768, Math.min (32767, (int) (12716L * u + 160193L * v + 91091L * (u = (long) OPM.opmBuffer[src + 60]) + 131072L >> 18)));
  1475:             sndByteBlock[dst + 88] = (byte) t;
  1476:             sndByteBlock[dst + 89] = (byte) (t >> 8);
  1477:             t = Math.max (-32768, Math.min (32767, (int) (275L * v + 111661L * u + 145728L * (v = (long) OPM.opmBuffer[src + 62]) + 6336L * (u = (long) OPM.opmBuffer[src + 64]) + 131072L >> 18)));
  1478:             sndByteBlock[dst + 92] = (byte) t;
  1479:             sndByteBlock[dst + 93] = (byte) (t >> 8);
  1480:             t = Math.max (-32768, Math.min (32767, (int) (57024L * v + 176077L * u + 30899L * (v = (long) OPM.opmBuffer[src + 66]) + 131072L >> 18)));
  1481:             sndByteBlock[dst + 96] = (byte) t;
  1482:             sndByteBlock[dst + 97] = (byte) (t >> 8);
  1483:             t = Math.max (-32768, Math.min (32767, (int) (20339L * u + 169697L * v + 73964L * (u = (long) OPM.opmBuffer[src + 68]) + 131072L >> 18)));
  1484:             sndByteBlock[dst + 100] = (byte) t;
  1485:             sndByteBlock[dst + 101] = (byte) (t >> 8);
  1486:             t = Math.max (-32768, Math.min (32767, (int) (2156L * v + 128788L * u + 130581L * (v = (long) OPM.opmBuffer[src + 70]) + 2475L * (u = (long) OPM.opmBuffer[src + 72]) + 131072L >> 18)));
  1487:             sndByteBlock[dst + 104] = (byte) t;
  1488:             sndByteBlock[dst + 105] = (byte) (t >> 8);
  1489:             t = Math.max (-32768, Math.min (32767, (int) (72171L * v + 170533L * u + 21296L * (v = (long) OPM.opmBuffer[src + 74]) + 131072L >> 18)));
  1490:             sndByteBlock[dst + 108] = (byte) t;
  1491:             sndByteBlock[dst + 109] = (byte) (t >> 8);
  1492:             t = Math.max (-32768, Math.min (32767, (int) (29744L * u + 175637L * v + 58619L * (u = (long) OPM.opmBuffer[src + 76]) + 131072L >> 18)));
  1493:             sndByteBlock[dst + 112] = (byte) t;
  1494:             sndByteBlock[dst + 113] = (byte) (t >> 8);
  1495:             t = Math.max (-32768, Math.min (32767, (int) (5819L * v + 144133L * u + 113652L * (v = (long) OPM.opmBuffer[src + 78]) + 396L * (u = (long) OPM.opmBuffer[src + 80]) + 131072L >> 18)));
  1496:             sndByteBlock[dst + 116] = (byte) t;
  1497:             sndByteBlock[dst + 117] = (byte) (t >> 8);
  1498:             t = Math.max (-32768, Math.min (32767, (int) (89100L * v + 161425L * u + 13475L * (v = (long) OPM.opmBuffer[src + 82]) + 131072L >> 18)));
  1499:             sndByteBlock[dst + 120] = (byte) t;
  1500:             sndByteBlock[dst + 121] = (byte) (t >> 8);
  1501:             t = Math.max (-32768, Math.min (32767, (int) (40931L * u + 178013L * v + 45056L * (u = (long) OPM.opmBuffer[src + 84]) + 131072L >> 18)));
  1502:             sndByteBlock[dst + 124] = (byte) t;
  1503:             sndByteBlock[dst + 125] = (byte) (t >> 8);
  1504:             t = Math.max (-32768, Math.min (32767, (int) (11264L * v + 157597L * u + 95139L * (v = (long) OPM.opmBuffer[src + 86]) + 131072L >> 18)));
  1505:             sndByteBlock[dst + 128] = (byte) t;
  1506:             sndByteBlock[dst + 129] = (byte) (t >> 8);
  1507:             t = Math.max (-32768, Math.min (32767, (int) (99L * u + 107613L * v + 148852L * (u = (long) OPM.opmBuffer[src + 88]) + 7436L * (v = (long) OPM.opmBuffer[src + 90]) + 131072L >> 18)));
  1508:             sndByteBlock[dst + 132] = (byte) t;
  1509:             sndByteBlock[dst + 133] = (byte) (t >> 8);
  1510:             t = Math.max (-32768, Math.min (32767, (int) (53900L * u + 176825L * v + 33275L * (u = (long) OPM.opmBuffer[src + 92]) + 131072L >> 18)));
  1511:             sndByteBlock[dst + 136] = (byte) t;
  1512:             sndByteBlock[dst + 137] = (byte) (t >> 8);
  1513:             t = Math.max (-32768, Math.min (32767, (int) (18491L * v + 167893L * u + 77616L * (v = (long) OPM.opmBuffer[src + 94]) + 131072L >> 18)));
  1514:             sndByteBlock[dst + 140] = (byte) t;
  1515:             sndByteBlock[dst + 141] = (byte) (t >> 8);
  1516:             t = Math.max (-32768, Math.min (32767, (int) (1584L * u + 125136L * v + 134101L * (u = (long) OPM.opmBuffer[src + 96]) + 3179L * (v = (long) OPM.opmBuffer[src + 98]) + 131072L >> 18)));
  1517:             sndByteBlock[dst + 144] = (byte) t;
  1518:             sndByteBlock[dst + 145] = (byte) (t >> 8);
  1519:             t = Math.max (-32768, Math.min (32767, (int) (68651L * u + 172073L * v + 23276L * (u = (long) OPM.opmBuffer[src + 100]) + 131072L >> 18)));
  1520:             sndByteBlock[dst + 148] = (byte) t;
  1521:             sndByteBlock[dst + 149] = (byte) (t >> 8);
  1522:             t = Math.max (-32768, Math.min (32767, (int) (27500L * v + 174625L * u + 61875L * (v = (long) OPM.opmBuffer[src + 102]) + 131072L >> 18)));
  1523:             sndByteBlock[dst + 152] = (byte) t;
  1524:             sndByteBlock[dst + 153] = (byte) (t >> 8);
  1525:             t = Math.max (-32768, Math.min (32767, (int) (4851L * u + 140877L * v + 117568L * (u = (long) OPM.opmBuffer[src + 104]) + 704L * (v = (long) OPM.opmBuffer[src + 106]) + 131072L >> 18)));
  1526:             sndByteBlock[dst + 156] = (byte) t;
  1527:             sndByteBlock[dst + 157] = (byte) (t >> 8);
  1528:             t = Math.max (-32768, Math.min (32767, (int) (85184L * u + 163757L * v + 15059L * (u = (long) OPM.opmBuffer[src + 108]) + 131072L >> 18)));
  1529:             sndByteBlock[dst + 160] = (byte) t;
  1530:             sndByteBlock[dst + 161] = (byte) (t >> 8);
  1531:             t = Math.max (-32768, Math.min (32767, (int) (38291L * v + 177793L * u + 47916L * (v = (long) OPM.opmBuffer[src + 110]) + 131072L >> 18)));
  1532:             sndByteBlock[dst + 164] = (byte) t;
  1533:             sndByteBlock[dst + 165] = (byte) (t >> 8);
  1534:             t = Math.max (-32768, Math.min (32767, (int) (9900L * u + 154825L * v + 99275L * (u = (long) OPM.opmBuffer[src + 112]) + 131072L >> 18)));
  1535:             sndByteBlock[dst + 168] = (byte) t;
  1536:             sndByteBlock[dst + 169] = (byte) (t >> 8);
  1537:             t = Math.max (-32768, Math.min (32767, (int) (11L * v + 103477L * u + 151888L * (v = (long) OPM.opmBuffer[src + 114]) + 8624L * (u = (long) OPM.opmBuffer[src + 116]) + 131072L >> 18)));
  1538:             sndByteBlock[dst + 172] = (byte) t;
  1539:             sndByteBlock[dst + 173] = (byte) (t >> 8);
  1540:             t = Math.max (-32768, Math.min (32767, (int) (50864L * v + 177397L * u + 35739L * (v = (long) OPM.opmBuffer[src + 118]) + 131072L >> 18)));
  1541:             sndByteBlock[dst + 176] = (byte) t;
  1542:             sndByteBlock[dst + 177] = (byte) (t >> 8);
  1543:             t = Math.max (-32768, Math.min (32767, (int) (16731L * u + 165913L * v + 81356L * (u = (long) OPM.opmBuffer[src + 120]) + 131072L >> 18)));
  1544:             sndByteBlock[dst + 180] = (byte) t;
  1545:             sndByteBlock[dst + 181] = (byte) (t >> 8);
  1546:             t = Math.max (-32768, Math.min (32767, (int) (1100L * v + 121396L * u + 137533L * (v = (long) OPM.opmBuffer[src + 122]) + 3971L * (u = (long) OPM.opmBuffer[src + 124]) + 131072L >> 18)));
  1547:             sndByteBlock[dst + 184] = (byte) t;
  1548:             sndByteBlock[dst + 185] = (byte) (t >> 8);
  1549:             t = Math.max (-32768, Math.min (32767, (int) (65219L * v + 173437L * u + 25344L * (v = (long) OPM.opmBuffer[src + 126]) + 131072L >> 18)));
  1550:             sndByteBlock[dst + 188] = (byte) t;
  1551:             sndByteBlock[dst + 189] = (byte) (t >> 8);
  1552:             t = Math.max (-32768, Math.min (32767, (int) (25344L * u + 173437L * v + 65219L * (u = (long) OPM.opmBuffer[src + 128]) + 131072L >> 18)));
  1553:             sndByteBlock[dst + 192] = (byte) t;
  1554:             sndByteBlock[dst + 193] = (byte) (t >> 8);
  1555:             t = Math.max (-32768, Math.min (32767, (int) (3971L * v + 137533L * u + 121396L * (v = (long) OPM.opmBuffer[src + 130]) + 1100L * (u = (long) OPM.opmBuffer[src + 132]) + 131072L >> 18)));
  1556:             sndByteBlock[dst + 196] = (byte) t;
  1557:             sndByteBlock[dst + 197] = (byte) (t >> 8);
  1558:             t = Math.max (-32768, Math.min (32767, (int) (81356L * v + 165913L * u + 16731L * (v = (long) OPM.opmBuffer[src + 134]) + 131072L >> 18)));
  1559:             sndByteBlock[dst + 200] = (byte) t;
  1560:             sndByteBlock[dst + 201] = (byte) (t >> 8);
  1561:             t = Math.max (-32768, Math.min (32767, (int) (35739L * u + 177397L * v + 50864L * (u = (long) OPM.opmBuffer[src + 136]) + 131072L >> 18)));
  1562:             sndByteBlock[dst + 204] = (byte) t;
  1563:             sndByteBlock[dst + 205] = (byte) (t >> 8);
  1564:             t = Math.max (-32768, Math.min (32767, (int) (8624L * v + 151888L * u + 103477L * (v = (long) OPM.opmBuffer[src + 138]) + 11L * (u = (long) OPM.opmBuffer[src + 140]) + 131072L >> 18)));
  1565:             sndByteBlock[dst + 208] = (byte) t;
  1566:             sndByteBlock[dst + 209] = (byte) (t >> 8);
  1567:             t = Math.max (-32768, Math.min (32767, (int) (99275L * v + 154825L * u + 9900L * (v = (long) OPM.opmBuffer[src + 142]) + 131072L >> 18)));
  1568:             sndByteBlock[dst + 212] = (byte) t;
  1569:             sndByteBlock[dst + 213] = (byte) (t >> 8);
  1570:             t = Math.max (-32768, Math.min (32767, (int) (47916L * u + 177793L * v + 38291L * (u = (long) OPM.opmBuffer[src + 144]) + 131072L >> 18)));
  1571:             sndByteBlock[dst + 216] = (byte) t;
  1572:             sndByteBlock[dst + 217] = (byte) (t >> 8);
  1573:             t = Math.max (-32768, Math.min (32767, (int) (15059L * v + 163757L * u + 85184L * (v = (long) OPM.opmBuffer[src + 146]) + 131072L >> 18)));
  1574:             sndByteBlock[dst + 220] = (byte) t;
  1575:             sndByteBlock[dst + 221] = (byte) (t >> 8);
  1576:             t = Math.max (-32768, Math.min (32767, (int) (704L * u + 117568L * v + 140877L * (u = (long) OPM.opmBuffer[src + 148]) + 4851L * (v = (long) OPM.opmBuffer[src + 150]) + 131072L >> 18)));
  1577:             sndByteBlock[dst + 224] = (byte) t;
  1578:             sndByteBlock[dst + 225] = (byte) (t >> 8);
  1579:             t = Math.max (-32768, Math.min (32767, (int) (61875L * u + 174625L * v + 27500L * (u = (long) OPM.opmBuffer[src + 152]) + 131072L >> 18)));
  1580:             sndByteBlock[dst + 228] = (byte) t;
  1581:             sndByteBlock[dst + 229] = (byte) (t >> 8);
  1582:             t = Math.max (-32768, Math.min (32767, (int) (23276L * v + 172073L * u + 68651L * (v = (long) OPM.opmBuffer[src + 154]) + 131072L >> 18)));
  1583:             sndByteBlock[dst + 232] = (byte) t;
  1584:             sndByteBlock[dst + 233] = (byte) (t >> 8);
  1585:             t = Math.max (-32768, Math.min (32767, (int) (3179L * u + 134101L * v + 125136L * (u = (long) OPM.opmBuffer[src + 156]) + 1584L * (v = (long) OPM.opmBuffer[src + 158]) + 131072L >> 18)));
  1586:             sndByteBlock[dst + 236] = (byte) t;
  1587:             sndByteBlock[dst + 237] = (byte) (t >> 8);
  1588:             t = Math.max (-32768, Math.min (32767, (int) (77616L * u + 167893L * v + 18491L * (u = (long) OPM.opmBuffer[src + 160]) + 131072L >> 18)));
  1589:             sndByteBlock[dst + 240] = (byte) t;
  1590:             sndByteBlock[dst + 241] = (byte) (t >> 8);
  1591:             t = Math.max (-32768, Math.min (32767, (int) (33275L * v + 176825L * u + 53900L * (v = (long) OPM.opmBuffer[src + 162]) + 131072L >> 18)));
  1592:             sndByteBlock[dst + 244] = (byte) t;
  1593:             sndByteBlock[dst + 245] = (byte) (t >> 8);
  1594:             t = Math.max (-32768, Math.min (32767, (int) (7436L * u + 148852L * v + 107613L * (u = (long) OPM.opmBuffer[src + 164]) + 99L * (v = (long) OPM.opmBuffer[src + 166]) + 131072L >> 18)));
  1595:             sndByteBlock[dst + 248] = (byte) t;
  1596:             sndByteBlock[dst + 249] = (byte) (t >> 8);
  1597:             t = Math.max (-32768, Math.min (32767, (int) (95139L * u + 157597L * v + 11264L * (u = (long) OPM.opmBuffer[src + 168]) + 131072L >> 18)));
  1598:             sndByteBlock[dst + 252] = (byte) t;
  1599:             sndByteBlock[dst + 253] = (byte) (t >> 8);
  1600:             t = Math.max (-32768, Math.min (32767, (int) (45056L * v + 178013L * u + 40931L * (v = (long) OPM.opmBuffer[src + 170]) + 131072L >> 18)));
  1601:             sndByteBlock[dst + 256] = (byte) t;
  1602:             sndByteBlock[dst + 257] = (byte) (t >> 8);
  1603:             t = Math.max (-32768, Math.min (32767, (int) (13475L * u + 161425L * v + 89100L * (u = (long) OPM.opmBuffer[src + 172]) + 131072L >> 18)));
  1604:             sndByteBlock[dst + 260] = (byte) t;
  1605:             sndByteBlock[dst + 261] = (byte) (t >> 8);
  1606:             t = Math.max (-32768, Math.min (32767, (int) (396L * v + 113652L * u + 144133L * (v = (long) OPM.opmBuffer[src + 174]) + 5819L * (u = (long) OPM.opmBuffer[src + 176]) + 131072L >> 18)));
  1607:             sndByteBlock[dst + 264] = (byte) t;
  1608:             sndByteBlock[dst + 265] = (byte) (t >> 8);
  1609:             t = Math.max (-32768, Math.min (32767, (int) (58619L * v + 175637L * u + 29744L * (v = (long) OPM.opmBuffer[src + 178]) + 131072L >> 18)));
  1610:             sndByteBlock[dst + 268] = (byte) t;
  1611:             sndByteBlock[dst + 269] = (byte) (t >> 8);
  1612:             t = Math.max (-32768, Math.min (32767, (int) (21296L * u + 170533L * v + 72171L * (u = (long) OPM.opmBuffer[src + 180]) + 131072L >> 18)));
  1613:             sndByteBlock[dst + 272] = (byte) t;
  1614:             sndByteBlock[dst + 273] = (byte) (t >> 8);
  1615:             t = Math.max (-32768, Math.min (32767, (int) (2475L * v + 130581L * u + 128788L * (v = (long) OPM.opmBuffer[src + 182]) + 2156L * (u = (long) OPM.opmBuffer[src + 184]) + 131072L >> 18)));
  1616:             sndByteBlock[dst + 276] = (byte) t;
  1617:             sndByteBlock[dst + 277] = (byte) (t >> 8);
  1618:             t = Math.max (-32768, Math.min (32767, (int) (73964L * v + 169697L * u + 20339L * (v = (long) OPM.opmBuffer[src + 186]) + 131072L >> 18)));
  1619:             sndByteBlock[dst + 280] = (byte) t;
  1620:             sndByteBlock[dst + 281] = (byte) (t >> 8);
  1621:             t = Math.max (-32768, Math.min (32767, (int) (30899L * u + 176077L * v + 57024L * (u = (long) OPM.opmBuffer[src + 188]) + 131072L >> 18)));
  1622:             sndByteBlock[dst + 284] = (byte) t;
  1623:             sndByteBlock[dst + 285] = (byte) (t >> 8);
  1624:             t = Math.max (-32768, Math.min (32767, (int) (6336L * v + 145728L * u + 111661L * (v = (long) OPM.opmBuffer[src + 190]) + 275L * (u = (long) OPM.opmBuffer[src + 192]) + 131072L >> 18)));
  1625:             sndByteBlock[dst + 288] = (byte) t;
  1626:             sndByteBlock[dst + 289] = (byte) (t >> 8);
  1627:             t = Math.max (-32768, Math.min (32767, (int) (91091L * v + 160193L * u + 12716L * (v = (long) OPM.opmBuffer[src + 194]) + 131072L >> 18)));
  1628:             sndByteBlock[dst + 292] = (byte) t;
  1629:             sndByteBlock[dst + 293] = (byte) (t >> 8);
  1630:             t = Math.max (-32768, Math.min (32767, (int) (42284L * u + 178057L * v + 43659L * (u = (long) OPM.opmBuffer[src + 196]) + 131072L >> 18)));
  1631:             sndByteBlock[dst + 296] = (byte) t;
  1632:             sndByteBlock[dst + 297] = (byte) (t >> 8);
  1633:             t = Math.max (-32768, Math.min (32767, (int) (11979L * v + 158917L * u + 93104L * (v = (long) OPM.opmBuffer[src + 198]) + 131072L >> 18)));
  1634:             sndByteBlock[dst + 300] = (byte) t;
  1635:             sndByteBlock[dst + 301] = (byte) (t >> 8);
  1636:             t = Math.max (-32768, Math.min (32767, (int) (176L * u + 109648L * v + 147301L * (u = (long) OPM.opmBuffer[src + 200]) + 6875L * (v = (long) OPM.opmBuffer[src + 202]) + 131072L >> 18)));
  1637:             sndByteBlock[dst + 304] = (byte) t;
  1638:             sndByteBlock[dst + 305] = (byte) (t >> 8);
  1639:             t = Math.max (-32768, Math.min (32767, (int) (55451L * u + 176473L * v + 32076L * (u = (long) OPM.opmBuffer[src + 204]) + 131072L >> 18)));
  1640:             sndByteBlock[dst + 308] = (byte) t;
  1641:             sndByteBlock[dst + 309] = (byte) (t >> 8);
  1642:             t = Math.max (-32768, Math.min (32767, (int) (19404L * v + 168817L * u + 75779L * (v = (long) OPM.opmBuffer[src + 206]) + 131072L >> 18)));
  1643:             sndByteBlock[dst + 312] = (byte) t;
  1644:             sndByteBlock[dst + 313] = (byte) (t >> 8);
  1645:             t = Math.max (-32768, Math.min (32767, (int) (1859L * u + 126973L * v + 132352L * (u = (long) OPM.opmBuffer[src + 208]) + 2816L * (v = (long) OPM.opmBuffer[src + 210]) + 131072L >> 18)));
  1646:             sndByteBlock[dst + 316] = (byte) t;
  1647:             sndByteBlock[dst + 317] = (byte) (t >> 8);
  1648:             t = Math.max (-32768, Math.min (32767, (int) (70400L * u + 171325L * v + 22275L * (u = (long) OPM.opmBuffer[src + 212]) + 131072L >> 18)));
  1649:             sndByteBlock[dst + 320] = (byte) t;
  1650:             sndByteBlock[dst + 321] = (byte) (t >> 8);
  1651:             t = Math.max (-32768, Math.min (32767, (int) (28611L * v + 175153L * u + 60236L * (v = (long) OPM.opmBuffer[src + 214]) + 131072L >> 18)));
  1652:             sndByteBlock[dst + 324] = (byte) t;
  1653:             sndByteBlock[dst + 325] = (byte) (t >> 8);
  1654:             t = Math.max (-32768, Math.min (32767, (int) (5324L * u + 142516L * v + 115621L * (u = (long) OPM.opmBuffer[src + 216]) + 539L * (v = (long) OPM.opmBuffer[src + 218]) + 131072L >> 18)));
  1655:             sndByteBlock[dst + 328] = (byte) t;
  1656:             sndByteBlock[dst + 329] = (byte) (t >> 8);
  1657:             t = Math.max (-32768, Math.min (32767, (int) (87131L * u + 162613L * v + 14256L * (u = (long) OPM.opmBuffer[src + 220]) + 131072L >> 18)));
  1658:             sndByteBlock[dst + 332] = (byte) t;
  1659:             sndByteBlock[dst + 333] = (byte) (t >> 8);
  1660:             t = Math.max (-32768, Math.min (32767, (int) (39600L * v + 177925L * u + 46475L * (v = (long) OPM.opmBuffer[src + 222]) + 131072L >> 18)));
  1661:             sndByteBlock[dst + 336] = (byte) t;
  1662:             sndByteBlock[dst + 337] = (byte) (t >> 8);
  1663:             t = Math.max (-32768, Math.min (32767, (int) (10571L * u + 156233L * v + 97196L * (u = (long) OPM.opmBuffer[src + 224]) + 131072L >> 18)));
  1664:             sndByteBlock[dst + 340] = (byte) t;
  1665:             sndByteBlock[dst + 341] = (byte) (t >> 8);
  1666:             t = Math.max (-32768, Math.min (32767, (int) (44L * v + 105556L * u + 150381L * (v = (long) OPM.opmBuffer[src + 226]) + 8019L * (u = (long) OPM.opmBuffer[src + 228]) + 131072L >> 18)));
  1667:             sndByteBlock[dst + 344] = (byte) t;
  1668:             sndByteBlock[dst + 345] = (byte) (t >> 8);
  1669:             t = Math.max (-32768, Math.min (32767, (int) (52371L * v + 177133L * u + 34496L * (v = (long) OPM.opmBuffer[src + 230]) + 131072L >> 18)));
  1670:             sndByteBlock[dst + 348] = (byte) t;
  1671:             sndByteBlock[dst + 349] = (byte) (t >> 8);
  1672:             t = Math.max (-32768, Math.min (32767, (int) (17600L * u + 166925L * v + 79475L * (u = (long) OPM.opmBuffer[src + 232]) + 131072L >> 18)));
  1673:             sndByteBlock[dst + 352] = (byte) t;
  1674:             sndByteBlock[dst + 353] = (byte) (t >> 8);
  1675:             t = Math.max (-32768, Math.min (32767, (int) (1331L * v + 123277L * u + 135828L * (v = (long) OPM.opmBuffer[src + 234]) + 3564L * (u = (long) OPM.opmBuffer[src + 236]) + 131072L >> 18)));
  1676:             sndByteBlock[dst + 356] = (byte) t;
  1677:             sndByteBlock[dst + 357] = (byte) (t >> 8);
  1678:             t = Math.max (-32768, Math.min (32767, (int) (66924L * v + 172777L * u + 24299L * (v = (long) OPM.opmBuffer[src + 238]) + 131072L >> 18)));
  1679:             sndByteBlock[dst + 360] = (byte) t;
  1680:             sndByteBlock[dst + 361] = (byte) (t >> 8);
  1681:             t = Math.max (-32768, Math.min (32767, (int) (26411L * u + 174053L * v + 63536L * (u = (long) OPM.opmBuffer[src + 240]) + 131072L >> 18)));
  1682:             sndByteBlock[dst + 364] = (byte) t;
  1683:             sndByteBlock[dst + 365] = (byte) (t >> 8);
  1684:             t = Math.max (-32768, Math.min (32767, (int) (4400L * v + 139216L * u + 119493L * (v = (long) OPM.opmBuffer[src + 242]) + 891L * (u = (long) OPM.opmBuffer[src + 244]) + 131072L >> 18)));
  1685:             sndByteBlock[dst + 368] = (byte) t;
  1686:             sndByteBlock[dst + 369] = (byte) (t >> 8);
  1687:             t = Math.max (-32768, Math.min (32767, (int) (83259L * v + 164857L * u + 15884L * (v = (long) OPM.opmBuffer[src + 246]) + 131072L >> 18)));
  1688:             sndByteBlock[dst + 372] = (byte) t;
  1689:             sndByteBlock[dst + 373] = (byte) (t >> 8);
  1690:             t = Math.max (-32768, Math.min (32767, (int) (37004L * u + 177617L * v + 49379L * (u = (long) OPM.opmBuffer[src + 248]) + 131072L >> 18)));
  1691:             sndByteBlock[dst + 376] = (byte) t;
  1692:             sndByteBlock[dst + 377] = (byte) (t >> 8);
  1693:             t = Math.max (-32768, Math.min (32767, (int) (9251L * v + 153373L * u + 101376L * (long) OPM.opmBuffer[src + 250] + 131072L >> 18)));
  1694:             sndByteBlock[dst + 380] = (byte) t;
  1695:             sndByteBlock[dst + 381] = (byte) (t >> 8);
  1696:             //right
  1697:             t = Math.max (-32768, Math.min (32767, (int) (101376L * (long) OPM.opmBuffer[src + 1] + 153373L * (v = (long) OPM.opmBuffer[src + 3]) + 9251L * (u = (long) OPM.opmBuffer[src + 5]) + 131072L >> 18)));
  1698:             sndByteBlock[dst + 2] = (byte) t;
  1699:             sndByteBlock[dst + 3] = (byte) (t >> 8);
  1700:             t = Math.max (-32768, Math.min (32767, (int) (49379L * v + 177617L * u + 37004L * (v = (long) OPM.opmBuffer[src + 7]) + 131072L >> 18)));
  1701:             sndByteBlock[dst + 6] = (byte) t;
  1702:             sndByteBlock[dst + 7] = (byte) (t >> 8);
  1703:             t = Math.max (-32768, Math.min (32767, (int) (15884L * u + 164857L * v + 83259L * (u = (long) OPM.opmBuffer[src + 9]) + 131072L >> 18)));
  1704:             sndByteBlock[dst + 10] = (byte) t;
  1705:             sndByteBlock[dst + 11] = (byte) (t >> 8);
  1706:             t = Math.max (-32768, Math.min (32767, (int) (891L * v + 119493L * u + 139216L * (v = (long) OPM.opmBuffer[src + 11]) + 4400L * (u = (long) OPM.opmBuffer[src + 13]) + 131072L >> 18)));
  1707:             sndByteBlock[dst + 14] = (byte) t;
  1708:             sndByteBlock[dst + 15] = (byte) (t >> 8);
  1709:             t = Math.max (-32768, Math.min (32767, (int) (63536L * v + 174053L * u + 26411L * (v = (long) OPM.opmBuffer[src + 15]) + 131072L >> 18)));
  1710:             sndByteBlock[dst + 18] = (byte) t;
  1711:             sndByteBlock[dst + 19] = (byte) (t >> 8);
  1712:             t = Math.max (-32768, Math.min (32767, (int) (24299L * u + 172777L * v + 66924L * (u = (long) OPM.opmBuffer[src + 17]) + 131072L >> 18)));
  1713:             sndByteBlock[dst + 22] = (byte) t;
  1714:             sndByteBlock[dst + 23] = (byte) (t >> 8);
  1715:             t = Math.max (-32768, Math.min (32767, (int) (3564L * v + 135828L * u + 123277L * (v = (long) OPM.opmBuffer[src + 19]) + 1331L * (u = (long) OPM.opmBuffer[src + 21]) + 131072L >> 18)));
  1716:             sndByteBlock[dst + 26] = (byte) t;
  1717:             sndByteBlock[dst + 27] = (byte) (t >> 8);
  1718:             t = Math.max (-32768, Math.min (32767, (int) (79475L * v + 166925L * u + 17600L * (v = (long) OPM.opmBuffer[src + 23]) + 131072L >> 18)));
  1719:             sndByteBlock[dst + 30] = (byte) t;
  1720:             sndByteBlock[dst + 31] = (byte) (t >> 8);
  1721:             t = Math.max (-32768, Math.min (32767, (int) (34496L * u + 177133L * v + 52371L * (u = (long) OPM.opmBuffer[src + 25]) + 131072L >> 18)));
  1722:             sndByteBlock[dst + 34] = (byte) t;
  1723:             sndByteBlock[dst + 35] = (byte) (t >> 8);
  1724:             t = Math.max (-32768, Math.min (32767, (int) (8019L * v + 150381L * u + 105556L * (v = (long) OPM.opmBuffer[src + 27]) + 44L * (u = (long) OPM.opmBuffer[src + 29]) + 131072L >> 18)));
  1725:             sndByteBlock[dst + 38] = (byte) t;
  1726:             sndByteBlock[dst + 39] = (byte) (t >> 8);
  1727:             t = Math.max (-32768, Math.min (32767, (int) (97196L * v + 156233L * u + 10571L * (v = (long) OPM.opmBuffer[src + 31]) + 131072L >> 18)));
  1728:             sndByteBlock[dst + 42] = (byte) t;
  1729:             sndByteBlock[dst + 43] = (byte) (t >> 8);
  1730:             t = Math.max (-32768, Math.min (32767, (int) (46475L * u + 177925L * v + 39600L * (u = (long) OPM.opmBuffer[src + 33]) + 131072L >> 18)));
  1731:             sndByteBlock[dst + 46] = (byte) t;
  1732:             sndByteBlock[dst + 47] = (byte) (t >> 8);
  1733:             t = Math.max (-32768, Math.min (32767, (int) (14256L * v + 162613L * u + 87131L * (v = (long) OPM.opmBuffer[src + 35]) + 131072L >> 18)));
  1734:             sndByteBlock[dst + 50] = (byte) t;
  1735:             sndByteBlock[dst + 51] = (byte) (t >> 8);
  1736:             t = Math.max (-32768, Math.min (32767, (int) (539L * u + 115621L * v + 142516L * (u = (long) OPM.opmBuffer[src + 37]) + 5324L * (v = (long) OPM.opmBuffer[src + 39]) + 131072L >> 18)));
  1737:             sndByteBlock[dst + 54] = (byte) t;
  1738:             sndByteBlock[dst + 55] = (byte) (t >> 8);
  1739:             t = Math.max (-32768, Math.min (32767, (int) (60236L * u + 175153L * v + 28611L * (u = (long) OPM.opmBuffer[src + 41]) + 131072L >> 18)));
  1740:             sndByteBlock[dst + 58] = (byte) t;
  1741:             sndByteBlock[dst + 59] = (byte) (t >> 8);
  1742:             t = Math.max (-32768, Math.min (32767, (int) (22275L * v + 171325L * u + 70400L * (v = (long) OPM.opmBuffer[src + 43]) + 131072L >> 18)));
  1743:             sndByteBlock[dst + 62] = (byte) t;
  1744:             sndByteBlock[dst + 63] = (byte) (t >> 8);
  1745:             t = Math.max (-32768, Math.min (32767, (int) (2816L * u + 132352L * v + 126973L * (u = (long) OPM.opmBuffer[src + 45]) + 1859L * (v = (long) OPM.opmBuffer[src + 47]) + 131072L >> 18)));
  1746:             sndByteBlock[dst + 66] = (byte) t;
  1747:             sndByteBlock[dst + 67] = (byte) (t >> 8);
  1748:             t = Math.max (-32768, Math.min (32767, (int) (75779L * u + 168817L * v + 19404L * (u = (long) OPM.opmBuffer[src + 49]) + 131072L >> 18)));
  1749:             sndByteBlock[dst + 70] = (byte) t;
  1750:             sndByteBlock[dst + 71] = (byte) (t >> 8);
  1751:             t = Math.max (-32768, Math.min (32767, (int) (32076L * v + 176473L * u + 55451L * (v = (long) OPM.opmBuffer[src + 51]) + 131072L >> 18)));
  1752:             sndByteBlock[dst + 74] = (byte) t;
  1753:             sndByteBlock[dst + 75] = (byte) (t >> 8);
  1754:             t = Math.max (-32768, Math.min (32767, (int) (6875L * u + 147301L * v + 109648L * (u = (long) OPM.opmBuffer[src + 53]) + 176L * (v = (long) OPM.opmBuffer[src + 55]) + 131072L >> 18)));
  1755:             sndByteBlock[dst + 78] = (byte) t;
  1756:             sndByteBlock[dst + 79] = (byte) (t >> 8);
  1757:             t = Math.max (-32768, Math.min (32767, (int) (93104L * u + 158917L * v + 11979L * (u = (long) OPM.opmBuffer[src + 57]) + 131072L >> 18)));
  1758:             sndByteBlock[dst + 82] = (byte) t;
  1759:             sndByteBlock[dst + 83] = (byte) (t >> 8);
  1760:             t = Math.max (-32768, Math.min (32767, (int) (43659L * v + 178057L * u + 42284L * (v = (long) OPM.opmBuffer[src + 59]) + 131072L >> 18)));
  1761:             sndByteBlock[dst + 86] = (byte) t;
  1762:             sndByteBlock[dst + 87] = (byte) (t >> 8);
  1763:             t = Math.max (-32768, Math.min (32767, (int) (12716L * u + 160193L * v + 91091L * (u = (long) OPM.opmBuffer[src + 61]) + 131072L >> 18)));
  1764:             sndByteBlock[dst + 90] = (byte) t;
  1765:             sndByteBlock[dst + 91] = (byte) (t >> 8);
  1766:             t = Math.max (-32768, Math.min (32767, (int) (275L * v + 111661L * u + 145728L * (v = (long) OPM.opmBuffer[src + 63]) + 6336L * (u = (long) OPM.opmBuffer[src + 65]) + 131072L >> 18)));
  1767:             sndByteBlock[dst + 94] = (byte) t;
  1768:             sndByteBlock[dst + 95] = (byte) (t >> 8);
  1769:             t = Math.max (-32768, Math.min (32767, (int) (57024L * v + 176077L * u + 30899L * (v = (long) OPM.opmBuffer[src + 67]) + 131072L >> 18)));
  1770:             sndByteBlock[dst + 98] = (byte) t;
  1771:             sndByteBlock[dst + 99] = (byte) (t >> 8);
  1772:             t = Math.max (-32768, Math.min (32767, (int) (20339L * u + 169697L * v + 73964L * (u = (long) OPM.opmBuffer[src + 69]) + 131072L >> 18)));
  1773:             sndByteBlock[dst + 102] = (byte) t;
  1774:             sndByteBlock[dst + 103] = (byte) (t >> 8);
  1775:             t = Math.max (-32768, Math.min (32767, (int) (2156L * v + 128788L * u + 130581L * (v = (long) OPM.opmBuffer[src + 71]) + 2475L * (u = (long) OPM.opmBuffer[src + 73]) + 131072L >> 18)));
  1776:             sndByteBlock[dst + 106] = (byte) t;
  1777:             sndByteBlock[dst + 107] = (byte) (t >> 8);
  1778:             t = Math.max (-32768, Math.min (32767, (int) (72171L * v + 170533L * u + 21296L * (v = (long) OPM.opmBuffer[src + 75]) + 131072L >> 18)));
  1779:             sndByteBlock[dst + 110] = (byte) t;
  1780:             sndByteBlock[dst + 111] = (byte) (t >> 8);
  1781:             t = Math.max (-32768, Math.min (32767, (int) (29744L * u + 175637L * v + 58619L * (u = (long) OPM.opmBuffer[src + 77]) + 131072L >> 18)));
  1782:             sndByteBlock[dst + 114] = (byte) t;
  1783:             sndByteBlock[dst + 115] = (byte) (t >> 8);
  1784:             t = Math.max (-32768, Math.min (32767, (int) (5819L * v + 144133L * u + 113652L * (v = (long) OPM.opmBuffer[src + 79]) + 396L * (u = (long) OPM.opmBuffer[src + 81]) + 131072L >> 18)));
  1785:             sndByteBlock[dst + 118] = (byte) t;
  1786:             sndByteBlock[dst + 119] = (byte) (t >> 8);
  1787:             t = Math.max (-32768, Math.min (32767, (int) (89100L * v + 161425L * u + 13475L * (v = (long) OPM.opmBuffer[src + 83]) + 131072L >> 18)));
  1788:             sndByteBlock[dst + 122] = (byte) t;
  1789:             sndByteBlock[dst + 123] = (byte) (t >> 8);
  1790:             t = Math.max (-32768, Math.min (32767, (int) (40931L * u + 178013L * v + 45056L * (u = (long) OPM.opmBuffer[src + 85]) + 131072L >> 18)));
  1791:             sndByteBlock[dst + 126] = (byte) t;
  1792:             sndByteBlock[dst + 127] = (byte) (t >> 8);
  1793:             t = Math.max (-32768, Math.min (32767, (int) (11264L * v + 157597L * u + 95139L * (v = (long) OPM.opmBuffer[src + 87]) + 131072L >> 18)));
  1794:             sndByteBlock[dst + 130] = (byte) t;
  1795:             sndByteBlock[dst + 131] = (byte) (t >> 8);
  1796:             t = Math.max (-32768, Math.min (32767, (int) (99L * u + 107613L * v + 148852L * (u = (long) OPM.opmBuffer[src + 89]) + 7436L * (v = (long) OPM.opmBuffer[src + 91]) + 131072L >> 18)));
  1797:             sndByteBlock[dst + 134] = (byte) t;
  1798:             sndByteBlock[dst + 135] = (byte) (t >> 8);
  1799:             t = Math.max (-32768, Math.min (32767, (int) (53900L * u + 176825L * v + 33275L * (u = (long) OPM.opmBuffer[src + 93]) + 131072L >> 18)));
  1800:             sndByteBlock[dst + 138] = (byte) t;
  1801:             sndByteBlock[dst + 139] = (byte) (t >> 8);
  1802:             t = Math.max (-32768, Math.min (32767, (int) (18491L * v + 167893L * u + 77616L * (v = (long) OPM.opmBuffer[src + 95]) + 131072L >> 18)));
  1803:             sndByteBlock[dst + 142] = (byte) t;
  1804:             sndByteBlock[dst + 143] = (byte) (t >> 8);
  1805:             t = Math.max (-32768, Math.min (32767, (int) (1584L * u + 125136L * v + 134101L * (u = (long) OPM.opmBuffer[src + 97]) + 3179L * (v = (long) OPM.opmBuffer[src + 99]) + 131072L >> 18)));
  1806:             sndByteBlock[dst + 146] = (byte) t;
  1807:             sndByteBlock[dst + 147] = (byte) (t >> 8);
  1808:             t = Math.max (-32768, Math.min (32767, (int) (68651L * u + 172073L * v + 23276L * (u = (long) OPM.opmBuffer[src + 101]) + 131072L >> 18)));
  1809:             sndByteBlock[dst + 150] = (byte) t;
  1810:             sndByteBlock[dst + 151] = (byte) (t >> 8);
  1811:             t = Math.max (-32768, Math.min (32767, (int) (27500L * v + 174625L * u + 61875L * (v = (long) OPM.opmBuffer[src + 103]) + 131072L >> 18)));
  1812:             sndByteBlock[dst + 154] = (byte) t;
  1813:             sndByteBlock[dst + 155] = (byte) (t >> 8);
  1814:             t = Math.max (-32768, Math.min (32767, (int) (4851L * u + 140877L * v + 117568L * (u = (long) OPM.opmBuffer[src + 105]) + 704L * (v = (long) OPM.opmBuffer[src + 107]) + 131072L >> 18)));
  1815:             sndByteBlock[dst + 158] = (byte) t;
  1816:             sndByteBlock[dst + 159] = (byte) (t >> 8);
  1817:             t = Math.max (-32768, Math.min (32767, (int) (85184L * u + 163757L * v + 15059L * (u = (long) OPM.opmBuffer[src + 109]) + 131072L >> 18)));
  1818:             sndByteBlock[dst + 162] = (byte) t;
  1819:             sndByteBlock[dst + 163] = (byte) (t >> 8);
  1820:             t = Math.max (-32768, Math.min (32767, (int) (38291L * v + 177793L * u + 47916L * (v = (long) OPM.opmBuffer[src + 111]) + 131072L >> 18)));
  1821:             sndByteBlock[dst + 166] = (byte) t;
  1822:             sndByteBlock[dst + 167] = (byte) (t >> 8);
  1823:             t = Math.max (-32768, Math.min (32767, (int) (9900L * u + 154825L * v + 99275L * (u = (long) OPM.opmBuffer[src + 113]) + 131072L >> 18)));
  1824:             sndByteBlock[dst + 170] = (byte) t;
  1825:             sndByteBlock[dst + 171] = (byte) (t >> 8);
  1826:             t = Math.max (-32768, Math.min (32767, (int) (11L * v + 103477L * u + 151888L * (v = (long) OPM.opmBuffer[src + 115]) + 8624L * (u = (long) OPM.opmBuffer[src + 117]) + 131072L >> 18)));
  1827:             sndByteBlock[dst + 174] = (byte) t;
  1828:             sndByteBlock[dst + 175] = (byte) (t >> 8);
  1829:             t = Math.max (-32768, Math.min (32767, (int) (50864L * v + 177397L * u + 35739L * (v = (long) OPM.opmBuffer[src + 119]) + 131072L >> 18)));
  1830:             sndByteBlock[dst + 178] = (byte) t;
  1831:             sndByteBlock[dst + 179] = (byte) (t >> 8);
  1832:             t = Math.max (-32768, Math.min (32767, (int) (16731L * u + 165913L * v + 81356L * (u = (long) OPM.opmBuffer[src + 121]) + 131072L >> 18)));
  1833:             sndByteBlock[dst + 182] = (byte) t;
  1834:             sndByteBlock[dst + 183] = (byte) (t >> 8);
  1835:             t = Math.max (-32768, Math.min (32767, (int) (1100L * v + 121396L * u + 137533L * (v = (long) OPM.opmBuffer[src + 123]) + 3971L * (u = (long) OPM.opmBuffer[src + 125]) + 131072L >> 18)));
  1836:             sndByteBlock[dst + 186] = (byte) t;
  1837:             sndByteBlock[dst + 187] = (byte) (t >> 8);
  1838:             t = Math.max (-32768, Math.min (32767, (int) (65219L * v + 173437L * u + 25344L * (v = (long) OPM.opmBuffer[src + 127]) + 131072L >> 18)));
  1839:             sndByteBlock[dst + 190] = (byte) t;
  1840:             sndByteBlock[dst + 191] = (byte) (t >> 8);
  1841:             t = Math.max (-32768, Math.min (32767, (int) (25344L * u + 173437L * v + 65219L * (u = (long) OPM.opmBuffer[src + 129]) + 131072L >> 18)));
  1842:             sndByteBlock[dst + 194] = (byte) t;
  1843:             sndByteBlock[dst + 195] = (byte) (t >> 8);
  1844:             t = Math.max (-32768, Math.min (32767, (int) (3971L * v + 137533L * u + 121396L * (v = (long) OPM.opmBuffer[src + 131]) + 1100L * (u = (long) OPM.opmBuffer[src + 133]) + 131072L >> 18)));
  1845:             sndByteBlock[dst + 198] = (byte) t;
  1846:             sndByteBlock[dst + 199] = (byte) (t >> 8);
  1847:             t = Math.max (-32768, Math.min (32767, (int) (81356L * v + 165913L * u + 16731L * (v = (long) OPM.opmBuffer[src + 135]) + 131072L >> 18)));
  1848:             sndByteBlock[dst + 202] = (byte) t;
  1849:             sndByteBlock[dst + 203] = (byte) (t >> 8);
  1850:             t = Math.max (-32768, Math.min (32767, (int) (35739L * u + 177397L * v + 50864L * (u = (long) OPM.opmBuffer[src + 137]) + 131072L >> 18)));
  1851:             sndByteBlock[dst + 206] = (byte) t;
  1852:             sndByteBlock[dst + 207] = (byte) (t >> 8);
  1853:             t = Math.max (-32768, Math.min (32767, (int) (8624L * v + 151888L * u + 103477L * (v = (long) OPM.opmBuffer[src + 139]) + 11L * (u = (long) OPM.opmBuffer[src + 141]) + 131072L >> 18)));
  1854:             sndByteBlock[dst + 210] = (byte) t;
  1855:             sndByteBlock[dst + 211] = (byte) (t >> 8);
  1856:             t = Math.max (-32768, Math.min (32767, (int) (99275L * v + 154825L * u + 9900L * (v = (long) OPM.opmBuffer[src + 143]) + 131072L >> 18)));
  1857:             sndByteBlock[dst + 214] = (byte) t;
  1858:             sndByteBlock[dst + 215] = (byte) (t >> 8);
  1859:             t = Math.max (-32768, Math.min (32767, (int) (47916L * u + 177793L * v + 38291L * (u = (long) OPM.opmBuffer[src + 145]) + 131072L >> 18)));
  1860:             sndByteBlock[dst + 218] = (byte) t;
  1861:             sndByteBlock[dst + 219] = (byte) (t >> 8);
  1862:             t = Math.max (-32768, Math.min (32767, (int) (15059L * v + 163757L * u + 85184L * (v = (long) OPM.opmBuffer[src + 147]) + 131072L >> 18)));
  1863:             sndByteBlock[dst + 222] = (byte) t;
  1864:             sndByteBlock[dst + 223] = (byte) (t >> 8);
  1865:             t = Math.max (-32768, Math.min (32767, (int) (704L * u + 117568L * v + 140877L * (u = (long) OPM.opmBuffer[src + 149]) + 4851L * (v = (long) OPM.opmBuffer[src + 151]) + 131072L >> 18)));
  1866:             sndByteBlock[dst + 226] = (byte) t;
  1867:             sndByteBlock[dst + 227] = (byte) (t >> 8);
  1868:             t = Math.max (-32768, Math.min (32767, (int) (61875L * u + 174625L * v + 27500L * (u = (long) OPM.opmBuffer[src + 153]) + 131072L >> 18)));
  1869:             sndByteBlock[dst + 230] = (byte) t;
  1870:             sndByteBlock[dst + 231] = (byte) (t >> 8);
  1871:             t = Math.max (-32768, Math.min (32767, (int) (23276L * v + 172073L * u + 68651L * (v = (long) OPM.opmBuffer[src + 155]) + 131072L >> 18)));
  1872:             sndByteBlock[dst + 234] = (byte) t;
  1873:             sndByteBlock[dst + 235] = (byte) (t >> 8);
  1874:             t = Math.max (-32768, Math.min (32767, (int) (3179L * u + 134101L * v + 125136L * (u = (long) OPM.opmBuffer[src + 157]) + 1584L * (v = (long) OPM.opmBuffer[src + 159]) + 131072L >> 18)));
  1875:             sndByteBlock[dst + 238] = (byte) t;
  1876:             sndByteBlock[dst + 239] = (byte) (t >> 8);
  1877:             t = Math.max (-32768, Math.min (32767, (int) (77616L * u + 167893L * v + 18491L * (u = (long) OPM.opmBuffer[src + 161]) + 131072L >> 18)));
  1878:             sndByteBlock[dst + 242] = (byte) t;
  1879:             sndByteBlock[dst + 243] = (byte) (t >> 8);
  1880:             t = Math.max (-32768, Math.min (32767, (int) (33275L * v + 176825L * u + 53900L * (v = (long) OPM.opmBuffer[src + 163]) + 131072L >> 18)));
  1881:             sndByteBlock[dst + 246] = (byte) t;
  1882:             sndByteBlock[dst + 247] = (byte) (t >> 8);
  1883:             t = Math.max (-32768, Math.min (32767, (int) (7436L * u + 148852L * v + 107613L * (u = (long) OPM.opmBuffer[src + 165]) + 99L * (v = (long) OPM.opmBuffer[src + 167]) + 131072L >> 18)));
  1884:             sndByteBlock[dst + 250] = (byte) t;
  1885:             sndByteBlock[dst + 251] = (byte) (t >> 8);
  1886:             t = Math.max (-32768, Math.min (32767, (int) (95139L * u + 157597L * v + 11264L * (u = (long) OPM.opmBuffer[src + 169]) + 131072L >> 18)));
  1887:             sndByteBlock[dst + 254] = (byte) t;
  1888:             sndByteBlock[dst + 255] = (byte) (t >> 8);
  1889:             t = Math.max (-32768, Math.min (32767, (int) (45056L * v + 178013L * u + 40931L * (v = (long) OPM.opmBuffer[src + 171]) + 131072L >> 18)));
  1890:             sndByteBlock[dst + 258] = (byte) t;
  1891:             sndByteBlock[dst + 259] = (byte) (t >> 8);
  1892:             t = Math.max (-32768, Math.min (32767, (int) (13475L * u + 161425L * v + 89100L * (u = (long) OPM.opmBuffer[src + 173]) + 131072L >> 18)));
  1893:             sndByteBlock[dst + 262] = (byte) t;
  1894:             sndByteBlock[dst + 263] = (byte) (t >> 8);
  1895:             t = Math.max (-32768, Math.min (32767, (int) (396L * v + 113652L * u + 144133L * (v = (long) OPM.opmBuffer[src + 175]) + 5819L * (u = (long) OPM.opmBuffer[src + 177]) + 131072L >> 18)));
  1896:             sndByteBlock[dst + 266] = (byte) t;
  1897:             sndByteBlock[dst + 267] = (byte) (t >> 8);
  1898:             t = Math.max (-32768, Math.min (32767, (int) (58619L * v + 175637L * u + 29744L * (v = (long) OPM.opmBuffer[src + 179]) + 131072L >> 18)));
  1899:             sndByteBlock[dst + 270] = (byte) t;
  1900:             sndByteBlock[dst + 271] = (byte) (t >> 8);
  1901:             t = Math.max (-32768, Math.min (32767, (int) (21296L * u + 170533L * v + 72171L * (u = (long) OPM.opmBuffer[src + 181]) + 131072L >> 18)));
  1902:             sndByteBlock[dst + 274] = (byte) t;
  1903:             sndByteBlock[dst + 275] = (byte) (t >> 8);
  1904:             t = Math.max (-32768, Math.min (32767, (int) (2475L * v + 130581L * u + 128788L * (v = (long) OPM.opmBuffer[src + 183]) + 2156L * (u = (long) OPM.opmBuffer[src + 185]) + 131072L >> 18)));
  1905:             sndByteBlock[dst + 278] = (byte) t;
  1906:             sndByteBlock[dst + 279] = (byte) (t >> 8);
  1907:             t = Math.max (-32768, Math.min (32767, (int) (73964L * v + 169697L * u + 20339L * (v = (long) OPM.opmBuffer[src + 187]) + 131072L >> 18)));
  1908:             sndByteBlock[dst + 282] = (byte) t;
  1909:             sndByteBlock[dst + 283] = (byte) (t >> 8);
  1910:             t = Math.max (-32768, Math.min (32767, (int) (30899L * u + 176077L * v + 57024L * (u = (long) OPM.opmBuffer[src + 189]) + 131072L >> 18)));
  1911:             sndByteBlock[dst + 286] = (byte) t;
  1912:             sndByteBlock[dst + 287] = (byte) (t >> 8);
  1913:             t = Math.max (-32768, Math.min (32767, (int) (6336L * v + 145728L * u + 111661L * (v = (long) OPM.opmBuffer[src + 191]) + 275L * (u = (long) OPM.opmBuffer[src + 193]) + 131072L >> 18)));
  1914:             sndByteBlock[dst + 290] = (byte) t;
  1915:             sndByteBlock[dst + 291] = (byte) (t >> 8);
  1916:             t = Math.max (-32768, Math.min (32767, (int) (91091L * v + 160193L * u + 12716L * (v = (long) OPM.opmBuffer[src + 195]) + 131072L >> 18)));
  1917:             sndByteBlock[dst + 294] = (byte) t;
  1918:             sndByteBlock[dst + 295] = (byte) (t >> 8);
  1919:             t = Math.max (-32768, Math.min (32767, (int) (42284L * u + 178057L * v + 43659L * (u = (long) OPM.opmBuffer[src + 197]) + 131072L >> 18)));
  1920:             sndByteBlock[dst + 298] = (byte) t;
  1921:             sndByteBlock[dst + 299] = (byte) (t >> 8);
  1922:             t = Math.max (-32768, Math.min (32767, (int) (11979L * v + 158917L * u + 93104L * (v = (long) OPM.opmBuffer[src + 199]) + 131072L >> 18)));
  1923:             sndByteBlock[dst + 302] = (byte) t;
  1924:             sndByteBlock[dst + 303] = (byte) (t >> 8);
  1925:             t = Math.max (-32768, Math.min (32767, (int) (176L * u + 109648L * v + 147301L * (u = (long) OPM.opmBuffer[src + 201]) + 6875L * (v = (long) OPM.opmBuffer[src + 203]) + 131072L >> 18)));
  1926:             sndByteBlock[dst + 306] = (byte) t;
  1927:             sndByteBlock[dst + 307] = (byte) (t >> 8);
  1928:             t = Math.max (-32768, Math.min (32767, (int) (55451L * u + 176473L * v + 32076L * (u = (long) OPM.opmBuffer[src + 205]) + 131072L >> 18)));
  1929:             sndByteBlock[dst + 310] = (byte) t;
  1930:             sndByteBlock[dst + 311] = (byte) (t >> 8);
  1931:             t = Math.max (-32768, Math.min (32767, (int) (19404L * v + 168817L * u + 75779L * (v = (long) OPM.opmBuffer[src + 207]) + 131072L >> 18)));
  1932:             sndByteBlock[dst + 314] = (byte) t;
  1933:             sndByteBlock[dst + 315] = (byte) (t >> 8);
  1934:             t = Math.max (-32768, Math.min (32767, (int) (1859L * u + 126973L * v + 132352L * (u = (long) OPM.opmBuffer[src + 209]) + 2816L * (v = (long) OPM.opmBuffer[src + 211]) + 131072L >> 18)));
  1935:             sndByteBlock[dst + 318] = (byte) t;
  1936:             sndByteBlock[dst + 319] = (byte) (t >> 8);
  1937:             t = Math.max (-32768, Math.min (32767, (int) (70400L * u + 171325L * v + 22275L * (u = (long) OPM.opmBuffer[src + 213]) + 131072L >> 18)));
  1938:             sndByteBlock[dst + 322] = (byte) t;
  1939:             sndByteBlock[dst + 323] = (byte) (t >> 8);
  1940:             t = Math.max (-32768, Math.min (32767, (int) (28611L * v + 175153L * u + 60236L * (v = (long) OPM.opmBuffer[src + 215]) + 131072L >> 18)));
  1941:             sndByteBlock[dst + 326] = (byte) t;
  1942:             sndByteBlock[dst + 327] = (byte) (t >> 8);
  1943:             t = Math.max (-32768, Math.min (32767, (int) (5324L * u + 142516L * v + 115621L * (u = (long) OPM.opmBuffer[src + 217]) + 539L * (v = (long) OPM.opmBuffer[src + 219]) + 131072L >> 18)));
  1944:             sndByteBlock[dst + 330] = (byte) t;
  1945:             sndByteBlock[dst + 331] = (byte) (t >> 8);
  1946:             t = Math.max (-32768, Math.min (32767, (int) (87131L * u + 162613L * v + 14256L * (u = (long) OPM.opmBuffer[src + 221]) + 131072L >> 18)));
  1947:             sndByteBlock[dst + 334] = (byte) t;
  1948:             sndByteBlock[dst + 335] = (byte) (t >> 8);
  1949:             t = Math.max (-32768, Math.min (32767, (int) (39600L * v + 177925L * u + 46475L * (v = (long) OPM.opmBuffer[src + 223]) + 131072L >> 18)));
  1950:             sndByteBlock[dst + 338] = (byte) t;
  1951:             sndByteBlock[dst + 339] = (byte) (t >> 8);
  1952:             t = Math.max (-32768, Math.min (32767, (int) (10571L * u + 156233L * v + 97196L * (u = (long) OPM.opmBuffer[src + 225]) + 131072L >> 18)));
  1953:             sndByteBlock[dst + 342] = (byte) t;
  1954:             sndByteBlock[dst + 343] = (byte) (t >> 8);
  1955:             t = Math.max (-32768, Math.min (32767, (int) (44L * v + 105556L * u + 150381L * (v = (long) OPM.opmBuffer[src + 227]) + 8019L * (u = (long) OPM.opmBuffer[src + 229]) + 131072L >> 18)));
  1956:             sndByteBlock[dst + 346] = (byte) t;
  1957:             sndByteBlock[dst + 347] = (byte) (t >> 8);
  1958:             t = Math.max (-32768, Math.min (32767, (int) (52371L * v + 177133L * u + 34496L * (v = (long) OPM.opmBuffer[src + 231]) + 131072L >> 18)));
  1959:             sndByteBlock[dst + 350] = (byte) t;
  1960:             sndByteBlock[dst + 351] = (byte) (t >> 8);
  1961:             t = Math.max (-32768, Math.min (32767, (int) (17600L * u + 166925L * v + 79475L * (u = (long) OPM.opmBuffer[src + 233]) + 131072L >> 18)));
  1962:             sndByteBlock[dst + 354] = (byte) t;
  1963:             sndByteBlock[dst + 355] = (byte) (t >> 8);
  1964:             t = Math.max (-32768, Math.min (32767, (int) (1331L * v + 123277L * u + 135828L * (v = (long) OPM.opmBuffer[src + 235]) + 3564L * (u = (long) OPM.opmBuffer[src + 237]) + 131072L >> 18)));
  1965:             sndByteBlock[dst + 358] = (byte) t;
  1966:             sndByteBlock[dst + 359] = (byte) (t >> 8);
  1967:             t = Math.max (-32768, Math.min (32767, (int) (66924L * v + 172777L * u + 24299L * (v = (long) OPM.opmBuffer[src + 239]) + 131072L >> 18)));
  1968:             sndByteBlock[dst + 362] = (byte) t;
  1969:             sndByteBlock[dst + 363] = (byte) (t >> 8);
  1970:             t = Math.max (-32768, Math.min (32767, (int) (26411L * u + 174053L * v + 63536L * (u = (long) OPM.opmBuffer[src + 241]) + 131072L >> 18)));
  1971:             sndByteBlock[dst + 366] = (byte) t;
  1972:             sndByteBlock[dst + 367] = (byte) (t >> 8);
  1973:             t = Math.max (-32768, Math.min (32767, (int) (4400L * v + 139216L * u + 119493L * (v = (long) OPM.opmBuffer[src + 243]) + 891L * (u = (long) OPM.opmBuffer[src + 245]) + 131072L >> 18)));
  1974:             sndByteBlock[dst + 370] = (byte) t;
  1975:             sndByteBlock[dst + 371] = (byte) (t >> 8);
  1976:             t = Math.max (-32768, Math.min (32767, (int) (83259L * v + 164857L * u + 15884L * (v = (long) OPM.opmBuffer[src + 247]) + 131072L >> 18)));
  1977:             sndByteBlock[dst + 374] = (byte) t;
  1978:             sndByteBlock[dst + 375] = (byte) (t >> 8);
  1979:             t = Math.max (-32768, Math.min (32767, (int) (37004L * u + 177617L * v + 49379L * (u = (long) OPM.opmBuffer[src + 249]) + 131072L >> 18)));
  1980:             sndByteBlock[dst + 378] = (byte) t;
  1981:             sndByteBlock[dst + 379] = (byte) (t >> 8);
  1982:             t = Math.max (-32768, Math.min (32767, (int) (9251L * v + 153373L * u + 101376L * (long) OPM.opmBuffer[src + 251] + 131072L >> 18)));
  1983:             sndByteBlock[dst + 382] = (byte) t;
  1984:             sndByteBlock[dst + 383] = (byte) (t >> 8);
  1985:           }  //for src,dst
  1986:         } else {  //float
  1987:           //OPMとPCMを合わせてボリュームを掛ける。ついでに後ろに1サンプルずらす
  1988:           int l = OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES    ];  //前回の最後のデータ
  1989:           int r = OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES + 1];
  1990:           for (int src = 0; src < 2 * OPM.OPM_BLOCK_SAMPLES; src += 2) {
  1991:             int t;
  1992:             t = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src    ] + ADPCM.pcmBuffer[src    ] :
  1993:                  OPM.OPM_ON           ? OPM.opmBuffer[src    ]                      :
  1994:                  ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src    ] :
  1995:                  0) * sndCurrentScale >> 12;
  1996:             OPM.opmBuffer[src    ] = l;
  1997:             l = t;
  1998:             t = (OPM.OPM_ON && ADPCM.PCM_ON ? OPM.opmBuffer[src + 1] + ADPCM.pcmBuffer[src + 1] :
  1999:                  OPM.OPM_ON           ? OPM.opmBuffer[src + 1]                      :
  2000:                  ADPCM.PCM_ON           ?                      ADPCM.pcmBuffer[src + 1] :
  2001:                  0) * sndCurrentScale >> 12;
  2002:             OPM.opmBuffer[src + 1] = r;
  2003:             r = t;
  2004:             sndCurrentScale += (sndCurrentScale - sndTargetScale >>> 31) - (sndTargetScale - sndCurrentScale >>> 31);
  2005:           }
  2006:           OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES    ] = l;  //今回の最後のデータ
  2007:           OPM.opmBuffer[2 * OPM.OPM_BLOCK_SAMPLES + 1] = r;
  2008:           //線形面積補間
  2009:           //  float→intのキャストに飽和処理をさせている
  2010:           for (int src = 0, dst = 0; src < 2 * OPM.OPM_BLOCK_SAMPLES; src += 2 * 125, dst += 4 * 96) {
  2011:             int t;
  2012:             float u, v;
  2013:             //  perl -e "$m=125;$n=96;$CH=2;$I=12;sub str{my($t,$lr)=@_;my@s=();for my$k(sort{$a<=>$b}keys%$t){push@s,$t->{$k}.'F * OPM.opmBuffer[src'.($CH*$k+$lr?' + '.($CH*$k+$lr):'').']'}join' + ',@s}sub mul{my($t,$m)=@_;my$p={};for my$k(keys%$t){$p->{$k}=$t->{$k}*$m}$p}sub add{my($t,$u)=@_;my$s={};for my$k(keys%$t){$s->{$k}=$t->{$k}};for my$k(keys%$u){$s->{$k}=($s->{$k}//0)+$u->{$k}}$s}@out=();@w=();for$i(0..$m){$k=$n*$i;$t={};$t->{$i}=1;push@w,[$k,$t]}for$j(0..$n-1){$k=$m*$j;$r=$k%$n;$r or next;$q=($k-$r)/$n;$t={};$t->{$q}=($n-$r)/$n;$t->{$q+1}=$r/$n;push@w,[$k,$t];}@w=sort{$a->[0]<=>$b->[0]}@w;for$lr(0..$CH-1){push@out,sprintf'%*s//%s%c',$I,'',$CH==1?'mid':$lr?'right':'left',10;for$j(0..$n-1){$k=$m*$j;@v=grep{$k<=$_->[0]&&$_->[0]<=$k+$m}@w;$d={};for$i(0..@v-2){$d=add($d,mul(add($v[$i]->[1],$v[$i+1]->[1]),($v[$i+1]->[0]-$v[$i]->[0])))}$d=mul($d,65536/(2*$m));push@out,sprintf'%*st = (int) (%s + 32768F) >> 16;%c',$I,'',str($d,$lr),10;push@out,sprintf'%*ssndByteBlock[dst'.(2*($CH*$j+$lr)+0?' + '.(2*($CH*$j+$lr)+0):'').'] = (byte) t;%c',$I,'',10;push@out,sprintf'%*ssndByteBlock[dst + '.(2*($CH*$j+$lr)+1).'] = (byte) (t >> 8);%c',$I,'',10;}}$out=join'',@out;$out2='';%flag=();while($out=~/OPM.opmBuffer\[src(?: \+ (\d+))?\]/){$out2.=$`;$out=$';$s=$&;$i=int(($1//0)/$CH);if($i==0||$i==$m){$out2.='(float) '.$s}else{$uv=$i%2?'v':'u';if(exists$flag{$s}){$out2.=$uv}else{$flag{$s}=1;$out2.='('.$uv.' = (float) '.$s.')'}}}$out2.=$out;print$out2"
  2014:             //left
  2015:             t = (int) (25165.824F * (float) OPM.opmBuffer[src] + 38073.6853333333F * (v = (float) OPM.opmBuffer[src + 2]) + 2296.49066666667F * (u = (float) OPM.opmBuffer[src + 4]) + 32768F) >> 16;
  2016:             sndByteBlock[dst] = (byte) t;
  2017:             sndByteBlock[dst + 1] = (byte) (t >> 8);
  2018:             t = (int) (12257.9626666667F * v + 44092.0746666667F * u + 9185.96266666667F * (v = (float) OPM.opmBuffer[src + 6]) + 32768F) >> 16;
  2019:             sndByteBlock[dst + 4] = (byte) t;
  2020:             sndByteBlock[dst + 5] = (byte) (t >> 8);
  2021:             t = (int) (3943.08266666667F * u + 40924.5013333333F * v + 20668.416F * (u = (float) OPM.opmBuffer[src + 8]) + 32768F) >> 16;
  2022:             sndByteBlock[dst + 8] = (byte) t;
  2023:             sndByteBlock[dst + 9] = (byte) (t >> 8);
  2024:             t = (int) (221.184F * v + 29663.232F * u + 34559.3173333333F * (v = (float) OPM.opmBuffer[src + 10]) + 1092.26666666667F * (u = (float) OPM.opmBuffer[src + 12]) + 32768F) >> 16;
  2025:             sndByteBlock[dst + 12] = (byte) t;
  2026:             sndByteBlock[dst + 13] = (byte) (t >> 8);
  2027:             t = (int) (15772.3306666667F * v + 43207.3386666667F * u + 6556.33066666667F * (v = (float) OPM.opmBuffer[src + 14]) + 32768F) >> 16;
  2028:             sndByteBlock[dst + 16] = (byte) t;
  2029:             sndByteBlock[dst + 17] = (byte) (t >> 8);
  2030:             t = (int) (6032.04266666667F * u + 42890.5813333333F * v + 16613.376F * (u = (float) OPM.opmBuffer[src + 16]) + 32768F) >> 16;
  2031:             sndByteBlock[dst + 20] = (byte) t;
  2032:             sndByteBlock[dst + 21] = (byte) (t >> 8);
  2033:             t = (int) (884.736F * v + 33718.272F * u + 30602.5813333333F * (v = (float) OPM.opmBuffer[src + 18]) + 330.410666666667F * (u = (float) OPM.opmBuffer[src + 20]) + 32768F) >> 16;
  2034:             sndByteBlock[dst + 24] = (byte) t;
  2035:             sndByteBlock[dst + 25] = (byte) (t >> 8);
  2036:             t = (int) (19729.0666666667F * v + 41437.8666666667F * u + 4369.06666666667F * (v = (float) OPM.opmBuffer[src + 22]) + 32768F) >> 16;
  2037:             sndByteBlock[dst + 28] = (byte) t;
  2038:             sndByteBlock[dst + 29] = (byte) (t >> 8);
  2039:             t = (int) (8563.37066666667F * u + 43971.9253333333F * v + 13000.704F * (u = (float) OPM.opmBuffer[src + 24]) + 32768F) >> 16;
  2040:             sndByteBlock[dst + 32] = (byte) t;
  2041:             sndByteBlock[dst + 33] = (byte) (t >> 8);
  2042:             t = (int) (1990.656F * v + 37330.944F * u + 26203.4773333333F * (v = (float) OPM.opmBuffer[src + 26]) + 10.9226666666667F * (u = (float) OPM.opmBuffer[src + 28]) + 32768F) >> 16;
  2043:             sndByteBlock[dst + 36] = (byte) t;
  2044:             sndByteBlock[dst + 37] = (byte) (t >> 8);
  2045:             t = (int) (24128.1706666667F * v + 38783.6586666667F * u + 2624.17066666667F * (v = (float) OPM.opmBuffer[src + 30]) + 32768F) >> 16;
  2046:             sndByteBlock[dst + 40] = (byte) t;
  2047:             sndByteBlock[dst + 41] = (byte) (t >> 8);
  2048:             t = (int) (11537.0666666667F * u + 44168.5333333333F * v + 9830.4F * (u = (float) OPM.opmBuffer[src + 32]) + 32768F) >> 16;
  2049:             sndByteBlock[dst + 44] = (byte) t;
  2050:             sndByteBlock[dst + 45] = (byte) (t >> 8);
  2051:             t = (int) (3538.944F * v + 40367.4453333333F * u + 21629.6106666667F * (v = (float) OPM.opmBuffer[src + 34]) + 32768F) >> 16;
  2052:             sndByteBlock[dst + 48] = (byte) t;
  2053:             sndByteBlock[dst + 49] = (byte) (t >> 8);
  2054:             t = (int) (133.802666666667F * u + 28702.0373333333F * v + 35378.5173333333F * (u = (float) OPM.opmBuffer[src + 36]) + 1321.64266666667F * (v = (float) OPM.opmBuffer[src + 38]) + 32768F) >> 16;
  2055:             sndByteBlock[dst + 52] = (byte) t;
  2056:             sndByteBlock[dst + 53] = (byte) (t >> 8);
  2057:             t = (int) (14953.1306666667F * u + 43480.4053333333F * v + 7102.464F * (u = (float) OPM.opmBuffer[src + 40]) + 32768F) >> 16;
  2058:             sndByteBlock[dst + 56] = (byte) t;
  2059:             sndByteBlock[dst + 57] = (byte) (t >> 8);
  2060:             t = (int) (5529.6F * v + 42530.1333333333F * u + 17476.2666666667F * (v = (float) OPM.opmBuffer[src + 42]) + 32768F) >> 16;
  2061:             sndByteBlock[dst + 60] = (byte) t;
  2062:             sndByteBlock[dst + 61] = (byte) (t >> 8);
  2063:             t = (int) (699.050666666667F * u + 32855.3813333333F * v + 31520.0853333333F * (u = (float) OPM.opmBuffer[src + 44]) + 461.482666666667F * (v = (float) OPM.opmBuffer[src + 46]) + 32768F) >> 16;
  2064:             sndByteBlock[dst + 64] = (byte) t;
  2065:             sndByteBlock[dst + 65] = (byte) (t >> 8);
  2066:             t = (int) (18811.5626666667F * u + 41907.5413333333F * v + 4816.896F * (u = (float) OPM.opmBuffer[src + 48]) + 32768F) >> 16;
  2067:             sndByteBlock[dst + 68] = (byte) t;
  2068:             sndByteBlock[dst + 69] = (byte) (t >> 8);
  2069:             t = (int) (7962.624F * v + 43808.0853333333F * u + 13765.2906666667F * (v = (float) OPM.opmBuffer[src + 50]) + 32768F) >> 16;
  2070:             sndByteBlock[dst + 72] = (byte) t;
  2071:             sndByteBlock[dst + 73] = (byte) (t >> 8);
  2072:             t = (int) (1706.66666666667F * u + 36566.3573333333F * v + 27219.2853333333F * (u = (float) OPM.opmBuffer[src + 52]) + 43.6906666666667F * (v = (float) OPM.opmBuffer[src + 54]) + 32768F) >> 16;
  2073:             sndByteBlock[dst + 76] = (byte) t;
  2074:             sndByteBlock[dst + 77] = (byte) (t >> 8);
  2075:             t = (int) (23112.3626666667F * u + 39449.9413333333F * v + 2973.696F * (u = (float) OPM.opmBuffer[src + 56]) + 32768F) >> 16;
  2076:             sndByteBlock[dst + 80] = (byte) t;
  2077:             sndByteBlock[dst + 81] = (byte) (t >> 8);
  2078:             t = (int) (10838.016F * v + 44201.3013333333F * u + 10496.6826666667F * (v = (float) OPM.opmBuffer[src + 58]) + 32768F) >> 16;
  2079:             sndByteBlock[dst + 84] = (byte) t;
  2080:             sndByteBlock[dst + 85] = (byte) (t >> 8);
  2081:             t = (int) (3156.65066666667F * u + 39766.6986666667F * v + 22612.6506666667F * (u = (float) OPM.opmBuffer[src + 60]) + 32768F) >> 16;
  2082:             sndByteBlock[dst + 88] = (byte) t;
  2083:             sndByteBlock[dst + 89] = (byte) (t >> 8);
  2084:             t = (int) (68.2666666666667F * v + 27718.9973333333F * u + 36175.872F * (v = (float) OPM.opmBuffer[src + 62]) + 1572.864F * (u = (float) OPM.opmBuffer[src + 64]) + 32768F) >> 16;
  2085:             sndByteBlock[dst + 92] = (byte) t;
  2086:             sndByteBlock[dst + 93] = (byte) (t >> 8);
  2087:             t = (int) (14155.776F * v + 43709.7813333333F * u + 7670.44266666667F * (v = (float) OPM.opmBuffer[src + 66]) + 32768F) >> 16;
  2088:             sndByteBlock[dst + 96] = (byte) t;
  2089:             sndByteBlock[dst + 97] = (byte) (t >> 8);
  2090:             t = (int) (5049.00266666667F * u + 42125.9946666667F * v + 18361.0026666667F * (u = (float) OPM.opmBuffer[src + 68]) + 32768F) >> 16;
  2091:             sndByteBlock[dst + 100] = (byte) t;
  2092:             sndByteBlock[dst + 101] = (byte) (t >> 8);
  2093:             t = (int) (535.210666666667F * v + 31970.6453333333F * u + 32415.744F * (v = (float) OPM.opmBuffer[src + 70]) + 614.4F * (u = (float) OPM.opmBuffer[src + 72]) + 32768F) >> 16;
  2094:             sndByteBlock[dst + 104] = (byte) t;
  2095:             sndByteBlock[dst + 105] = (byte) (t >> 8);
  2096:             t = (int) (17915.904F * v + 42333.5253333333F * u + 5286.57066666667F * (v = (float) OPM.opmBuffer[src + 74]) + 32768F) >> 16;
  2097:             sndByteBlock[dst + 108] = (byte) t;
  2098:             sndByteBlock[dst + 109] = (byte) (t >> 8);
  2099:             t = (int) (7383.72266666667F * u + 43600.5546666667F * v + 14551.7226666667F * (u = (float) OPM.opmBuffer[src + 76]) + 32768F) >> 16;
  2100:             sndByteBlock[dst + 112] = (byte) t;
  2101:             sndByteBlock[dst + 113] = (byte) (t >> 8);
  2102:             t = (int) (1444.52266666667F * v + 35779.9253333333F * u + 28213.248F * (v = (float) OPM.opmBuffer[src + 78]) + 98.304F * (u = (float) OPM.opmBuffer[src + 80]) + 32768F) >> 16;
  2103:             sndByteBlock[dst + 116] = (byte) t;
  2104:             sndByteBlock[dst + 117] = (byte) (t >> 8);
  2105:             t = (int) (22118.4F * v + 40072.5333333333F * u + 3345.06666666667F * (v = (float) OPM.opmBuffer[src + 82]) + 32768F) >> 16;
  2106:             sndByteBlock[dst + 120] = (byte) t;
  2107:             sndByteBlock[dst + 121] = (byte) (t >> 8);
  2108:             t = (int) (10160.8106666667F * u + 44190.3786666667F * v + 11184.8106666667F * (u = (float) OPM.opmBuffer[src + 84]) + 32768F) >> 16;
  2109:             sndByteBlock[dst + 124] = (byte) t;
  2110:             sndByteBlock[dst + 125] = (byte) (t >> 8);
  2111:             t = (int) (2796.20266666667F * v + 39122.2613333333F * u + 23617.536F * (v = (float) OPM.opmBuffer[src + 86]) + 32768F) >> 16;
  2112:             sndByteBlock[dst + 128] = (byte) t;
  2113:             sndByteBlock[dst + 129] = (byte) (t >> 8);
  2114:             t = (int) (24.576F * u + 26714.112F * v + 36951.3813333333F * (u = (float) OPM.opmBuffer[src + 88]) + 1845.93066666667F * (v = (float) OPM.opmBuffer[src + 90]) + 32768F) >> 16;
  2115:             sndByteBlock[dst + 132] = (byte) t;
  2116:             sndByteBlock[dst + 133] = (byte) (t >> 8);
  2117:             t = (int) (13380.2666666667F * u + 43895.4666666667F * v + 8260.26666666667F * (u = (float) OPM.opmBuffer[src + 92]) + 32768F) >> 16;
  2118:             sndByteBlock[dst + 136] = (byte) t;
  2119:             sndByteBlock[dst + 137] = (byte) (t >> 8);
  2120:             t = (int) (4590.25066666667F * v + 41678.1653333333F * u + 19267.584F * (v = (float) OPM.opmBuffer[src + 94]) + 32768F) >> 16;
  2121:             sndByteBlock[dst + 140] = (byte) t;
  2122:             sndByteBlock[dst + 141] = (byte) (t >> 8);
  2123:             t = (int) (393.216F * u + 31064.064F * v + 33289.5573333333F * (u = (float) OPM.opmBuffer[src + 96]) + 789.162666666667F * (v = (float) OPM.opmBuffer[src + 98]) + 32768F) >> 16;
  2124:             sndByteBlock[dst + 144] = (byte) t;
  2125:             sndByteBlock[dst + 145] = (byte) (t >> 8);
  2126:             t = (int) (17042.0906666667F * u + 42715.8186666667F * v + 5778.09066666667F * (u = (float) OPM.opmBuffer[src + 100]) + 32768F) >> 16;
  2127:             sndByteBlock[dst + 148] = (byte) t;
  2128:             sndByteBlock[dst + 149] = (byte) (t >> 8);
  2129:             t = (int) (6826.66666666667F * v + 43349.3333333333F * u + 15360F * (v = (float) OPM.opmBuffer[src + 102]) + 32768F) >> 16;
  2130:             sndByteBlock[dst + 152] = (byte) t;
  2131:             sndByteBlock[dst + 153] = (byte) (t >> 8);
  2132:             t = (int) (1204.224F * u + 34971.648F * v + 29185.3653333333F * (u = (float) OPM.opmBuffer[src + 104]) + 174.762666666667F * (v = (float) OPM.opmBuffer[src + 106]) + 32768F) >> 16;
  2133:             sndByteBlock[dst + 156] = (byte) t;
  2134:             sndByteBlock[dst + 157] = (byte) (t >> 8);
  2135:             t = (int) (21146.2826666667F * u + 40651.4346666667F * v + 3738.28266666667F * (u = (float) OPM.opmBuffer[src + 108]) + 32768F) >> 16;
  2136:             sndByteBlock[dst + 160] = (byte) t;
  2137:             sndByteBlock[dst + 161] = (byte) (t >> 8);
  2138:             t = (int) (9505.45066666667F * v + 44135.7653333333F * u + 11894.784F * (v = (float) OPM.opmBuffer[src + 110]) + 32768F) >> 16;
  2139:             sndByteBlock[dst + 164] = (byte) t;
  2140:             sndByteBlock[dst + 165] = (byte) (t >> 8);
  2141:             t = (int) (2457.6F * u + 38434.1333333333F * v + 24644.2666666667F * (u = (float) OPM.opmBuffer[src + 112]) + 32768F) >> 16;
  2142:             sndByteBlock[dst + 168] = (byte) t;
  2143:             sndByteBlock[dst + 169] = (byte) (t >> 8);
  2144:             t = (int) (2.73066666666667F * v + 25687.3813333333F * u + 37705.0453333333F * (v = (float) OPM.opmBuffer[src + 114]) + 2140.84266666667F * (u = (float) OPM.opmBuffer[src + 116]) + 32768F) >> 16;
  2145:             sndByteBlock[dst + 172] = (byte) t;
  2146:             sndByteBlock[dst + 173] = (byte) (t >> 8);
  2147:             t = (int) (12626.6026666667F * v + 44037.4613333333F * u + 8871.936F * (v = (float) OPM.opmBuffer[src + 118]) + 32768F) >> 16;
  2148:             sndByteBlock[dst + 176] = (byte) t;
  2149:             sndByteBlock[dst + 177] = (byte) (t >> 8);
  2150:             t = (int) (4153.344F * u + 41186.6453333333F * v + 20196.0106666667F * (u = (float) OPM.opmBuffer[src + 120]) + 32768F) >> 16;
  2151:             sndByteBlock[dst + 180] = (byte) t;
  2152:             sndByteBlock[dst + 181] = (byte) (t >> 8);
  2153:             t = (int) (273.066666666667F * v + 30135.6373333333F * u + 34141.5253333333F * (v = (float) OPM.opmBuffer[src + 122]) + 985.770666666667F * (u = (float) OPM.opmBuffer[src + 124]) + 32768F) >> 16;
  2154:             sndByteBlock[dst + 184] = (byte) t;
  2155:             sndByteBlock[dst + 185] = (byte) (t >> 8);
  2156:             t = (int) (16190.1226666667F * v + 43054.4213333333F * u + 6291.456F * (v = (float) OPM.opmBuffer[src + 126]) + 32768F) >> 16;
  2157:             sndByteBlock[dst + 188] = (byte) t;
  2158:             sndByteBlock[dst + 189] = (byte) (t >> 8);
  2159:             t = (int) (6291.456F * u + 43054.4213333333F * v + 16190.1226666667F * (u = (float) OPM.opmBuffer[src + 128]) + 32768F) >> 16;
  2160:             sndByteBlock[dst + 192] = (byte) t;
  2161:             sndByteBlock[dst + 193] = (byte) (t >> 8);
  2162:             t = (int) (985.770666666667F * v + 34141.5253333333F * u + 30135.6373333333F * (v = (float) OPM.opmBuffer[src + 130]) + 273.066666666667F * (u = (float) OPM.opmBuffer[src + 132]) + 32768F) >> 16;
  2163:             sndByteBlock[dst + 196] = (byte) t;
  2164:             sndByteBlock[dst + 197] = (byte) (t >> 8);
  2165:             t = (int) (20196.0106666667F * v + 41186.6453333333F * u + 4153.344F * (v = (float) OPM.opmBuffer[src + 134]) + 32768F) >> 16;
  2166:             sndByteBlock[dst + 200] = (byte) t;
  2167:             sndByteBlock[dst + 201] = (byte) (t >> 8);
  2168:             t = (int) (8871.936F * u + 44037.4613333333F * v + 12626.6026666667F * (u = (float) OPM.opmBuffer[src + 136]) + 32768F) >> 16;
  2169:             sndByteBlock[dst + 204] = (byte) t;
  2170:             sndByteBlock[dst + 205] = (byte) (t >> 8);
  2171:             t = (int) (2140.84266666667F * v + 37705.0453333333F * u + 25687.3813333333F * (v = (float) OPM.opmBuffer[src + 138]) + 2.73066666666667F * (u = (float) OPM.opmBuffer[src + 140]) + 32768F) >> 16;
  2172:             sndByteBlock[dst + 208] = (byte) t;
  2173:             sndByteBlock[dst + 209] = (byte) (t >> 8);
  2174:             t = (int) (24644.2666666667F * v + 38434.1333333333F * u + 2457.6F * (v = (float) OPM.opmBuffer[src + 142]) + 32768F) >> 16;
  2175:             sndByteBlock[dst + 212] = (byte) t;
  2176:             sndByteBlock[dst + 213] = (byte) (t >> 8);
  2177:             t = (int) (11894.784F * u + 44135.7653333333F * v + 9505.45066666667F * (u = (float) OPM.opmBuffer[src + 144]) + 32768F) >> 16;
  2178:             sndByteBlock[dst + 216] = (byte) t;
  2179:             sndByteBlock[dst + 217] = (byte) (t >> 8);
  2180:             t = (int) (3738.28266666667F * v + 40651.4346666667F * u + 21146.2826666667F * (v = (float) OPM.opmBuffer[src + 146]) + 32768F) >> 16;
  2181:             sndByteBlock[dst + 220] = (byte) t;
  2182:             sndByteBlock[dst + 221] = (byte) (t >> 8);
  2183:             t = (int) (174.762666666667F * u + 29185.3653333333F * v + 34971.648F * (u = (float) OPM.opmBuffer[src + 148]) + 1204.224F * (v = (float) OPM.opmBuffer[src + 150]) + 32768F) >> 16;
  2184:             sndByteBlock[dst + 224] = (byte) t;
  2185:             sndByteBlock[dst + 225] = (byte) (t >> 8);
  2186:             t = (int) (15360F * u + 43349.3333333333F * v + 6826.66666666667F * (u = (float) OPM.opmBuffer[src + 152]) + 32768F) >> 16;
  2187:             sndByteBlock[dst + 228] = (byte) t;
  2188:             sndByteBlock[dst + 229] = (byte) (t >> 8);
  2189:             t = (int) (5778.09066666667F * v + 42715.8186666667F * u + 17042.0906666667F * (v = (float) OPM.opmBuffer[src + 154]) + 32768F) >> 16;
  2190:             sndByteBlock[dst + 232] = (byte) t;
  2191:             sndByteBlock[dst + 233] = (byte) (t >> 8);
  2192:             t = (int) (789.162666666667F * u + 33289.5573333333F * v + 31064.064F * (u = (float) OPM.opmBuffer[src + 156]) + 393.216F * (v = (float) OPM.opmBuffer[src + 158]) + 32768F) >> 16;
  2193:             sndByteBlock[dst + 236] = (byte) t;
  2194:             sndByteBlock[dst + 237] = (byte) (t >> 8);
  2195:             t = (int) (19267.584F * u + 41678.1653333333F * v + 4590.25066666667F * (u = (float) OPM.opmBuffer[src + 160]) + 32768F) >> 16;
  2196:             sndByteBlock[dst + 240] = (byte) t;
  2197:             sndByteBlock[dst + 241] = (byte) (t >> 8);
  2198:             t = (int) (8260.26666666667F * v + 43895.4666666667F * u + 13380.2666666667F * (v = (float) OPM.opmBuffer[src + 162]) + 32768F) >> 16;
  2199:             sndByteBlock[dst + 244] = (byte) t;
  2200:             sndByteBlock[dst + 245] = (byte) (t >> 8);
  2201:             t = (int) (1845.93066666667F * u + 36951.3813333333F * v + 26714.112F * (u = (float) OPM.opmBuffer[src + 164]) + 24.576F * (v = (float) OPM.opmBuffer[src + 166]) + 32768F) >> 16;
  2202:             sndByteBlock[dst + 248] = (byte) t;
  2203:             sndByteBlock[dst + 249] = (byte) (t >> 8);
  2204:             t = (int) (23617.536F * u + 39122.2613333333F * v + 2796.20266666667F * (u = (float) OPM.opmBuffer[src + 168]) + 32768F) >> 16;
  2205:             sndByteBlock[dst + 252] = (byte) t;
  2206:             sndByteBlock[dst + 253] = (byte) (t >> 8);
  2207:             t = (int) (11184.8106666667F * v + 44190.3786666667F * u + 10160.8106666667F * (v = (float) OPM.opmBuffer[src + 170]) + 32768F) >> 16;
  2208:             sndByteBlock[dst + 256] = (byte) t;
  2209:             sndByteBlock[dst + 257] = (byte) (t >> 8);
  2210:             t = (int) (3345.06666666667F * u + 40072.5333333333F * v + 22118.4F * (u = (float) OPM.opmBuffer[src + 172]) + 32768F) >> 16;
  2211:             sndByteBlock[dst + 260] = (byte) t;
  2212:             sndByteBlock[dst + 261] = (byte) (t >> 8);
  2213:             t = (int) (98.304F * v + 28213.248F * u + 35779.9253333333F * (v = (float) OPM.opmBuffer[src + 174]) + 1444.52266666667F * (u = (float) OPM.opmBuffer[src + 176]) + 32768F) >> 16;
  2214:             sndByteBlock[dst + 264] = (byte) t;
  2215:             sndByteBlock[dst + 265] = (byte) (t >> 8);
  2216:             t = (int) (14551.7226666667F * v + 43600.5546666667F * u + 7383.72266666667F * (v = (float) OPM.opmBuffer[src + 178]) + 32768F) >> 16;
  2217:             sndByteBlock[dst + 268] = (byte) t;
  2218:             sndByteBlock[dst + 269] = (byte) (t >> 8);
  2219:             t = (int) (5286.57066666667F * u + 42333.5253333333F * v + 17915.904F * (u = (float) OPM.opmBuffer[src + 180]) + 32768F) >> 16;
  2220:             sndByteBlock[dst + 272] = (byte) t;
  2221:             sndByteBlock[dst + 273] = (byte) (t >> 8);
  2222:             t = (int) (614.4F * v + 32415.744F * u + 31970.6453333333F * (v = (float) OPM.opmBuffer[src + 182]) + 535.210666666667F * (u = (float) OPM.opmBuffer[src + 184]) + 32768F) >> 16;
  2223:             sndByteBlock[dst + 276] = (byte) t;
  2224:             sndByteBlock[dst + 277] = (byte) (t >> 8);
  2225:             t = (int) (18361.0026666667F * v + 42125.9946666667F * u + 5049.00266666667F * (v = (float) OPM.opmBuffer[src + 186]) + 32768F) >> 16;
  2226:             sndByteBlock[dst + 280] = (byte) t;
  2227:             sndByteBlock[dst + 281] = (byte) (t >> 8);
  2228:             t = (int) (7670.44266666667F * u + 43709.7813333333F * v + 14155.776F * (u = (float) OPM.opmBuffer[src + 188]) + 32768F) >> 16;
  2229:             sndByteBlock[dst + 284] = (byte) t;
  2230:             sndByteBlock[dst + 285] = (byte) (t >> 8);
  2231:             t = (int) (1572.864F * v + 36175.872F * u + 27718.9973333333F * (v = (float) OPM.opmBuffer[src + 190]) + 68.2666666666667F * (u = (float) OPM.opmBuffer[src + 192]) + 32768F) >> 16;
  2232:             sndByteBlock[dst + 288] = (byte) t;
  2233:             sndByteBlock[dst + 289] = (byte) (t >> 8);
  2234:             t = (int) (22612.6506666667F * v + 39766.6986666667F * u + 3156.65066666667F * (v = (float) OPM.opmBuffer[src + 194]) + 32768F) >> 16;
  2235:             sndByteBlock[dst + 292] = (byte) t;
  2236:             sndByteBlock[dst + 293] = (byte) (t >> 8);
  2237:             t = (int) (10496.6826666667F * u + 44201.3013333333F * v + 10838.016F * (u = (float) OPM.opmBuffer[src + 196]) + 32768F) >> 16;
  2238:             sndByteBlock[dst + 296] = (byte) t;
  2239:             sndByteBlock[dst + 297] = (byte) (t >> 8);
  2240:             t = (int) (2973.696F * v + 39449.9413333333F * u + 23112.3626666667F * (v = (float) OPM.opmBuffer[src + 198]) + 32768F) >> 16;
  2241:             sndByteBlock[dst + 300] = (byte) t;
  2242:             sndByteBlock[dst + 301] = (byte) (t >> 8);
  2243:             t = (int) (43.6906666666667F * u + 27219.2853333333F * v + 36566.3573333333F * (u = (float) OPM.opmBuffer[src + 200]) + 1706.66666666667F * (v = (float) OPM.opmBuffer[src + 202]) + 32768F) >> 16;
  2244:             sndByteBlock[dst + 304] = (byte) t;
  2245:             sndByteBlock[dst + 305] = (byte) (t >> 8);
  2246:             t = (int) (13765.2906666667F * u + 43808.0853333333F * v + 7962.624F * (u = (float) OPM.opmBuffer[src + 204]) + 32768F) >> 16;
  2247:             sndByteBlock[dst + 308] = (byte) t;
  2248:             sndByteBlock[dst + 309] = (byte) (t >> 8);
  2249:             t = (int) (4816.896F * v + 41907.5413333333F * u + 18811.5626666667F * (v = (float) OPM.opmBuffer[src + 206]) + 32768F) >> 16;
  2250:             sndByteBlock[dst + 312] = (byte) t;
  2251:             sndByteBlock[dst + 313] = (byte) (t >> 8);
  2252:             t = (int) (461.482666666667F * u + 31520.0853333333F * v + 32855.3813333333F * (u = (float) OPM.opmBuffer[src + 208]) + 699.050666666667F * (v = (float) OPM.opmBuffer[src + 210]) + 32768F) >> 16;
  2253:             sndByteBlock[dst + 316] = (byte) t;
  2254:             sndByteBlock[dst + 317] = (byte) (t >> 8);
  2255:             t = (int) (17476.2666666667F * u + 42530.1333333333F * v + 5529.6F * (u = (float) OPM.opmBuffer[src + 212]) + 32768F) >> 16;
  2256:             sndByteBlock[dst + 320] = (byte) t;
  2257:             sndByteBlock[dst + 321] = (byte) (t >> 8);
  2258:             t = (int) (7102.464F * v + 43480.4053333333F * u + 14953.1306666667F * (v = (float) OPM.opmBuffer[src + 214]) + 32768F) >> 16;
  2259:             sndByteBlock[dst + 324] = (byte) t;
  2260:             sndByteBlock[dst + 325] = (byte) (t >> 8);
  2261:             t = (int) (1321.64266666667F * u + 35378.5173333333F * v + 28702.0373333333F * (u = (float) OPM.opmBuffer[src + 216]) + 133.802666666667F * (v = (float) OPM.opmBuffer[src + 218]) + 32768F) >> 16;
  2262:             sndByteBlock[dst + 328] = (byte) t;
  2263:             sndByteBlock[dst + 329] = (byte) (t >> 8);
  2264:             t = (int) (21629.6106666667F * u + 40367.4453333333F * v + 3538.944F * (u = (float) OPM.opmBuffer[src + 220]) + 32768F) >> 16;
  2265:             sndByteBlock[dst + 332] = (byte) t;
  2266:             sndByteBlock[dst + 333] = (byte) (t >> 8);
  2267:             t = (int) (9830.4F * v + 44168.5333333333F * u + 11537.0666666667F * (v = (float) OPM.opmBuffer[src + 222]) + 32768F) >> 16;
  2268:             sndByteBlock[dst + 336] = (byte) t;
  2269:             sndByteBlock[dst + 337] = (byte) (t >> 8);
  2270:             t = (int) (2624.17066666667F * u + 38783.6586666667F * v + 24128.1706666667F * (u = (float) OPM.opmBuffer[src + 224]) + 32768F) >> 16;
  2271:             sndByteBlock[dst + 340] = (byte) t;
  2272:             sndByteBlock[dst + 341] = (byte) (t >> 8);
  2273:             t = (int) (10.9226666666667F * v + 26203.4773333333F * u + 37330.944F * (v = (float) OPM.opmBuffer[src + 226]) + 1990.656F * (u = (float) OPM.opmBuffer[src + 228]) + 32768F) >> 16;
  2274:             sndByteBlock[dst + 344] = (byte) t;
  2275:             sndByteBlock[dst + 345] = (byte) (t >> 8);
  2276:             t = (int) (13000.704F * v + 43971.9253333333F * u + 8563.37066666667F * (v = (float) OPM.opmBuffer[src + 230]) + 32768F) >> 16;
  2277:             sndByteBlock[dst + 348] = (byte) t;
  2278:             sndByteBlock[dst + 349] = (byte) (t >> 8);
  2279:             t = (int) (4369.06666666667F * u + 41437.8666666667F * v + 19729.0666666667F * (u = (float) OPM.opmBuffer[src + 232]) + 32768F) >> 16;
  2280:             sndByteBlock[dst + 352] = (byte) t;
  2281:             sndByteBlock[dst + 353] = (byte) (t >> 8);
  2282:             t = (int) (330.410666666667F * v + 30602.5813333333F * u + 33718.272F * (v = (float) OPM.opmBuffer[src + 234]) + 884.736F * (u = (float) OPM.opmBuffer[src + 236]) + 32768F) >> 16;
  2283:             sndByteBlock[dst + 356] = (byte) t;
  2284:             sndByteBlock[dst + 357] = (byte) (t >> 8);
  2285:             t = (int) (16613.376F * v + 42890.5813333333F * u + 6032.04266666667F * (v = (float) OPM.opmBuffer[src + 238]) + 32768F) >> 16;
  2286:             sndByteBlock[dst + 360] = (byte) t;
  2287:             sndByteBlock[dst + 361] = (byte) (t >> 8);
  2288:             t = (int) (6556.33066666667F * u + 43207.3386666667F * v + 15772.3306666667F * (u = (float) OPM.opmBuffer[src + 240]) + 32768F) >> 16;
  2289:             sndByteBlock[dst + 364] = (byte) t;
  2290:             sndByteBlock[dst + 365] = (byte) (t >> 8);
  2291:             t = (int) (1092.26666666667F * v + 34559.3173333333F * u + 29663.232F * (v = (float) OPM.opmBuffer[src + 242]) + 221.184F * (u = (float) OPM.opmBuffer[src + 244]) + 32768F) >> 16;
  2292:             sndByteBlock[dst + 368] = (byte) t;
  2293:             sndByteBlock[dst + 369] = (byte) (t >> 8);
  2294:             t = (int) (20668.416F * v + 40924.5013333333F * u + 3943.08266666667F * (v = (float) OPM.opmBuffer[src + 246]) + 32768F) >> 16;
  2295:             sndByteBlock[dst + 372] = (byte) t;
  2296:             sndByteBlock[dst + 373] = (byte) (t >> 8);
  2297:             t = (int) (9185.96266666667F * u + 44092.0746666667F * v + 12257.9626666667F * (u = (float) OPM.opmBuffer[src + 248]) + 32768F) >> 16;
  2298:             sndByteBlock[dst + 376] = (byte) t;
  2299:             sndByteBlock[dst + 377] = (byte) (t >> 8);
  2300:             t = (int) (2296.49066666667F * v + 38073.6853333333F * u + 25165.824F * (float) OPM.opmBuffer[src + 250] + 32768F) >> 16;
  2301:             sndByteBlock[dst + 380] = (byte) t;
  2302:             sndByteBlock[dst + 381] = (byte) (t >> 8);
  2303:             //right
  2304:             t = (int) (25165.824F * (float) OPM.opmBuffer[src + 1] + 38073.6853333333F * (v = (float) OPM.opmBuffer[src + 3]) + 2296.49066666667F * (u = (float) OPM.opmBuffer[src + 5]) + 32768F) >> 16;
  2305:             sndByteBlock[dst + 2] = (byte) t;
  2306:             sndByteBlock[dst + 3] = (byte) (t >> 8);
  2307:             t = (int) (12257.9626666667F * v + 44092.0746666667F * u + 9185.96266666667F * (v = (float) OPM.opmBuffer[src + 7]) + 32768F) >> 16;
  2308:             sndByteBlock[dst + 6] = (byte) t;
  2309:             sndByteBlock[dst + 7] = (byte) (t >> 8);
  2310:             t = (int) (3943.08266666667F * u + 40924.5013333333F * v + 20668.416F * (u = (float) OPM.opmBuffer[src + 9]) + 32768F) >> 16;
  2311:             sndByteBlock[dst + 10] = (byte) t;
  2312:             sndByteBlock[dst + 11] = (byte) (t >> 8);
  2313:             t = (int) (221.184F * v + 29663.232F * u + 34559.3173333333F * (v = (float) OPM.opmBuffer[src + 11]) + 1092.26666666667F * (u = (float) OPM.opmBuffer[src + 13]) + 32768F) >> 16;
  2314:             sndByteBlock[dst + 14] = (byte) t;
  2315:             sndByteBlock[dst + 15] = (byte) (t >> 8);
  2316:             t = (int) (15772.3306666667F * v + 43207.3386666667F * u + 6556.33066666667F * (v = (float) OPM.opmBuffer[src + 15]) + 32768F) >> 16;
  2317:             sndByteBlock[dst + 18] = (byte) t;
  2318:             sndByteBlock[dst + 19] = (byte) (t >> 8);
  2319:             t = (int) (6032.04266666667F * u + 42890.5813333333F * v + 16613.376F * (u = (float) OPM.opmBuffer[src + 17]) + 32768F) >> 16;
  2320:             sndByteBlock[dst + 22] = (byte) t;
  2321:             sndByteBlock[dst + 23] = (byte) (t >> 8);
  2322:             t = (int) (884.736F * v + 33718.272F * u + 30602.5813333333F * (v = (float) OPM.opmBuffer[src + 19]) + 330.410666666667F * (u = (float) OPM.opmBuffer[src + 21]) + 32768F) >> 16;
  2323:             sndByteBlock[dst + 26] = (byte) t;
  2324:             sndByteBlock[dst + 27] = (byte) (t >> 8);
  2325:             t = (int) (19729.0666666667F * v + 41437.8666666667F * u + 4369.06666666667F * (v = (float) OPM.opmBuffer[src + 23]) + 32768F) >> 16;
  2326:             sndByteBlock[dst + 30] = (byte) t;
  2327:             sndByteBlock[dst + 31] = (byte) (t >> 8);
  2328:             t = (int) (8563.37066666667F * u + 43971.9253333333F * v + 13000.704F * (u = (float) OPM.opmBuffer[src + 25]) + 32768F) >> 16;
  2329:             sndByteBlock[dst + 34] = (byte) t;
  2330:             sndByteBlock[dst + 35] = (byte) (t >> 8);
  2331:             t = (int) (1990.656F * v + 37330.944F * u + 26203.4773333333F * (v = (float) OPM.opmBuffer[src + 27]) + 10.9226666666667F * (u = (float) OPM.opmBuffer[src + 29]) + 32768F) >> 16;
  2332:             sndByteBlock[dst + 38] = (byte) t;
  2333:             sndByteBlock[dst + 39] = (byte) (t >> 8);
  2334:             t = (int) (24128.1706666667F * v + 38783.6586666667F * u + 2624.17066666667F * (v = (float) OPM.opmBuffer[src + 31]) + 32768F) >> 16;
  2335:             sndByteBlock[dst + 42] = (byte) t;
  2336:             sndByteBlock[dst + 43] = (byte) (t >> 8);
  2337:             t = (int) (11537.0666666667F * u + 44168.5333333333F * v + 9830.4F * (u = (float) OPM.opmBuffer[src + 33]) + 32768F) >> 16;
  2338:             sndByteBlock[dst + 46] = (byte) t;
  2339:             sndByteBlock[dst + 47] = (byte) (t >> 8);
  2340:             t = (int) (3538.944F * v + 40367.4453333333F * u + 21629.6106666667F * (v = (float) OPM.opmBuffer[src + 35]) + 32768F) >> 16;
  2341:             sndByteBlock[dst + 50] = (byte) t;
  2342:             sndByteBlock[dst + 51] = (byte) (t >> 8);
  2343:             t = (int) (133.802666666667F * u + 28702.0373333333F * v + 35378.5173333333F * (u = (float) OPM.opmBuffer[src + 37]) + 1321.64266666667F * (v = (float) OPM.opmBuffer[src + 39]) + 32768F) >> 16;
  2344:             sndByteBlock[dst + 54] = (byte) t;
  2345:             sndByteBlock[dst + 55] = (byte) (t >> 8);
  2346:             t = (int) (14953.1306666667F * u + 43480.4053333333F * v + 7102.464F * (u = (float) OPM.opmBuffer[src + 41]) + 32768F) >> 16;
  2347:             sndByteBlock[dst + 58] = (byte) t;
  2348:             sndByteBlock[dst + 59] = (byte) (t >> 8);
  2349:             t = (int) (5529.6F * v + 42530.1333333333F * u + 17476.2666666667F * (v = (float) OPM.opmBuffer[src + 43]) + 32768F) >> 16;
  2350:             sndByteBlock[dst + 62] = (byte) t;
  2351:             sndByteBlock[dst + 63] = (byte) (t >> 8);
  2352:             t = (int) (699.050666666667F * u + 32855.3813333333F * v + 31520.0853333333F * (u = (float) OPM.opmBuffer[src + 45]) + 461.482666666667F * (v = (float) OPM.opmBuffer[src + 47]) + 32768F) >> 16;
  2353:             sndByteBlock[dst + 66] = (byte) t;
  2354:             sndByteBlock[dst + 67] = (byte) (t >> 8);
  2355:             t = (int) (18811.5626666667F * u + 41907.5413333333F * v + 4816.896F * (u = (float) OPM.opmBuffer[src + 49]) + 32768F) >> 16;
  2356:             sndByteBlock[dst + 70] = (byte) t;
  2357:             sndByteBlock[dst + 71] = (byte) (t >> 8);
  2358:             t = (int) (7962.624F * v + 43808.0853333333F * u + 13765.2906666667F * (v = (float) OPM.opmBuffer[src + 51]) + 32768F) >> 16;
  2359:             sndByteBlock[dst + 74] = (byte) t;
  2360:             sndByteBlock[dst + 75] = (byte) (t >> 8);
  2361:             t = (int) (1706.66666666667F * u + 36566.3573333333F * v + 27219.2853333333F * (u = (float) OPM.opmBuffer[src + 53]) + 43.6906666666667F * (v = (float) OPM.opmBuffer[src + 55]) + 32768F) >> 16;
  2362:             sndByteBlock[dst + 78] = (byte) t;
  2363:             sndByteBlock[dst + 79] = (byte) (t >> 8);
  2364:             t = (int) (23112.3626666667F * u + 39449.9413333333F * v + 2973.696F * (u = (float) OPM.opmBuffer[src + 57]) + 32768F) >> 16;
  2365:             sndByteBlock[dst + 82] = (byte) t;
  2366:             sndByteBlock[dst + 83] = (byte) (t >> 8);
  2367:             t = (int) (10838.016F * v + 44201.3013333333F * u + 10496.6826666667F * (v = (float) OPM.opmBuffer[src + 59]) + 32768F) >> 16;
  2368:             sndByteBlock[dst + 86] = (byte) t;
  2369:             sndByteBlock[dst + 87] = (byte) (t >> 8);
  2370:             t = (int) (3156.65066666667F * u + 39766.6986666667F * v + 22612.6506666667F * (u = (float) OPM.opmBuffer[src + 61]) + 32768F) >> 16;
  2371:             sndByteBlock[dst + 90] = (byte) t;
  2372:             sndByteBlock[dst + 91] = (byte) (t >> 8);
  2373:             t = (int) (68.2666666666667F * v + 27718.9973333333F * u + 36175.872F * (v = (float) OPM.opmBuffer[src + 63]) + 1572.864F * (u = (float) OPM.opmBuffer[src + 65]) + 32768F) >> 16;
  2374:             sndByteBlock[dst + 94] = (byte) t;
  2375:             sndByteBlock[dst + 95] = (byte) (t >> 8);
  2376:             t = (int) (14155.776F * v + 43709.7813333333F * u + 7670.44266666667F * (v = (float) OPM.opmBuffer[src + 67]) + 32768F) >> 16;
  2377:             sndByteBlock[dst + 98] = (byte) t;
  2378:             sndByteBlock[dst + 99] = (byte) (t >> 8);
  2379:             t = (int) (5049.00266666667F * u + 42125.9946666667F * v + 18361.0026666667F * (u = (float) OPM.opmBuffer[src + 69]) + 32768F) >> 16;
  2380:             sndByteBlock[dst + 102] = (byte) t;
  2381:             sndByteBlock[dst + 103] = (byte) (t >> 8);
  2382:             t = (int) (535.210666666667F * v + 31970.6453333333F * u + 32415.744F * (v = (float) OPM.opmBuffer[src + 71]) + 614.4F * (u = (float) OPM.opmBuffer[src + 73]) + 32768F) >> 16;
  2383:             sndByteBlock[dst + 106] = (byte) t;
  2384:             sndByteBlock[dst + 107] = (byte) (t >> 8);
  2385:             t = (int) (17915.904F * v + 42333.5253333333F * u + 5286.57066666667F * (v = (float) OPM.opmBuffer[src + 75]) + 32768F) >> 16;
  2386:             sndByteBlock[dst + 110] = (byte) t;
  2387:             sndByteBlock[dst + 111] = (byte) (t >> 8);
  2388:             t = (int) (7383.72266666667F * u + 43600.5546666667F * v + 14551.7226666667F * (u = (float) OPM.opmBuffer[src + 77]) + 32768F) >> 16;
  2389:             sndByteBlock[dst + 114] = (byte) t;
  2390:             sndByteBlock[dst + 115] = (byte) (t >> 8);
  2391:             t = (int) (1444.52266666667F * v + 35779.9253333333F * u + 28213.248F * (v = (float) OPM.opmBuffer[src + 79]) + 98.304F * (u = (float) OPM.opmBuffer[src + 81]) + 32768F) >> 16;
  2392:             sndByteBlock[dst + 118] = (byte) t;
  2393:             sndByteBlock[dst + 119] = (byte) (t >> 8);
  2394:             t = (int) (22118.4F * v + 40072.5333333333F * u + 3345.06666666667F * (v = (float) OPM.opmBuffer[src + 83]) + 32768F) >> 16;
  2395:             sndByteBlock[dst + 122] = (byte) t;
  2396:             sndByteBlock[dst + 123] = (byte) (t >> 8);
  2397:             t = (int) (10160.8106666667F * u + 44190.3786666667F * v + 11184.8106666667F * (u = (float) OPM.opmBuffer[src + 85]) + 32768F) >> 16;
  2398:             sndByteBlock[dst + 126] = (byte) t;
  2399:             sndByteBlock[dst + 127] = (byte) (t >> 8);
  2400:             t = (int) (2796.20266666667F * v + 39122.2613333333F * u + 23617.536F * (v = (float) OPM.opmBuffer[src + 87]) + 32768F) >> 16;
  2401:             sndByteBlock[dst + 130] = (byte) t;
  2402:             sndByteBlock[dst + 131] = (byte) (t >> 8);
  2403:             t = (int) (24.576F * u + 26714.112F * v + 36951.3813333333F * (u = (float) OPM.opmBuffer[src + 89]) + 1845.93066666667F * (v = (float) OPM.opmBuffer[src + 91]) + 32768F) >> 16;
  2404:             sndByteBlock[dst + 134] = (byte) t;
  2405:             sndByteBlock[dst + 135] = (byte) (t >> 8);
  2406:             t = (int) (13380.2666666667F * u + 43895.4666666667F * v + 8260.26666666667F * (u = (float) OPM.opmBuffer[src + 93]) + 32768F) >> 16;
  2407:             sndByteBlock[dst + 138] = (byte) t;
  2408:             sndByteBlock[dst + 139] = (byte) (t >> 8);
  2409:             t = (int) (4590.25066666667F * v + 41678.1653333333F * u + 19267.584F * (v = (float) OPM.opmBuffer[src + 95]) + 32768F) >> 16;
  2410:             sndByteBlock[dst + 142] = (byte) t;
  2411:             sndByteBlock[dst + 143] = (byte) (t >> 8);
  2412:             t = (int) (393.216F * u + 31064.064F * v + 33289.5573333333F * (u = (float) OPM.opmBuffer[src + 97]) + 789.162666666667F * (v = (float) OPM.opmBuffer[src + 99]) + 32768F) >> 16;
  2413:             sndByteBlock[dst + 146] = (byte) t;
  2414:             sndByteBlock[dst + 147] = (byte) (t >> 8);
  2415:             t = (int) (17042.0906666667F * u + 42715.8186666667F * v + 5778.09066666667F * (u = (float) OPM.opmBuffer[src + 101]) + 32768F) >> 16;
  2416:             sndByteBlock[dst + 150] = (byte) t;
  2417:             sndByteBlock[dst + 151] = (byte) (t >> 8);
  2418:             t = (int) (6826.66666666667F * v + 43349.3333333333F * u + 15360F * (v = (float) OPM.opmBuffer[src + 103]) + 32768F) >> 16;
  2419:             sndByteBlock[dst + 154] = (byte) t;
  2420:             sndByteBlock[dst + 155] = (byte) (t >> 8);
  2421:             t = (int) (1204.224F * u + 34971.648F * v + 29185.3653333333F * (u = (float) OPM.opmBuffer[src + 105]) + 174.762666666667F * (v = (float) OPM.opmBuffer[src + 107]) + 32768F) >> 16;
  2422:             sndByteBlock[dst + 158] = (byte) t;
  2423:             sndByteBlock[dst + 159] = (byte) (t >> 8);
  2424:             t = (int) (21146.2826666667F * u + 40651.4346666667F * v + 3738.28266666667F * (u = (float) OPM.opmBuffer[src + 109]) + 32768F) >> 16;
  2425:             sndByteBlock[dst + 162] = (byte) t;
  2426:             sndByteBlock[dst + 163] = (byte) (t >> 8);
  2427:             t = (int) (9505.45066666667F * v + 44135.7653333333F * u + 11894.784F * (v = (float) OPM.opmBuffer[src + 111]) + 32768F) >> 16;
  2428:             sndByteBlock[dst + 166] = (byte) t;
  2429:             sndByteBlock[dst + 167] = (byte) (t >> 8);
  2430:             t = (int) (2457.6F * u + 38434.1333333333F * v + 24644.2666666667F * (u = (float) OPM.opmBuffer[src + 113]) + 32768F) >> 16;
  2431:             sndByteBlock[dst + 170] = (byte) t;
  2432:             sndByteBlock[dst + 171] = (byte) (t >> 8);
  2433:             t = (int) (2.73066666666667F * v + 25687.3813333333F * u + 37705.0453333333F * (v = (float) OPM.opmBuffer[src + 115]) + 2140.84266666667F * (u = (float) OPM.opmBuffer[src + 117]) + 32768F) >> 16;
  2434:             sndByteBlock[dst + 174] = (byte) t;
  2435:             sndByteBlock[dst + 175] = (byte) (t >> 8);
  2436:             t = (int) (12626.6026666667F * v + 44037.4613333333F * u + 8871.936F * (v = (float) OPM.opmBuffer[src + 119]) + 32768F) >> 16;
  2437:             sndByteBlock[dst + 178] = (byte) t;
  2438:             sndByteBlock[dst + 179] = (byte) (t >> 8);
  2439:             t = (int) (4153.344F * u + 41186.6453333333F * v + 20196.0106666667F * (u = (float) OPM.opmBuffer[src + 121]) + 32768F) >> 16;
  2440:             sndByteBlock[dst + 182] = (byte) t;
  2441:             sndByteBlock[dst + 183] = (byte) (t >> 8);
  2442:             t = (int) (273.066666666667F * v + 30135.6373333333F * u + 34141.5253333333F * (v = (float) OPM.opmBuffer[src + 123]) + 985.770666666667F * (u = (float) OPM.opmBuffer[src + 125]) + 32768F) >> 16;
  2443:             sndByteBlock[dst + 186] = (byte) t;
  2444:             sndByteBlock[dst + 187] = (byte) (t >> 8);
  2445:             t = (int) (16190.1226666667F * v + 43054.4213333333F * u + 6291.456F * (v = (float) OPM.opmBuffer[src + 127]) + 32768F) >> 16;
  2446:             sndByteBlock[dst + 190] = (byte) t;
  2447:             sndByteBlock[dst + 191] = (byte) (t >> 8);
  2448:             t = (int) (6291.456F * u + 43054.4213333333F * v + 16190.1226666667F * (u = (float) OPM.opmBuffer[src + 129]) + 32768F) >> 16;
  2449:             sndByteBlock[dst + 194] = (byte) t;
  2450:             sndByteBlock[dst + 195] = (byte) (t >> 8);
  2451:             t = (int) (985.770666666667F * v + 34141.5253333333F * u + 30135.6373333333F * (v = (float) OPM.opmBuffer[src + 131]) + 273.066666666667F * (u = (float) OPM.opmBuffer[src + 133]) + 32768F) >> 16;
  2452:             sndByteBlock[dst + 198] = (byte) t;
  2453:             sndByteBlock[dst + 199] = (byte) (t >> 8);
  2454:             t = (int) (20196.0106666667F * v + 41186.6453333333F * u + 4153.344F * (v = (float) OPM.opmBuffer[src + 135]) + 32768F) >> 16;
  2455:             sndByteBlock[dst + 202] = (byte) t;
  2456:             sndByteBlock[dst + 203] = (byte) (t >> 8);
  2457:             t = (int) (8871.936F * u + 44037.4613333333F * v + 12626.6026666667F * (u = (float) OPM.opmBuffer[src + 137]) + 32768F) >> 16;
  2458:             sndByteBlock[dst + 206] = (byte) t;
  2459:             sndByteBlock[dst + 207] = (byte) (t >> 8);
  2460:             t = (int) (2140.84266666667F * v + 37705.0453333333F * u + 25687.3813333333F * (v = (float) OPM.opmBuffer[src + 139]) + 2.73066666666667F * (u = (float) OPM.opmBuffer[src + 141]) + 32768F) >> 16;
  2461:             sndByteBlock[dst + 210] = (byte) t;
  2462:             sndByteBlock[dst + 211] = (byte) (t >> 8);
  2463:             t = (int) (24644.2666666667F * v + 38434.1333333333F * u + 2457.6F * (v = (float) OPM.opmBuffer[src + 143]) + 32768F) >> 16;
  2464:             sndByteBlock[dst + 214] = (byte) t;
  2465:             sndByteBlock[dst + 215] = (byte) (t >> 8);
  2466:             t = (int) (11894.784F * u + 44135.7653333333F * v + 9505.45066666667F * (u = (float) OPM.opmBuffer[src + 145]) + 32768F) >> 16;
  2467:             sndByteBlock[dst + 218] = (byte) t;
  2468:             sndByteBlock[dst + 219] = (byte) (t >> 8);
  2469:             t = (int) (3738.28266666667F * v + 40651.4346666667F * u + 21146.2826666667F * (v = (float) OPM.opmBuffer[src + 147]) + 32768F) >> 16;
  2470:             sndByteBlock[dst + 222] = (byte) t;
  2471:             sndByteBlock[dst + 223] = (byte) (t >> 8);
  2472:             t = (int) (174.762666666667F * u + 29185.3653333333F * v + 34971.648F * (u = (float) OPM.opmBuffer[src + 149]) + 1204.224F * (v = (float) OPM.opmBuffer[src + 151]) + 32768F) >> 16;
  2473:             sndByteBlock[dst + 226] = (byte) t;
  2474:             sndByteBlock[dst + 227] = (byte) (t >> 8);
  2475:             t = (int) (15360F * u + 43349.3333333333F * v + 6826.66666666667F * (u = (float) OPM.opmBuffer[src + 153]) + 32768F) >> 16;
  2476:             sndByteBlock[dst + 230] = (byte) t;
  2477:             sndByteBlock[dst + 231] = (byte) (t >> 8);
  2478:             t = (int) (5778.09066666667F * v + 42715.8186666667F * u + 17042.0906666667F * (v = (float) OPM.opmBuffer[src + 155]) + 32768F) >> 16;
  2479:             sndByteBlock[dst + 234] = (byte) t;
  2480:             sndByteBlock[dst + 235] = (byte) (t >> 8);
  2481:             t = (int) (789.162666666667F * u + 33289.5573333333F * v + 31064.064F * (u = (float) OPM.opmBuffer[src + 157]) + 393.216F * (v = (float) OPM.opmBuffer[src + 159]) + 32768F) >> 16;
  2482:             sndByteBlock[dst + 238] = (byte) t;
  2483:             sndByteBlock[dst + 239] = (byte) (t >> 8);
  2484:             t = (int) (19267.584F * u + 41678.1653333333F * v + 4590.25066666667F * (u = (float) OPM.opmBuffer[src + 161]) + 32768F) >> 16;
  2485:             sndByteBlock[dst + 242] = (byte) t;
  2486:             sndByteBlock[dst + 243] = (byte) (t >> 8);
  2487:             t = (int) (8260.26666666667F * v + 43895.4666666667F * u + 13380.2666666667F * (v = (float) OPM.opmBuffer[src + 163]) + 32768F) >> 16;
  2488:             sndByteBlock[dst + 246] = (byte) t;
  2489:             sndByteBlock[dst + 247] = (byte) (t >> 8);
  2490:             t = (int) (1845.93066666667F * u + 36951.3813333333F * v + 26714.112F * (u = (float) OPM.opmBuffer[src + 165]) + 24.576F * (v = (float) OPM.opmBuffer[src + 167]) + 32768F) >> 16;
  2491:             sndByteBlock[dst + 250] = (byte) t;
  2492:             sndByteBlock[dst + 251] = (byte) (t >> 8);
  2493:             t = (int) (23617.536F * u + 39122.2613333333F * v + 2796.20266666667F * (u = (float) OPM.opmBuffer[src + 169]) + 32768F) >> 16;
  2494:             sndByteBlock[dst + 254] = (byte) t;
  2495:             sndByteBlock[dst + 255] = (byte) (t >> 8);
  2496:             t = (int) (11184.8106666667F * v + 44190.3786666667F * u + 10160.8106666667F * (v = (float) OPM.opmBuffer[src + 171]) + 32768F) >> 16;
  2497:             sndByteBlock[dst + 258] = (byte) t;
  2498:             sndByteBlock[dst + 259] = (byte) (t >> 8);
  2499:             t = (int) (3345.06666666667F * u + 40072.5333333333F * v + 22118.4F * (u = (float) OPM.opmBuffer[src + 173]) + 32768F) >> 16;
  2500:             sndByteBlock[dst + 262] = (byte) t;
  2501:             sndByteBlock[dst + 263] = (byte) (t >> 8);
  2502:             t = (int) (98.304F * v + 28213.248F * u + 35779.9253333333F * (v = (float) OPM.opmBuffer[src + 175]) + 1444.52266666667F * (u = (float) OPM.opmBuffer[src + 177]) + 32768F) >> 16;
  2503:             sndByteBlock[dst + 266] = (byte) t;
  2504:             sndByteBlock[dst + 267] = (byte) (t >> 8);
  2505:             t = (int) (14551.7226666667F * v + 43600.5546666667F * u + 7383.72266666667F * (v = (float) OPM.opmBuffer[src + 179]) + 32768F) >> 16;
  2506:             sndByteBlock[dst + 270] = (byte) t;
  2507:             sndByteBlock[dst + 271] = (byte) (t >> 8);
  2508:             t = (int) (5286.57066666667F * u + 42333.5253333333F * v + 17915.904F * (u = (float) OPM.opmBuffer[src + 181]) + 32768F) >> 16;
  2509:             sndByteBlock[dst + 274] = (byte) t;
  2510:             sndByteBlock[dst + 275] = (byte) (t >> 8);
  2511:             t = (int) (614.4F * v + 32415.744F * u + 31970.6453333333F * (v = (float) OPM.opmBuffer[src + 183]) + 535.210666666667F * (u = (float) OPM.opmBuffer[src + 185]) + 32768F) >> 16;
  2512:             sndByteBlock[dst + 278] = (byte) t;
  2513:             sndByteBlock[dst + 279] = (byte) (t >> 8);
  2514:             t = (int) (18361.0026666667F * v + 42125.9946666667F * u + 5049.00266666667F * (v = (float) OPM.opmBuffer[src + 187]) + 32768F) >> 16;
  2515:             sndByteBlock[dst + 282] = (byte) t;
  2516:             sndByteBlock[dst + 283] = (byte) (t >> 8);
  2517:             t = (int) (7670.44266666667F * u + 43709.7813333333F * v + 14155.776F * (u = (float) OPM.opmBuffer[src + 189]) + 32768F) >> 16;
  2518:             sndByteBlock[dst + 286] = (byte) t;
  2519:             sndByteBlock[dst + 287] = (byte) (t >> 8);
  2520:             t = (int) (1572.864F * v + 36175.872F * u + 27718.9973333333F * (v = (float) OPM.opmBuffer[src + 191]) + 68.2666666666667F * (u = (float) OPM.opmBuffer[src + 193]) + 32768F) >> 16;
  2521:             sndByteBlock[dst + 290] = (byte) t;
  2522:             sndByteBlock[dst + 291] = (byte) (t >> 8);
  2523:             t = (int) (22612.6506666667F * v + 39766.6986666667F * u + 3156.65066666667F * (v = (float) OPM.opmBuffer[src + 195]) + 32768F) >> 16;
  2524:             sndByteBlock[dst + 294] = (byte) t;
  2525:             sndByteBlock[dst + 295] = (byte) (t >> 8);
  2526:             t = (int) (10496.6826666667F * u + 44201.3013333333F * v + 10838.016F * (u = (float) OPM.opmBuffer[src + 197]) + 32768F) >> 16;
  2527:             sndByteBlock[dst + 298] = (byte) t;
  2528:             sndByteBlock[dst + 299] = (byte) (t >> 8);
  2529:             t = (int) (2973.696F * v + 39449.9413333333F * u + 23112.3626666667F * (v = (float) OPM.opmBuffer[src + 199]) + 32768F) >> 16;
  2530:             sndByteBlock[dst + 302] = (byte) t;
  2531:             sndByteBlock[dst + 303] = (byte) (t >> 8);
  2532:             t = (int) (43.6906666666667F * u + 27219.2853333333F * v + 36566.3573333333F * (u = (float) OPM.opmBuffer[src + 201]) + 1706.66666666667F * (v = (float) OPM.opmBuffer[src + 203]) + 32768F) >> 16;
  2533:             sndByteBlock[dst + 306] = (byte) t;
  2534:             sndByteBlock[dst + 307] = (byte) (t >> 8);
  2535:             t = (int) (13765.2906666667F * u + 43808.0853333333F * v + 7962.624F * (u = (float) OPM.opmBuffer[src + 205]) + 32768F) >> 16;
  2536:             sndByteBlock[dst + 310] = (byte) t;
  2537:             sndByteBlock[dst + 311] = (byte) (t >> 8);
  2538:             t = (int) (4816.896F * v + 41907.5413333333F * u + 18811.5626666667F * (v = (float) OPM.opmBuffer[src + 207]) + 32768F) >> 16;
  2539:             sndByteBlock[dst + 314] = (byte) t;
  2540:             sndByteBlock[dst + 315] = (byte) (t >> 8);
  2541:             t = (int) (461.482666666667F * u + 31520.0853333333F * v + 32855.3813333333F * (u = (float) OPM.opmBuffer[src + 209]) + 699.050666666667F * (v = (float) OPM.opmBuffer[src + 211]) + 32768F) >> 16;
  2542:             sndByteBlock[dst + 318] = (byte) t;
  2543:             sndByteBlock[dst + 319] = (byte) (t >> 8);
  2544:             t = (int) (17476.2666666667F * u + 42530.1333333333F * v + 5529.6F * (u = (float) OPM.opmBuffer[src + 213]) + 32768F) >> 16;
  2545:             sndByteBlock[dst + 322] = (byte) t;
  2546:             sndByteBlock[dst + 323] = (byte) (t >> 8);
  2547:             t = (int) (7102.464F * v + 43480.4053333333F * u + 14953.1306666667F * (v = (float) OPM.opmBuffer[src + 215]) + 32768F) >> 16;
  2548:             sndByteBlock[dst + 326] = (byte) t;
  2549:             sndByteBlock[dst + 327] = (byte) (t >> 8);
  2550:             t = (int) (1321.64266666667F * u + 35378.5173333333F * v + 28702.0373333333F * (u = (float) OPM.opmBuffer[src + 217]) + 133.802666666667F * (v = (float) OPM.opmBuffer[src + 219]) + 32768F) >> 16;
  2551:             sndByteBlock[dst + 330] = (byte) t;
  2552:             sndByteBlock[dst + 331] = (byte) (t >> 8);
  2553:             t = (int) (21629.6106666667F * u + 40367.4453333333F * v + 3538.944F * (u = (float) OPM.opmBuffer[src + 221]) + 32768F) >> 16;
  2554:             sndByteBlock[dst + 334] = (byte) t;
  2555:             sndByteBlock[dst + 335] = (byte) (t >> 8);
  2556:             t = (int) (9830.4F * v + 44168.5333333333F * u + 11537.0666666667F * (v = (float) OPM.opmBuffer[src + 223]) + 32768F) >> 16;
  2557:             sndByteBlock[dst + 338] = (byte) t;
  2558:             sndByteBlock[dst + 339] = (byte) (t >> 8);
  2559:             t = (int) (2624.17066666667F * u + 38783.6586666667F * v + 24128.1706666667F * (u = (float) OPM.opmBuffer[src + 225]) + 32768F) >> 16;
  2560:             sndByteBlock[dst + 342] = (byte) t;
  2561:             sndByteBlock[dst + 343] = (byte) (t >> 8);
  2562:             t = (int) (10.9226666666667F * v + 26203.4773333333F * u + 37330.944F * (v = (float) OPM.opmBuffer[src + 227]) + 1990.656F * (u = (float) OPM.opmBuffer[src + 229]) + 32768F) >> 16;
  2563:             sndByteBlock[dst + 346] = (byte) t;
  2564:             sndByteBlock[dst + 347] = (byte) (t >> 8);
  2565:             t = (int) (13000.704F * v + 43971.9253333333F * u + 8563.37066666667F * (v = (float) OPM.opmBuffer[src + 231]) + 32768F) >> 16;
  2566:             sndByteBlock[dst + 350] = (byte) t;
  2567:             sndByteBlock[dst + 351] = (byte) (t >> 8);
  2568:             t = (int) (4369.06666666667F * u + 41437.8666666667F * v + 19729.0666666667F * (u = (float) OPM.opmBuffer[src + 233]) + 32768F) >> 16;
  2569:             sndByteBlock[dst + 354] = (byte) t;
  2570:             sndByteBlock[dst + 355] = (byte) (t >> 8);
  2571:             t = (int) (330.410666666667F * v + 30602.5813333333F * u + 33718.272F * (v = (float) OPM.opmBuffer[src + 235]) + 884.736F * (u = (float) OPM.opmBuffer[src + 237]) + 32768F) >> 16;
  2572:             sndByteBlock[dst + 358] = (byte) t;
  2573:             sndByteBlock[dst + 359] = (byte) (t >> 8);
  2574:             t = (int) (16613.376F * v + 42890.5813333333F * u + 6032.04266666667F * (v = (float) OPM.opmBuffer[src + 239]) + 32768F) >> 16;
  2575:             sndByteBlock[dst + 362] = (byte) t;
  2576:             sndByteBlock[dst + 363] = (byte) (t >> 8);
  2577:             t = (int) (6556.33066666667F * u + 43207.3386666667F * v + 15772.3306666667F * (u = (float) OPM.opmBuffer[src + 241]) + 32768F) >> 16;
  2578:             sndByteBlock[dst + 366] = (byte) t;
  2579:             sndByteBlock[dst + 367] = (byte) (t >> 8);
  2580:             t = (int) (1092.26666666667F * v + 34559.3173333333F * u + 29663.232F * (v = (float) OPM.opmBuffer[src + 243]) + 221.184F * (u = (float) OPM.opmBuffer[src + 245]) + 32768F) >> 16;
  2581:             sndByteBlock[dst + 370] = (byte) t;
  2582:             sndByteBlock[dst + 371] = (byte) (t >> 8);
  2583:             t = (int) (20668.416F * v + 40924.5013333333F * u + 3943.08266666667F * (v = (float) OPM.opmBuffer[src + 247]) + 32768F) >> 16;
  2584:             sndByteBlock[dst + 374] = (byte) t;
  2585:             sndByteBlock[dst + 375] = (byte) (t >> 8);
  2586:             t = (int) (9185.96266666667F * u + 44092.0746666667F * v + 12257.9626666667F * (u = (float) OPM.opmBuffer[src + 249]) + 32768F) >> 16;
  2587:             sndByteBlock[dst + 378] = (byte) t;
  2588:             sndByteBlock[dst + 379] = (byte) (t >> 8);
  2589:             t = (int) (2296.49066666667F * v + 38073.6853333333F * u + 25165.824F * (float) OPM.opmBuffer[src + 251] + 32768F) >> 16;
  2590:             sndByteBlock[dst + 382] = (byte) t;
  2591:             sndByteBlock[dst + 383] = (byte) (t >> 8);
  2592:           }  //for src,dst
  2593:         }  //if long/float
  2594:       }  //convert(int)
  2595:     };  //SNDRateConverter.LINEAR_AREA_STEREO_48000
  2596: 
  2597:     //rateConverter.initialize ()
  2598:     //  初めて選択されたときに配列の初期化などの必要な処理があれば行う
  2599:     public void initialize () {
  2600:     }
  2601: 
  2602:     //rateConverter.convert ()
  2603:     //  1ブロック分変換する。ADAPTIVE以外はoutputSamplesを使わない
  2604:     public abstract void convert (int outputSamples);
  2605: 
  2606:   }  //enum SNDRateConverter
  2607: 
  2608: 
  2609: 
  2610: }  //class SoundSource
  2611: 
  2612: 
  2613: