devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA变声器_java 变声代码

作者：不正经 | 2024-04-03 08:32:05

赞

踩

java 变声代码

需求

最近接到一个需求，为了保护客户隐私，需要对客户的录音文件进行变声处理。于是搞了一个变声器的公共组件以便于大家使用。

工作原理

通过java代码改变音频的音调、速度、声音等来达成变声效果。

效果展示及代码可以参考：

链接：https://pan.baidu.com/s/1tHV4KHGXG4lD11rtB-2LkQ?pwd=jq98 

代码调用参考：
  1. package com.library.knowledge;
  2.  
  3. import com.library.knowledge.change_sound.SoundUtils;
  4.  
  5. /**
  6.  * @author ll
  7.  * @since 2023/7/20 14:27
  8.  */
  9. public class ChangeSound {
  10.     public static void main(String[] args) {
  11.         String filePath = "C:\\Users\\DELL\\Desktop\\history\\变声前.wav";
  12.         String newFilePath = "C:\\Users\\DELL\\Desktop\\history\\变声后.wav";
  13.         try {
  14.             SoundUtils.changeSound(filePath, newFilePath);
  15.         } catch (Exception e) {
  16.             throw new RuntimeException(e);
  17.         }
  18.     }
  19.
工具类主要的三个方法：
  1.  /**
  2.      * 变声方法-简化
  3.      *
  4.      * @param oldFilePath 旧文件路劲
  5.      * @param newFilePath 产生文件路径
  6.      */
  7.  
  8.     public static void changeSound(String oldFilePath, String newFilePath) ;
  9.  
  10.  
  11.     /**
  12.      * 变声方法-普通
  13.      * 返回 byte数组
  14.      * 默认变声方法，音调、速度、音量采用默认值
  15.      *
  16.      * @param stream 输入流
  17.      * @return byte数组
  18.      */
  19.     public static byte[] changeSound(AudioInputStream stream) throws Exception ;
  20.  
  21.   /**
  22.      * 自定义变声器-进阶
  23.      *
  24.      * @param stream 音频输入
  25.      * @param speed  速度
  26.      * @param pitch  音调
  27.      * @param volume 音量
  28.      * @return byte数组
  29.      */
  30.     public static byte[] changeSound(AudioInputStream stream, float speed, float pitch, float volume) throws Exception

具体代码如下：

maven：
  1.       <dependency>
  2.             <groupId>com.google.guava</groupId>
  3.             <artifactId>guava</artifactId>
  4.             <version>31.1-jre</version>
  5.         </dependency>
工具类：
  1. package com.library.knowledge.change_sound;
  2.  
  3. import com.google.common.io.ByteArrayDataOutput;
  4. import com.google.common.io.ByteStreams;
  5. import com.sun.media.sound.WaveFileWriter;
  6.  
  7. import javax.sound.sampled.*;
  8. import java.io.ByteArrayInputStream;
  9. import java.io.File;
  10. import java.io.OutputStream;
  11. import java.nio.file.Files;
  12.  
  13. /**
  14.  * @author ll
  15.  * @since 2023/7/20 14:53
  16.  */
  17. public class SoundUtils {
  18.     public static ByteArrayDataOutput out = ByteStreams.newDataOutput();
  19.  
  20.     /**
  21.      * 变声方法-简化
  22.      *
  23.      * @param oldFilePath 旧文件路劲
  24.      * @param newFilePath 产生文件路径
  25.      */
  26.  
  27.     public static void changeSound(String oldFilePath, String newFilePath) throws Exception {
  28.         OutputStream outStream = null;
  29.         try {
  30.             File input = new File(oldFilePath);
  31.             File output = new File(newFilePath);
  32.             outStream = Files.newOutputStream(output.toPath());
  33.             WaveFileWriter writer = new WaveFileWriter();
  34.             AudioFormat audioFormat = new AudioFormat(16000, 16, 1, true, false);
  35.             byte[] bytes = SoundUtils.changeSound(AudioSystem.getAudioInputStream(input));
  36.             ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
  37.             AudioInputStream in = new AudioInputStream(bi, audioFormat, bytes.length);
  38.             writer.write(in, AudioFileFormat.Type.WAVE, outStream);
  39.             outStream.close();
  40.         } finally {
  41.             if (outStream != null) {
  42.                 outStream.close();
  43.             }
  44.         }
  45.     }
  46.  
  47.     /**
  48.      * 变声方法-普通
  49.      * 返回 byte数组
  50.      * 默认变声方法，音调、速度、音量采用默认值
  51.      *
  52.      * @param stream 输入流
  53.      * @return byte数组
  54.      */
  55.     public static byte[] changeSound(AudioInputStream stream) throws Exception {
  56.         //速度
  57.         float speed = 1.0f;
  58.         //音调
  59.         float pitch = 1.4f;
  60.         //音量
  61.         float volume = 0.5f;
  62.         return changeSound(stream, speed, pitch, volume);
  63.     }
  64.  
  65.     /**
  66.      * 自定义变声器-进阶
  67.      *
  68.      * @param stream 音频输入
  69.      * @param speed  速度
  70.      * @param pitch  音调
  71.      * @param volume 音量
  72.      * @return byte数组
  73.      */
  74.     public static byte[] changeSound(AudioInputStream stream, float speed, float pitch, float volume) throws Exception {
  75.         float rate = 1.0f;
  76.         boolean emulateChordPitch = false;
  77.         int quality = 0;
  78.         AudioFormat format = stream.getFormat();
  79.         int sampleRate = (int) format.getSampleRate();
  80.         int numChannels = format.getChannels();
  81.         SourceDataLine.Info info = new DataLine.Info(SourceDataLine.class, format,
  82.                 ((int) stream.getFrameLength() * format.getFrameSize()));
  83.         SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info);
  84.         return runSonic(stream, line, speed, pitch, rate, volume, emulateChordPitch, quality,
  85.                 sampleRate, numChannels);
  86.     }
  87.  
  88.     // Run sonic.
  89.     private static byte[] runSonic(
  90.             AudioInputStream audioStream,
  91.             SourceDataLine line,
  92.             float speed,
  93.             float pitch,
  94.             float rate,
  95.             float volume,
  96.             boolean emulateChordPitch,
  97.             int quality,
  98.             int sampleRate,
  99.             int numChannels) throws Exception {
  100.  
  101.  
  102.         Sound sound = new Sound(sampleRate, numChannels);
  103.         int bufferSize = line.getBufferSize();
  104.         byte[] inBuffer = new byte[bufferSize];
  105.         byte[] outBuffer = new byte[bufferSize];
  106.         int numRead, numWritten;
  107.  
  108.         sound.setSpeed(speed);
  109.         sound.setPitch(pitch);
  110.         sound.setRate(rate);
  111.         sound.setVolume(volume);
  112.         sound.setChordPitch(emulateChordPitch);
  113.         sound.setQuality(quality);
  114.         do {
  115.             numRead = audioStream.read(inBuffer, 0, bufferSize);
  116.  
  117.             if (numRead <= 0) {
  118.                 sound.flushStream();
  119.             } else {
  120.                 sound.writeBytesToStream(inBuffer, numRead);
  121.             }
  122.             do {
  123.                 numWritten = sound.readBytesFromStream(outBuffer, bufferSize);
  124.                 if (numWritten > 0) {
  125.                     line.write(outBuffer, 0, numWritten);
  126.                     byte[] target = new byte[numWritten];
  127.                     System.arraycopy(outBuffer, 0, target, 0, numWritten);
  128.                     out.write(target);
  129.                 }
  130.             } while (numWritten > 0);
  131.         } while (numRead > 0);
  132.         return out.toByteArray();
  133.     }
  134.  
  135. }
实现类：
  1. package com.library.knowledge.change_sound;
  2.  
  3. /**
  4.  * @author ll
  5.  * @since 2023/7/20 14:43
  6.  */
  7. public class Sound {
  8.  
  9.     private static final int SONIC_MIN_PITCH = 65;
  10.     private static final int SONIC_MAX_PITCH = 400;
  11.     // This is used to down-sample some inputs to improve speed
  12.     private static final int SONIC_AMDF_FREQ = 4000;
  13.     // The number of points to use in the sinc FIR filter for resampling.
  14.     private static final int SINC_FILTER_POINTS = 12;
  15.     private static final int SINC_TABLE_SIZE = 601;
  16.  
  17.     // Lookup table for windowed sinc function of SINC_FILTER_POINTS points.
  18.     private static final short[] sincTable = {
  19.             0, 0, 0, 0, 0, 0, 0, -1, -1, -2, -2, -3, -4, -6, -7, -9, -10, -12, -14,
  20.             -17, -19, -21, -24, -26, -29, -32, -34, -37, -40, -42, -44, -47, -48, -50,
  21.             -51, -52, -53, -53, -53, -52, -50, -48, -46, -43, -39, -34, -29, -22, -16,
  22.             -8, 0, 9, 19, 29, 41, 53, 65, 79, 92, 107, 121, 137, 152, 168, 184, 200,
  23.             215, 231, 247, 262, 276, 291, 304, 317, 328, 339, 348, 357, 363, 369, 372,
  24.             374, 375, 373, 369, 363, 355, 345, 332, 318, 300, 281, 259, 234, 208, 178,
  25.             147, 113, 77, 39, 0, -41, -85, -130, -177, -225, -274, -324, -375, -426,
  26.             -478, -530, -581, -632, -682, -731, -779, -825, -870, -912, -951, -989,
  27.             -1023, -1053, -1080, -1104, -1123, -1138, -1149, -1154, -1155, -1151,
  28.             -1141, -1125, -1105, -1078, -1046, -1007, -963, -913, -857, -796, -728,
  29.             -655, -576, -492, -403, -309, -210, -107, 0, 111, 225, 342, 462, 584, 708,
  30.             833, 958, 1084, 1209, 1333, 1455, 1575, 1693, 1807, 1916, 2022, 2122, 2216,
  31.             2304, 2384, 2457, 2522, 2579, 2625, 2663, 2689, 2706, 2711, 2705, 2687,
  32.             2657, 2614, 2559, 2491, 2411, 2317, 2211, 2092, 1960, 1815, 1658, 1489,
  33.             1308, 1115, 912, 698, 474, 241, 0, -249, -506, -769, -1037, -1310, -1586,
  34.             -1864, -2144, -2424, -2703, -2980, -3254, -3523, -3787, -4043, -4291,
  35.             -4529, -4757, -4972, -5174, -5360, -5531, -5685, -5819, -5935, -6029,
  36.             -6101, -6150, -6175, -6175, -6149, -6096, -6015, -5905, -5767, -5599,
  37.             -5401, -5172, -4912, -4621, -4298, -3944, -3558, -3141, -2693, -2214,
  38.             -1705, -1166, -597, 0, 625, 1277, 1955, 2658, 3386, 4135, 4906, 5697, 6506,
  39.             7332, 8173, 9027, 9893, 10769, 11654, 12544, 13439, 14335, 15232, 16128,
  40.             17019, 17904, 18782, 19649, 20504, 21345, 22170, 22977, 23763, 24527,
  41.             25268, 25982, 26669, 27327, 27953, 28547, 29107, 29632, 30119, 30569,
  42.             30979, 31349, 31678, 31964, 32208, 32408, 32565, 32677, 32744, 32767,
  43.             32744, 32677, 32565, 32408, 32208, 31964, 31678, 31349, 30979, 30569,
  44.             30119, 29632, 29107, 28547, 27953, 27327, 26669, 25982, 25268, 24527,
  45.             23763, 22977, 22170, 21345, 20504, 19649, 18782, 17904, 17019, 16128,
  46.             15232, 14335, 13439, 12544, 11654, 10769, 9893, 9027, 8173, 7332, 6506,
  47.             5697, 4906, 4135, 3386, 2658, 1955, 1277, 625, 0, -597, -1166, -1705,
  48.             -2214, -2693, -3141, -3558, -3944, -4298, -4621, -4912, -5172, -5401,
  49.             -5599, -5767, -5905, -6015, -6096, -6149, -6175, -6175, -6150, -6101,
  50.             -6029, -5935, -5819, -5685, -5531, -5360, -5174, -4972, -4757, -4529,
  51.             -4291, -4043, -3787, -3523, -3254, -2980, -2703, -2424, -2144, -1864,
  52.             -1586, -1310, -1037, -769, -506, -249, 0, 241, 474, 698, 912, 1115, 1308,
  53.             1489, 1658, 1815, 1960, 2092, 2211, 2317, 2411, 2491, 2559, 2614, 2657,
  54.             2687, 2705, 2711, 2706, 2689, 2663, 2625, 2579, 2522, 2457, 2384, 2304,
  55.             2216, 2122, 2022, 1916, 1807, 1693, 1575, 1455, 1333, 1209, 1084, 958, 833,
  56.             708, 584, 462, 342, 225, 111, 0, -107, -210, -309, -403, -492, -576, -655,
  57.             -728, -796, -857, -913, -963, -1007, -1046, -1078, -1105, -1125, -1141,
  58.             -1151, -1155, -1154, -1149, -1138, -1123, -1104, -1080, -1053, -1023, -989,
  59.             -951, -912, -870, -825, -779, -731, -682, -632, -581, -530, -478, -426,
  60.             -375, -324, -274, -225, -177, -130, -85, -41, 0, 39, 77, 113, 147, 178,
  61.             208, 234, 259, 281, 300, 318, 332, 345, 355, 363, 369, 373, 375, 374, 372,
  62.             369, 363, 357, 348, 339, 328, 317, 304, 291, 276, 262, 247, 231, 215, 200,
  63.             184, 168, 152, 137, 121, 107, 92, 79, 65, 53, 41, 29, 19, 9, 0, -8, -16,
  64.             -22, -29, -34, -39, -43, -46, -48, -50, -52, -53, -53, -53, -52, -51, -50,
  65.             -48, -47, -44, -42, -40, -37, -34, -32, -29, -26, -24, -21, -19, -17, -14,
  66.             -12, -10, -9, -7, -6, -4, -3, -2, -2, -1, -1, 0, 0, 0, 0, 0, 0, 0
  67.     };
  68.  
  69.     private short[] inputBuffer;
  70.     private short[] outputBuffer;
  71.     private short[] pitchBuffer;
  72.     private short[] downSampleBuffer;
  73.     private float speed;
  74.     private float volume;
  75.     private float pitch;
  76.     private float rate;
  77.     private int oldRatePosition;
  78.     private int newRatePosition;
  79.     private boolean useChordPitch;
  80.     private int quality;
  81.     private int numChannels;
  82.     private int inputBufferSize;
  83.     private int pitchBufferSize;
  84.     private int outputBufferSize;
  85.     private int numInputSamples;
  86.     private int numOutputSamples;
  87.     private int numPitchSamples;
  88.     private int minPeriod;
  89.     private int maxPeriod;
  90.     private int maxRequired;
  91.     private int remainingInputToCopy;
  92.     private int sampleRate;
  93.     private int prevPeriod;
  94.     private int prevMinDiff;
  95.     private int minDiff;
  96.     private int maxDiff;
  97.  
  98.     // Create a sonic stream.
  99.     public Sound(
  100.             int sampleRate,
  101.             int numChannels) {
  102.         allocateStreamBuffers(sampleRate, numChannels);
  103.         speed = 1.0f;
  104.         pitch = 1.0f;
  105.         volume = 1.0f;
  106.         rate = 1.0f;
  107.         oldRatePosition = 0;
  108.         newRatePosition = 0;
  109.         useChordPitch = false;
  110.         quality = 0;
  111.     }
  112.  
  113.     // This is a non-stream oriented interface to just change the speed of a sound sample
  114.     public static int changeFloatSpeed(
  115.             float[] samples,
  116.             int numSamples,
  117.             float speed,
  118.             float pitch,
  119.             float rate,
  120.             float volume,
  121.             boolean useChordPitch,
  122.             int sampleRate,
  123.             int numChannels) {
  124.         Sound stream = new Sound(sampleRate, numChannels);
  125.  
  126.         stream.setSpeed(speed);
  127.         stream.setPitch(pitch);
  128.         stream.setRate(rate);
  129.         stream.setVolume(volume);
  130.         stream.setChordPitch(useChordPitch);
  131.         stream.writeFloatToStream(samples, numSamples);
  132.         stream.flushStream();
  133.         numSamples = stream.samplesAvailable();
  134.         stream.readFloatFromStream(samples, numSamples);
  135.         return numSamples;
  136.     }
  137.  
  138.     // Resize the array.
  139.     private short[] resize(
  140.             short[] oldArray,
  141.             int newLength) {
  142.         newLength *= numChannels;
  143.         short[] newArray = new short[newLength];
  144.         int length = oldArray.length <= newLength ? oldArray.length : newLength;
  145.  
  146.         System.arraycopy(oldArray, 0, newArray, 0, length);
  147.         return newArray;
  148.     }
  149.  
  150.     // Move samples from one array to another.  May move samples down within an array, but not up.
  151.     private void move(
  152.             short[] dest,
  153.             int destPos,
  154.             short[] source,
  155.             int sourcePos,
  156.             int numSamples) {
  157.         System.arraycopy(source, sourcePos * numChannels, dest, destPos * numChannels, numSamples * numChannels);
  158.     }
  159.  
  160.     // Scale the samples by the factor.
  161.     private void scaleSamples(
  162.             short[] samples,
  163.             int position,
  164.             int numSamples,
  165.             float volume) {
  166.         int fixedPointVolume = (int) (volume * 4096.0f);
  167.         int start = position * numChannels;
  168.         int stop = start + numSamples * numChannels;
  169.  
  170.         for (int xSample = start; xSample < stop; xSample++) {
  171.             int value = (samples[xSample] * fixedPointVolume) >> 12;
  172.             if (value > 32767) {
  173.                 value = 32767;
  174.             } else if (value < -32767) {
  175.                 value = -32767;
  176.             }
  177.             samples[xSample] = (short) value;
  178.         }
  179.     }
  180.  
  181.     // Get the speed of the stream.
  182.     public float getSpeed() {
  183.         return speed;
  184.     }
  185.  
  186.     // Set the speed of the stream.
  187.     public void setSpeed(
  188.             float speed) {
  189.         this.speed = speed;
  190.     }
  191.  
  192.     // Get the pitch of the stream.
  193.     public float getPitch() {
  194.         return pitch;
  195.     }
  196.  
  197.     // Set the pitch of the stream.
  198.     public void setPitch(
  199.             float pitch) {
  200.         this.pitch = pitch;
  201.     }
  202.  
  203.     // Get the rate of the stream.
  204.     public float getRate() {
  205.         return rate;
  206.     }
  207.  
  208.     // Set the playback rate of the stream. This scales pitch and speed at the same time.
  209.     public void setRate(
  210.             float rate) {
  211.         this.rate = rate;
  212.         this.oldRatePosition = 0;
  213.         this.newRatePosition = 0;
  214.     }
  215.  
  216.     // Get the vocal chord pitch setting.
  217.     public boolean getChordPitch() {
  218.         return useChordPitch;
  219.     }
  220.  
  221.     // Set the vocal chord mode for pitch computation.  Default is off.
  222.     public void setChordPitch(
  223.             boolean useChordPitch) {
  224.         this.useChordPitch = useChordPitch;
  225.     }
  226.  
  227.     // Get the quality setting.
  228.     public int getQuality() {
  229.         return quality;
  230.     }
  231.  
  232.     // Set the "quality".  Default 0 is virtually as good as 1, but very much faster.
  233.     public void setQuality(
  234.             int quality) {
  235.         this.quality = quality;
  236.     }
  237.  
  238.     // Get the scaling factor of the stream.
  239.     public float getVolume() {
  240.         return volume;
  241.     }
  242.  
  243.     // Set the scaling factor of the stream.
  244.     public void setVolume(
  245.             float volume) {
  246.         this.volume = volume;
  247.     }
  248.  
  249.     // Allocate stream buffers.
  250.     private void allocateStreamBuffers(
  251.             int sampleRate,
  252.             int numChannels) {
  253.         minPeriod = sampleRate / SONIC_MAX_PITCH;
  254.         maxPeriod = sampleRate / SONIC_MIN_PITCH;
  255.         maxRequired = 2 * maxPeriod;
  256.         inputBufferSize = maxRequired;
  257.         inputBuffer = new short[maxRequired * numChannels];
  258.         outputBufferSize = maxRequired;
  259.         outputBuffer = new short[maxRequired * numChannels];
  260.         pitchBufferSize = maxRequired;
  261.         pitchBuffer = new short[maxRequired * numChannels];
  262.         downSampleBuffer = new short[maxRequired];
  263.         this.sampleRate = sampleRate;
  264.         this.numChannels = numChannels;
  265.         oldRatePosition = 0;
  266.         newRatePosition = 0;
  267.         prevPeriod = 0;
  268.     }
  269.  
  270.     // Get the sample rate of the stream.
  271.     public int getSampleRate() {
  272.         return sampleRate;
  273.     }
  274.  
  275.     // Set the sample rate of the stream.  This will cause samples buffered in the stream to be lost.
  276.     public void setSampleRate(
  277.             int sampleRate) {
  278.         allocateStreamBuffers(sampleRate, numChannels);
  279.     }
  280.  
  281.     // Get the number of channels.
  282.     public int getNumChannels() {
  283.         return numChannels;
  284.     }
  285.  
  286.     // Set the num channels of the stream.  This will cause samples buffered in the stream to be lost.
  287.     public void setNumChannels(
  288.             int numChannels) {
  289.         allocateStreamBuffers(sampleRate, numChannels);
  290.     }
  291.  
  292.     // Enlarge the output buffer if needed.
  293.     private void enlargeOutputBufferIfNeeded(
  294.             int numSamples) {
  295.         if (numOutputSamples + numSamples > outputBufferSize) {
  296.             outputBufferSize += (outputBufferSize >> 1) + numSamples;
  297.             outputBuffer = resize(outputBuffer, outputBufferSize);
  298.         }
  299.     }
  300.  
  301.     // Enlarge the input buffer if needed.
  302.     private void enlargeInputBufferIfNeeded(
  303.             int numSamples) {
  304.         if (numInputSamples + numSamples > inputBufferSize) {
  305.             inputBufferSize += (inputBufferSize >> 1) + numSamples;
  306.             inputBuffer = resize(inputBuffer, inputBufferSize);
  307.         }
  308.     }
  309.  
  310.     // Add the input samples to the input buffer.
  311.     private void addFloatSamplesToInputBuffer(
  312.             float[] samples,
  313.             int numSamples) {
  314.         if (numSamples == 0) {
  315.             return;
  316.         }
  317.         enlargeInputBufferIfNeeded(numSamples);
  318.         int xBuffer = numInputSamples * numChannels;
  319.         for (int xSample = 0; xSample < numSamples * numChannels; xSample++) {
  320.             inputBuffer[xBuffer++] = (short) (samples[xSample] * 32767.0f);
  321.         }
  322.         numInputSamples += numSamples;
  323.     }
  324.  
  325.     // Add the input samples to the input buffer.
  326.     private void addShortSamplesToInputBuffer(
  327.             short[] samples,
  328.             int numSamples) {
  329.         if (numSamples == 0) {
  330.             return;
  331.         }
  332.         enlargeInputBufferIfNeeded(numSamples);
  333.         move(inputBuffer, numInputSamples, samples, 0, numSamples);
  334.         numInputSamples += numSamples;
  335.     }
  336.  
  337.     // Add the input samples to the input buffer.
  338.     private void addUnsignedByteSamplesToInputBuffer(
  339.             byte[] samples,
  340.             int numSamples) {
  341.         short sample;
  342.  
  343.         enlargeInputBufferIfNeeded(numSamples);
  344.         int xBuffer = numInputSamples * numChannels;
  345.         for (int xSample = 0; xSample < numSamples * numChannels; xSample++) {
  346.             sample = (short) ((samples[xSample] & 0xff) - 128); // Convert from unsigned to signed
  347.             inputBuffer[xBuffer++] = (short) (sample << 8);
  348.         }
  349.         numInputSamples += numSamples;
  350.     }
  351.  
  352.     // Add the input samples to the input buffer.  They must be 16-bit little-endian encoded in a byte array.
  353.     private void addBytesToInputBuffer(
  354.             byte[] inBuffer,
  355.             int numBytes) {
  356.         int numSamples = numBytes / (2 * numChannels);
  357.         short sample;
  358.  
  359.         enlargeInputBufferIfNeeded(numSamples);
  360.         int xBuffer = numInputSamples * numChannels;
  361.         for (int xByte = 0; xByte + 1 < numBytes; xByte += 2) {
  362.             sample = (short) ((inBuffer[xByte] & 0xff) | (inBuffer[xByte + 1] << 8));
  363.             inputBuffer[xBuffer++] = sample;
  364.         }
  365.         numInputSamples += numSamples;
  366.     }
  367.  
  368.     // Remove input samples that we have already processed.
  369.     private void removeInputSamples(
  370.             int position) {
  371.         int remainingSamples = numInputSamples - position;
  372.  
  373.         move(inputBuffer, 0, inputBuffer, position, remainingSamples);
  374.         numInputSamples = remainingSamples;
  375.     }
  376.  
  377.     // Just copy from the array to the output buffer
  378.     private void copyToOutput(
  379.             short[] samples,
  380.             int position,
  381.             int numSamples) {
  382.         enlargeOutputBufferIfNeeded(numSamples);
  383.         move(outputBuffer, numOutputSamples, samples, position, numSamples);
  384.         numOutputSamples += numSamples;
  385.     }
  386.  
  387.     // Just copy from the input buffer to the output buffer.  Return num samples copied.
  388.     private int copyInputToOutput(
  389.             int position) {
  390.         int numSamples = remainingInputToCopy;
  391.  
  392.         if (numSamples > maxRequired) {
  393.             numSamples = maxRequired;
  394.         }
  395.         copyToOutput(inputBuffer, position, numSamples);
  396.         remainingInputToCopy -= numSamples;
  397.         return numSamples;
  398.     }
  399.  
  400.     // Read data out of the stream.  Sometimes no data will be available, and zero
  401.     // is returned, which is not an error condition.
  402.     public int readFloatFromStream(
  403.             float[] samples,
  404.             int maxSamples) {
  405.         int numSamples = numOutputSamples;
  406.         int remainingSamples = 0;
  407.  
  408.         if (numSamples == 0) {
  409.             return 0;
  410.         }
  411.         if (numSamples > maxSamples) {
  412.             remainingSamples = numSamples - maxSamples;
  413.             numSamples = maxSamples;
  414.         }
  415.         for (int xSample = 0; xSample < numSamples * numChannels; xSample++) {
  416.             samples[xSample] = (outputBuffer[xSample]) / 32767.0f;
  417.         }
  418.         move(outputBuffer, 0, outputBuffer, numSamples, remainingSamples);
  419.         numOutputSamples = remainingSamples;
  420.         return numSamples;
  421.     }
  422.  
  423.     // Read short data out of the stream.  Sometimes no data will be available, and zero
  424.     // is returned, which is not an error condition.
  425.     public int readShortFromStream(
  426.             short[] samples,
  427.             int maxSamples) {
  428.         int numSamples = numOutputSamples;
  429.         int remainingSamples = 0;
  430.  
  431.         if (numSamples == 0) {
  432.             return 0;
  433.         }
  434.         if (numSamples > maxSamples) {
  435.             remainingSamples = numSamples - maxSamples;
  436.             numSamples = maxSamples;
  437.         }
  438.         move(samples, 0, outputBuffer, 0, numSamples);
  439.         move(outputBuffer, 0, outputBuffer, numSamples, remainingSamples);
  440.         numOutputSamples = remainingSamples;
  441.         return numSamples;
  442.     }
  443.  
  444.     // Read unsigned byte data out of the stream.  Sometimes no data will be available, and zero
  445.     // is returned, which is not an error condition.
  446.     public int readUnsignedByteFromStream(
  447.             byte[] samples,
  448.             int maxSamples) {
  449.         int numSamples = numOutputSamples;
  450.         int remainingSamples = 0;
  451.  
  452.         if (numSamples == 0) {
  453.             return 0;
  454.         }
  455.         if (numSamples > maxSamples) {
  456.             remainingSamples = numSamples - maxSamples;
  457.             numSamples = maxSamples;
  458.         }
  459.         for (int xSample = 0; xSample < numSamples * numChannels; xSample++) {
  460.             samples[xSample] = (byte) ((outputBuffer[xSample] >> 8) + 128);
  461.         }
  462.         move(outputBuffer, 0, outputBuffer, numSamples, remainingSamples);
  463.         numOutputSamples = remainingSamples;
  464.         return numSamples;
  465.     }
  466.  
  467.     // Read unsigned byte data out of the stream.  Sometimes no data will be available, and zero
  468.     // is returned, which is not an error condition.
  469.     public int readBytesFromStream(
  470.             byte[] outBuffer,
  471.             int maxBytes) {
  472.         int maxSamples = maxBytes / (2 * numChannels);
  473.         int numSamples = numOutputSamples;
  474.         int remainingSamples = 0;
  475.  
  476.         if (numSamples == 0 || maxSamples == 0) {
  477.             return 0;
  478.         }
  479.         if (numSamples > maxSamples) {
  480.             remainingSamples = numSamples - maxSamples;
  481.             numSamples = maxSamples;
  482.         }
  483.         for (int xSample = 0; xSample < numSamples * numChannels; xSample++) {
  484.             short sample = outputBuffer[xSample];
  485.             outBuffer[xSample << 1] = (byte) (sample & 0xff);
  486.             outBuffer[(xSample << 1) + 1] = (byte) (sample >> 8);
  487.         }
  488.         move(outputBuffer, 0, outputBuffer, numSamples, remainingSamples);
  489.         numOutputSamples = remainingSamples;
  490.         return 2 * numSamples * numChannels;
  491.     }
  492.  
  493.     // Force the sonic stream to generate output using whatever data it currently
  494.     // has.  No extra delay will be added to the output, but flushing in the middle of
  495.     // words could introduce distortion.
  496.     public void flushStream() {
  497.         int remainingSamples = numInputSamples;
  498.         float s = speed / pitch;
  499.         float r = rate * pitch;
  500.         int expectedOutputSamples = numOutputSamples + (int) ((remainingSamples / s + numPitchSamples) / r + 0.5f);
  501.  
  502.         // Add enough silence to flush both input and pitch buffers.
  503.         enlargeInputBufferIfNeeded(remainingSamples + 2 * maxRequired);
  504.         for (int xSample = 0; xSample < 2 * maxRequired * numChannels; xSample++) {
  505.             inputBuffer[remainingSamples * numChannels + xSample] = 0;
  506.         }
  507.         numInputSamples += 2 * maxRequired;
  508.         writeShortToStream(null, 0);
  509.         // Throw away any extra samples we generated due to the silence we added.
  510.         if (numOutputSamples > expectedOutputSamples) {
  511.             numOutputSamples = expectedOutputSamples;
  512.         }
  513.         // Empty input and pitch buffers.
  514.         numInputSamples = 0;
  515.         remainingInputToCopy = 0;
  516.         numPitchSamples = 0;
  517.     }
  518.  
  519.     // Return the number of samples in the output buffer
  520.     public int samplesAvailable() {
  521.         return numOutputSamples;
  522.     }
  523.  
  524.     // If skip is greater than one, average skip samples together and write them to
  525.     // the down-sample buffer.  If numChannels is greater than one, mix the channels
  526.     // together as we down sample.
  527.     private void downSampleInput(
  528.             short[] samples,
  529.             int position,
  530.             int skip) {
  531.         int numSamples = maxRequired / skip;
  532.         int samplesPerValue = numChannels * skip;
  533.         int value;
  534.  
  535.         position *= numChannels;
  536.         for (int i = 0; i < numSamples; i++) {
  537.             value = 0;
  538.             for (int j = 0; j < samplesPerValue; j++) {
  539.                 value += samples[position + i * samplesPerValue + j];
  540.             }
  541.             value /= samplesPerValue;
  542.             downSampleBuffer[i] = (short) value;
  543.         }
  544.     }
  545.  
  546.     // Find the best frequency match in the range, and given a sample skip multiple.
  547.     // For now, just find the pitch of the first channel.
  548.     private int findPitchPeriodInRange(
  549.             short[] samples,
  550.             int position,
  551.             int minPeriod,
  552.             int maxPeriod) {
  553.         int bestPeriod = 0, worstPeriod = 255;
  554.         int minDiff = 1, maxDiff = 0;
  555.  
  556.         position *= numChannels;
  557.         for (int period = minPeriod; period <= maxPeriod; period++) {
  558.             int diff = 0;
  559.             for (int i = 0; i < period; i++) {
  560.                 short sVal = samples[position + i];
  561.                 short pVal = samples[position + period + i];
  562.                 diff += sVal >= pVal ? sVal - pVal : pVal - sVal;
  563.             }
  564.             /* Note that the highest number of samples we add into diff will be less
  565.                than 256, since we skip samples.  Thus, diff is a 24 bit number, and
  566.                we can safely multiply by numSamples without overflow */
  567.             if (diff * bestPeriod < minDiff * period) {
  568.                 minDiff = diff;
  569.                 bestPeriod = period;
  570.             }
  571.             if (diff * worstPeriod > maxDiff * period) {
  572.                 maxDiff = diff;
  573.                 worstPeriod = period;
  574.             }
  575.         }
  576.         this.minDiff = minDiff / bestPeriod;
  577.         this.maxDiff = maxDiff / worstPeriod;
  578.  
  579.         return bestPeriod;
  580.     }
  581.  
  582.     // At abrupt ends of voiced words, we can have pitch periods that are better
  583.     // approximated by the previous pitch period estimate.  Try to detect this case.
  584.     private boolean prevPeriodBetter(
  585.             int minDiff,
  586.             int maxDiff,
  587.             boolean preferNewPeriod) {
  588.         if (minDiff == 0 || prevPeriod == 0) {
  589.             return false;
  590.         }
  591.         if (preferNewPeriod) {
  592.             if (maxDiff > minDiff * 3) {
  593.                 // Got a reasonable match this period
  594.                 return false;
  595.             }
  596.             // Mismatch is not that much greater this period
  597.             return minDiff * 2 > prevMinDiff * 3;
  598.         } else {
  599.             return minDiff > prevMinDiff;
  600.         }
  601.     }
  602.  
  603.     // Find the pitch period.  This is a critical step, and we may have to try
  604.     // multiple ways to get a good answer.  This version uses AMDF.  To improve
  605.     // speed, we down sample by an integer factor get in the 11KHz range, and then
  606.     // do it again with a narrower frequency range without down sampling
  607.     private int findPitchPeriod(
  608.             short[] samples,
  609.             int position,
  610.             boolean preferNewPeriod) {
  611.         int period, retPeriod;
  612.         int skip = 1;
  613.  
  614.         if (sampleRate > SONIC_AMDF_FREQ && quality == 0) {
  615.             skip = sampleRate / SONIC_AMDF_FREQ;
  616.         }
  617.         if (numChannels == 1 && skip == 1) {
  618.             period = findPitchPeriodInRange(samples, position, minPeriod, maxPeriod);
  619.         } else {
  620.             downSampleInput(samples, position, skip);
  621.             period = findPitchPeriodInRange(downSampleBuffer, 0, minPeriod / skip,
  622.                     maxPeriod / skip);
  623.             if (skip != 1) {
  624.                 period *= skip;
  625.                 int minP = period - (skip << 2);
  626.                 int maxP = period + (skip << 2);
  627.                 if (minP < minPeriod) {
  628.                     minP = minPeriod;
  629.                 }
  630.                 if (maxP > maxPeriod) {
  631.                     maxP = maxPeriod;
  632.                 }
  633.                 if (numChannels == 1) {
  634.                     period = findPitchPeriodInRange(samples, position, minP, maxP);
  635.                 } else {
  636.                     downSampleInput(samples, position, 1);
  637.                     period = findPitchPeriodInRange(downSampleBuffer, 0, minP, maxP);
  638.                 }
  639.             }
  640.         }
  641.         if (prevPeriodBetter(minDiff, maxDiff, preferNewPeriod)) {
  642.             retPeriod = prevPeriod;
  643.         } else {
  644.             retPeriod = period;
  645.         }
  646.         prevMinDiff = minDiff;
  647.         prevPeriod = period;
  648.         return retPeriod;
  649.     }
  650.  
  651.     // Overlap two sound segments, ramp the volume of one down, while ramping the
  652.     // other one from zero up, and add them, storing the result at the output.
  653.     private void overlapAdd(
  654.             int numSamples,
  655.             int numChannels,
  656.             short[] out,
  657.             int outPos,
  658.             short[] rampDown,
  659.             int rampDownPos,
  660.             short[] rampUp,
  661.             int rampUpPos) {
  662.         for (int i = 0; i < numChannels; i++) {
  663.             int o = outPos * numChannels + i;
  664.             int u = rampUpPos * numChannels + i;
  665.             int d = rampDownPos * numChannels + i;
  666.             for (int t = 0; t < numSamples; t++) {
  667.                 out[o] = (short) ((rampDown[d] * (numSamples - t) + rampUp[u] * t) / numSamples);
  668.                 o += numChannels;
  669.                 d += numChannels;
  670.                 u += numChannels;
  671.             }
  672.         }
  673.     }
  674.  
  675.     // Overlap two sound segments, ramp the volume of one down, while ramping the
  676.     // other one from zero up, and add them, storing the result at the output.
  677.     private void overlapAddWithSeparation(
  678.             int numSamples,
  679.             int numChannels,
  680.             int separation,
  681.             short[] out,
  682.             int outPos,
  683.             short[] rampDown,
  684.             int rampDownPos,
  685.             short[] rampUp,
  686.             int rampUpPos) {
  687.         for (int i = 0; i < numChannels; i++) {
  688.             int o = outPos * numChannels + i;
  689.             int u = rampUpPos * numChannels + i;
  690.             int d = rampDownPos * numChannels + i;
  691.             for (int t = 0; t < numSamples + separation; t++) {
  692.                 if (t < separation) {
  693.                     out[o] = (short) (rampDown[d] * (numSamples - t) / numSamples);
  694.                     d += numChannels;
  695.                 } else if (t < numSamples) {
  696.                     out[o] = (short) ((rampDown[d] * (numSamples - t) + rampUp[u] * (t - separation)) / numSamples);
  697.                     d += numChannels;
  698.                     u += numChannels;
  699.                 } else {
  700.                     out[o] = (short) (rampUp[u] * (t - separation) / numSamples);
  701.                     u += numChannels;
  702.                 }
  703.                 o += numChannels;
  704.             }
  705.         }
  706.     }
  707.  
  708.     // Just move the new samples in the output buffer to the pitch buffer
  709.     private void moveNewSamplesToPitchBuffer(
  710.             int originalNumOutputSamples) {
  711.         int numSamples = numOutputSamples - originalNumOutputSamples;
  712.  
  713.         if (numPitchSamples + numSamples > pitchBufferSize) {
  714.             pitchBufferSize += (pitchBufferSize >> 1) + numSamples;
  715.             pitchBuffer = resize(pitchBuffer, pitchBufferSize);
  716.         }
  717.         move(pitchBuffer, numPitchSamples, outputBuffer, originalNumOutputSamples, numSamples);
  718.         numOutputSamples = originalNumOutputSamples;
  719.         numPitchSamples += numSamples;
  720.     }
  721.  
  722.     // Remove processed samples from the pitch buffer.
  723.     private void removePitchSamples(
  724.             int numSamples) {
  725.         if (numSamples == 0) {
  726.             return;
  727.         }
  728.         move(pitchBuffer, 0, pitchBuffer, numSamples, numPitchSamples - numSamples);
  729.         numPitchSamples -= numSamples;
  730.     }
  731.  
  732.     // Change the pitch.  The latency this introduces could be reduced by looking at
  733.     // past samples to determine pitch, rather than future.
  734.     private void adjustPitch(
  735.             int originalNumOutputSamples) {
  736.         int period, newPeriod, separation;
  737.         int position = 0;
  738.  
  739.         if (numOutputSamples == originalNumOutputSamples) {
  740.             return;
  741.         }
  742.         moveNewSamplesToPitchBuffer(originalNumOutputSamples);
  743.         while (numPitchSamples - position >= maxRequired) {
  744.             period = findPitchPeriod(pitchBuffer, position, false);
  745.             newPeriod = (int) (period / pitch);
  746.             enlargeOutputBufferIfNeeded(newPeriod);
  747.             if (pitch >= 1.0f) {
  748.                 overlapAdd(newPeriod, numChannels, outputBuffer, numOutputSamples, pitchBuffer,
  749.                         position, pitchBuffer, position + period - newPeriod);
  750.             } else {
  751.                 separation = newPeriod - period;
  752.                 overlapAddWithSeparation(period, numChannels, separation, outputBuffer, numOutputSamples,
  753.                         pitchBuffer, position, pitchBuffer, position);
  754.             }
  755.             numOutputSamples += newPeriod;
  756.             position += period;
  757.         }
  758.         removePitchSamples(position);
  759.     }
  760.  
  761.     // Aproximate the sinc function times a Hann window from the sinc table.
  762.     private int findSincCoefficient(int i, int ratio, int width) {
  763.         int lobePoints = (SINC_TABLE_SIZE - 1) / SINC_FILTER_POINTS;
  764.         int left = i * lobePoints + (ratio * lobePoints) / width;
  765.         int right = left + 1;
  766.         int position = i * lobePoints * width + ratio * lobePoints - left * width;
  767.         int leftVal = sincTable[left];
  768.         int rightVal = sincTable[right];
  769.  
  770.         return ((leftVal * (width - position) + rightVal * position) << 1) / width;
  771.     }
  772.  
  773.     // Return 1 if value >= 0, else -1.  This represents the sign of value.
  774.     private int getSign(int value) {
  775.         return value >= 0 ? 1 : -1;
  776.     }
  777.  
  778.     // Interpolate the new output sample.
  779.     private short interpolate(
  780.             short[] in,
  781.             int inPos,  // Index to first sample which already includes channel offset.
  782.             int oldSampleRate,
  783.             int newSampleRate) {
  784.         // Compute N-point sinc FIR-filter here.  Clip rather than overflow.
  785.         int i;
  786.         int total = 0;
  787.         int position = newRatePosition * oldSampleRate;
  788.         int leftPosition = oldRatePosition * newSampleRate;
  789.         int rightPosition = (oldRatePosition + 1) * newSampleRate;
  790.         int ratio = rightPosition - position - 1;
  791.         int width = rightPosition - leftPosition;
  792.         int weight, value;
  793.         int oldSign;
  794.         int overflowCount = 0;
  795.  
  796.         for (i = 0; i < SINC_FILTER_POINTS; i++) {
  797.             weight = findSincCoefficient(i, ratio, width);
  798.             /* printf("%u %f\n", i, weight); */
  799.             value = in[inPos + i * numChannels] * weight;
  800.             oldSign = getSign(total);
  801.             total += value;
  802.             if (oldSign != getSign(total) && getSign(value) == oldSign) {
  803.                 /* We must have overflowed.  This can happen with a sinc filter. */
  804.                 overflowCount += oldSign;
  805.             }
  806.         }
  807.         /* It is better to clip than to wrap if there was a overflow. */
  808.         if (overflowCount > 0) {
  809.             return Short.MAX_VALUE;
  810.         } else if (overflowCount < 0) {
  811.             return Short.MIN_VALUE;
  812.         }
  813.         return (short) (total >> 16);
  814.     }
  815.  
  816.     // Change the rate.
  817.     private void adjustRate(
  818.             float rate,
  819.             int originalNumOutputSamples) {
  820.         int newSampleRate = (int) (sampleRate / rate);
  821.         int oldSampleRate = sampleRate;
  822.         int position;
  823.  
  824.         // Set these values to help with the integer math
  825.         while (newSampleRate > (1 << 14) || oldSampleRate > (1 << 14)) {
  826.             newSampleRate >>= 1;
  827.             oldSampleRate >>= 1;
  828.         }
  829.         if (numOutputSamples == originalNumOutputSamples) {
  830.             return;
  831.         }
  832.         moveNewSamplesToPitchBuffer(originalNumOutputSamples);
  833.         // Leave at least one pitch sample in the buffer
  834.         for (position = 0; position < numPitchSamples - 1; position++) {
  835.             while ((oldRatePosition + 1) * newSampleRate > newRatePosition * oldSampleRate) {
  836.                 enlargeOutputBufferIfNeeded(1);
  837.                 for (int i = 0; i < numChannels; i++) {
  838.                     outputBuffer[numOutputSamples * numChannels + i] = interpolate(pitchBuffer,
  839.                             position * numChannels + i, oldSampleRate, newSampleRate);
  840.                 }
  841.                 newRatePosition++;
  842.                 numOutputSamples++;
  843.             }
  844.             oldRatePosition++;
  845.             if (oldRatePosition == oldSampleRate) {
  846.                 oldRatePosition = 0;
  847.                 if (newRatePosition != newSampleRate) {
  848.                     System.out.print("Assertion failed: newRatePosition != newSampleRate\n");
  849.                     assert false;
  850.                 }
  851.                 newRatePosition = 0;
  852.             }
  853.         }
  854.         removePitchSamples(position);
  855.     }
  856.  
  857.     // Skip over a pitch period, and copy period/speed samples to the output
  858.     private int skipPitchPeriod(
  859.             short[] samples,
  860.             int position,
  861.             float speed,
  862.             int period) {
  863.         int newSamples;
  864.  
  865.         if (speed >= 2.0f) {
  866.             newSamples = (int) (period / (speed - 1.0f));
  867.         } else {
  868.             newSamples = period;
  869.             remainingInputToCopy = (int) (period * (2.0f - speed) / (speed - 1.0f));
  870.         }
  871.         enlargeOutputBufferIfNeeded(newSamples);
  872.         overlapAdd(newSamples, numChannels, outputBuffer, numOutputSamples, samples, position,
  873.                 samples, position + period);
  874.         numOutputSamples += newSamples;
  875.         return newSamples;
  876.     }
  877.  
  878.     // Insert a pitch period, and determine how much input to copy directly.
  879.     private int insertPitchPeriod(
  880.             short[] samples,
  881.             int position,
  882.             float speed,
  883.             int period) {
  884.         int newSamples;
  885.  
  886.         if (speed < 0.5f) {
  887.             newSamples = (int) (period * speed / (1.0f - speed));
  888.         } else {
  889.             newSamples = period;
  890.             remainingInputToCopy = (int) (period * (2.0f * speed - 1.0f) / (1.0f - speed));
  891.         }
  892.         enlargeOutputBufferIfNeeded(period + newSamples);
  893.         move(outputBuffer, numOutputSamples, samples, position, period);
  894.         overlapAdd(newSamples, numChannels, outputBuffer, numOutputSamples + period, samples,
  895.                 position + period, samples, position);
  896.         numOutputSamples += period + newSamples;
  897.         return newSamples;
  898.     }
  899.  
  900.     // Resample as many pitch periods as we have buffered on the input.  Return 0 if
  901.     // we fail to resize an input or output buffer.  Also scale the output by the volume.
  902.     private void changeSpeed(
  903.             float speed) {
  904.         int numSamples = numInputSamples;
  905.         int position = 0, period, newSamples;
  906.  
  907.         if (numInputSamples < maxRequired) {
  908.             return;
  909.         }
  910.         do {
  911.             if (remainingInputToCopy > 0) {
  912.                 newSamples = copyInputToOutput(position);
  913.                 position += newSamples;
  914.             } else {
  915.                 period = findPitchPeriod(inputBuffer, position, true);
  916.                 if (speed > 1.0) {
  917.                     newSamples = skipPitchPeriod(inputBuffer, position, speed, period);
  918.                     position += period + newSamples;
  919.                 } else {
  920.                     newSamples = insertPitchPeriod(inputBuffer, position, speed, period);
  921.                     position += newSamples;
  922.                 }
  923.             }
  924.         } while (position + maxRequired <= numSamples);
  925.         removeInputSamples(position);
  926.     }
  927.  
  928.     // Resample as many pitch periods as we have buffered on the input.  Scale the output by the volume.
  929.     private void processStreamInput() {
  930.         int originalNumOutputSamples = numOutputSamples;
  931.         float s = speed / pitch;
  932.         float r = rate;
  933.  
  934.         if (!useChordPitch) {
  935.             r *= pitch;
  936.         }
  937.         if (s > 1.00001 || s < 0.99999) {
  938.             changeSpeed(s);
  939.         } else {
  940.             copyToOutput(inputBuffer, 0, numInputSamples);
  941.             numInputSamples = 0;
  942.         }
  943.         if (useChordPitch) {
  944.             if (pitch != 1.0f) {
  945.                 adjustPitch(originalNumOutputSamples);
  946.             }
  947.         } else if (r != 1.0f) {
  948.             adjustRate(r, originalNumOutputSamples);
  949.         }
  950.         if (volume != 1.0f) {
  951.             // Adjust output volume.
  952.             scaleSamples(outputBuffer, originalNumOutputSamples, numOutputSamples - originalNumOutputSamples,
  953.                     volume);
  954.         }
  955.     }
  956.  
  957.     // Write floating point data to the input buffer and process it.
  958.     public void writeFloatToStream(
  959.             float[] samples,
  960.             int numSamples) {
  961.         addFloatSamplesToInputBuffer(samples, numSamples);
  962.         processStreamInput();
  963.     }
  964.  
  965.     // Write the data to the input stream, and process it.
  966.     public void writeShortToStream(
  967.             short[] samples,
  968.             int numSamples) {
  969.         addShortSamplesToInputBuffer(samples, numSamples);
  970.         processStreamInput();
  971.     }
  972.  
  973.     // Simple wrapper around sonicWriteFloatToStream that does the unsigned byte to short
  974.     // conversion for you.
  975.     public void writeUnsignedByteToStream(
  976.             byte[] samples,
  977.             int numSamples) {
  978.         addUnsignedByteSamplesToInputBuffer(samples, numSamples);
  979.         processStreamInput();
  980.     }
  981.  
  982.     // Simple wrapper around sonicWriteBytesToStream that does the byte to 16-bit LE conversion.
  983.     public void writeBytesToStream(
  984.             byte[] inBuffer,
  985.             int numBytes) {
  986.         addBytesToInputBuffer(inBuffer, numBytes);
  987.         processStreamInput();
  988.     }
  989.  
  990.     /* This is a non-stream oriented interface to just change the speed of a sound sample */
  991.     public int sonicChangeShortSpeed(
  992.             short[] samples,
  993.             int numSamples,
  994.             float speed,
  995.             float pitch,
  996.             float rate,
  997.             float volume,
  998.             boolean useChordPitch,
  999.             int sampleRate,
  1000.             int numChannels) {
  1001.         Sound stream = new Sound(sampleRate, numChannels);
  1002.  
  1003.         stream.setSpeed(speed);
  1004.         stream.setPitch(pitch);
  1005.         stream.setRate(rate);
  1006.         stream.setVolume(volume);
  1007.         stream.setChordPitch(useChordPitch);
  1008.         stream.writeShortToStream(samples, numSamples);
  1009.         stream.flushStream();
  1010.         numSamples = stream.samplesAvailable();
  1011.         stream.readShortFromStream(samples, numSamples);
  1012.         return numSamples;
  1013.     }
  1014.  
  1015. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/354875
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号