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