I'm programming a function to normalize an AudioFile.
I am using the JAudioTagger library.

I create a short AudioFile in Logic Pro X which will be completely silent (If i understand it right, all the bytes of the mp3 body should be 0).

Now, when reading the AudioFile into a byte[] without the header (which is 4096 bytes long), the body contains some values (and one is max (128)).

What happens here? Is the header a little longer than expected? Or does logic do some crazy stuff?

Here is the code of my class:

```
public class AudioNormalizer {
    public static void normalizeAudioFile(AudioFile audioFile){
        byte[] audioInBytes = convertAudioFileToByteArray(audioFile);
        int maxValue = getMaxValue(audioInBytes);
    }

    public static byte[] convertAudioFileToByteArray(AudioFile audioFile) {

        if (audioFile instanceof MP3File){
            try {
                org.jaudiotagger.audio.mp3.MP3File mp3File = new org.jaudiotagger.audio.mp3.MP3File(audioFile.getFile());
                long startingByte = mp3File.getMP3StartByte(audioFile.getFile());
                System.out.println(startingByte);

                return getBytesFromPosition(audioFile.getFile(), startingByte);

            } catch (IOException e) {
                e.printStackTrace();
            } catch (TagException e) {
                e.printStackTrace();
            } catch (ReadOnlyFileException e) {
                e.printStackTrace();
            } catch (InvalidAudioFrameException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private static int getMaxValue(byte[] theArray){
        int maxValue = 0;
        int tempValue = 0;
        for (int value : theArray){
            tempValue = value;
            if (tempValue < 0){
                tempValue = tempValue * -1;
            }
            if (maxValue < tempValue){
                maxValue = tempValue;
            }
        }
        return maxValue;
    }

    private static byte[] getBytesFromPosition(File file, long startingByte){
        FileInputStream fileStream = null;
        byte[] result;
        try {
            fileStream = new FileInputStream(file);

            // Instantiate array
            byte[] arr= new byte[(int)file.length()];
            result = new byte[arr.length - (int)startingByte];

            /// read All bytes of File stream
            fileStream.read(arr,0,arr.length);

            FileWriter fw = new FileWriter("testOut.txt");

            for (int i = 0; i < 8000; i++) {
                fw.write(i + " " + arr[i] + "\n");
            }

            fw.close();

            for (int i = 0; i < arr.length - startingByte; i++){
                result[i] = arr[i + (int)startingByte];
            }

            //for (int X : arr){
            //    System.out.print((char)X);
            //}

            return result;

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }
}

```

And here is the Output of the byte Array which consists of the array index and then the value (e.g.: 4011(array Index) 100(value)).

```
4083 0
4084 0
4085 0
4086 0
4087 0
4088 0
4089 0
4090 0
4091 0
4092 0
4093 0
4094 0
4095 0
4096 -1 (Starting point of the body)
4097 -5
4098 -30
4099 64
4100 0
4101 0
4102 0
4103 0
4104 0
4105 55
4106 -128
4107 0
4108 0
4109 0
4110 0
4111 0
4112 6
4113 -16
4114 0
4115 0
4116 0
4117 0
4118 0
4119 0
4120 -34
4121 0
4122 0
4123 0 (The rest is all 0)

```

I hope someone could explain me what I'm doing wrong