Java Sound API noise after processing the byte array with a fraction number

Question

Hi,

I'm trying to process my byte array which I got from the sampled sourcedataline (Java Sound API). If I'm multiplying the byte array with a fraction number, I will get noise while playing the stream.

Before I'm playing the sound I separate the stereo wav file into his left and right channel. This works fine. But if I want to process the channels with a gain control, which depends on a delay factor, I get noise.

for(int i=0; i<bufferSize; i++) { array[i] = (byte) (array[i] * gain); }

Does anyone know how to fix the problem?

//EDIT:

I tried to convert the two bytes into a short (2bytes) with bit shifting e.g.:

short leftMask = 0xff00;
short rightMask = 0x00ff;
short sValue = (array[i] + array[i+1] <<8) * gain;

array[i] = (sValue & leftMask) >> 8;
array[i+1] = (sValue & rightMask);

but I got the same when I just multiply the single bytes with the gain value.

//EDIT

OR should I just add the two array values into a short like this?

short shortValue = array[i] + array[i+1];
shortValue *= gain;
array[i] = ???

But how do I convert this short into the 2 single bytes without losing the sound?

//EDIT some code from the separating method:

public static void channelManipulation(byte[] arrayComplete) {
     int i=2; 
     char channel='L';
     int j=0; 

     /** 
      * The stereo stream will be divided into his channels - the Left and the Right channel. 
      * Every 2 bytes the channel switches. 
      * While data is collected for the left channel the right channel will be set by 0. Vice versa.
      */
     while(j<arrayComplete.length) {
      //while we are in the left channel we are collecting 2 bytes into the arrayLeft


      while(channel=='L') {
       if(i==0) {
        channel='R'; //switching to the right channel
        i=2;
        break;
       }
       arrayLeft[j] = (byte)(arrayComplete[j]);
       arrayRight[j] = 0;
       i--; j++;
      }

      //while we are in the right channel we are collecting 2 bytes into the arrayRight
      while(channel=='R') {
       if(i==0) {
        channel='L'; //switching to the left channel
        i=2;
        break;
       }
       arrayRight[j] = (byte) (arrayComplete[j]);
       arrayLeft[j] = 0;
       i--; j++;
      }
     }

    }

Answer 1

You need to apply some clipping. Suppose you have a sample of value 100, and you are applying a gain of 2. The result of the multiplication will be 200, which then ends up truncated to -73.

Try:

array[i] = Math.min(Math.max(array[i] * gain, -128), 127);

As a test for this - if you apply a gain which is effectively a "quietening" gain (e.g. 0.5) you shouldn't get noise at the moment.

EDIT: If the "raw" values aren't actually single bytes, you should convert from the byte array to those values first, and then apply the gain, then convert back to single bytes. Otherwise you will indeed get some strange results... particularly if the native format is actually treating the bytes as unsigned values...

Answer 2

Does not work. I have this code snippet:

for(int c=0; c<Constants.getBufferlength()-4; c+=4) {
      arrayLeft[c] = (byte) Math.min(Math.max((arrayLeft[c]*leftGain), -128), 127);

      arrayRight[c] = (byte) Math.min(Math.max((arrayRight[c]*rightGain),-128),127);

 }

I got the noise like before.

Answer 3

Even though your audio data is in the form of a byte array, your real audio is (I'm assuming) an array of short (2-byte) integers. When you multiply each individual byte of your array by a gain factor, you're turning the 2-byte sample values into gibberish (aka noise). I'm not a java programmer, but your solution is to cast the byte array as a 2-byte integer array (however you do that in java), and then multiply each 2-byte integer value by the gain factor (and then, I guess, cast it back to a byte array before playback).

Update: in C#, if I had a byte array of audio data (say, pulled out of a WAV file where the real format was 2-byte integer), I would apply the gain using the BitConverter and Array classes like this:

float gain = 0.5f;
for (int i = 0; i < audio.Length; i += 2)
{
    short val = BitConverter.ToInt16(audio, i);
    val = (short)((float)val * gain);
    Array.Copy(BitConverter.GetBytes(val), 0, audio, i, 2);
}

This is pretty clunky, and it's not something I would ever really do. In the C# world, I always work with audio as an array of 16- or 32-bit integers, or else as 32- or 64-bit floating point values. I really don't know how java audio works at all, but it should be possible (and much easier) somewhere to get your audio as an array of 16-bit integers in the first place - then you won't have to do any weird conversions like this to apply gain or do whatever else you want to do.

Update 2: also, I'm not sure your original audio source actually consists of 2-byte integer sample values. It may in fact be 4-byte integer or (more likely) 4-byte floating-point sample values, in which case my sample code would still produce noise. With 4-byte float, the proper code would be:

float gain = 0.5f;
for (int i = 0; i < audio.Length; i += 4)
{
    float val = BitConverter.ToSingle(audio, i);
    val *= gain;
    Array.Copy(BitConverter.GetBytes(val), 0, audio, i, 4);
}

Answer 4

I found this post after having a very similar sounding problem. FWIW my problem was solved by noting that code such as

short sValue = (array[i] + array[i+1] <<8)

doesn't account for the effect of Java's signed bytes. If the high bit is set in the low byte (e.g. array[i]), then this would have no effect for a short but does effect code that does arithmetic with the short's two bytes separately. Easily fixed by code along the lines of

if(array[i] < 0)
    array[i+1] += 1;

which adds 256 to the short - accounting for the missing 128 bit in the low byte and the two's complement of the rest. You might need some variation on this depending on how you're processing the byte array.