Need help on Java in sound application

Question

A good day to everyone here,
I need help on using Java.My project is mainly manipulating WAV sound files with Java. There is some problem.I hope you all can help me. I couldn't find much info about Java in sound manipulating,sample coding or something like that. I need to find the command to
1) Find each sampling point value in a sound file.
2) Find the number of sampling point and the average value of the all the sampling point.
3) Record the sound file in a different bit rate format.
I dont know how to go about it.I really hope you all can help me, or direct me to any resources that may help me. Your help is very much appreciated.
Thank you very much....

Answer 1

i found this coding in a website n i not very sure that i understand it.
can anyone tell me if i can find the sample point value of a sound file with this coding (byte[] source is byte array of the sound file).
thanks...for all the help
public byte[] executeAmplitudeTransformationInternal(byte[]
source)
int[] sampleArray = getSampleArray(source);
int[] newSampleArray = executeTransformation(sampleArray);
//convert 16 bit samples back to 8 bit byte[]
return getByteArray(newSampleArray);
public int[] getSampleArray(byte[] eightBitByteArray) {
//create an array 1/2 the size (since every 2
//8bit samples makes 1 16bit sample)
int[] toReturn = new int[eightBitByteArray.length];
int index = 0;
for (int t = 0; t < eightBitByteArray.length; t += 2) {
//read the high bit
int low = (int) eightBitByteArray[t];
//read the low bit
int high = (int) eightBitByteArray[t + 1];
//bit shift the high bit 8 bits to the left and
// "And" the low bit against 255 to drop any
//sign extended data in the top 8 bits.
//refer to the tutorial for more clarification
toReturn[index] = (high << 8) (low & 0x00ff);
index++;
return toReturn;
public byte[] getByteArray(int[] sampleArray) {
//create a new byte[] twice as big as the sample array
//because it takes two 8-bit bytes to represent one
//16-bit sample
byte[] toReturn = new byte[sampleArray.length * 2];
int index = 0;
for (int t = 0; t < sampleArray.length; t++) {
int sample = sampleArray[t];
//this places the low byte in the array.
//the downcasting automatically lops off the high byte
toReturn[index] = (byte) sample;
index++;
//this byte shifts the sample 8 bits to the right
//this puts the old high byte in the position of the low byte.
//this way the high byte remains after the downcasating from
//an int to a byte
toReturn[index] = (byte) (sample >> 8);
index++;
return toReturn;
public int[] executeTransformation(int[] sampleArray) {
//create a clone sample array
int[] newSampleArray = new int[sampleArray.length];
//apply algo to each sample
for (int t = 0; t < sampleArray.length; t++) {
int result = (int) (sampleArray[t] );
//add the sample
newSampleArray[t] = result;
return newSampleArray;