Changeset 1007 for trunk

Timestamp:

03/08/16 23:22:09 (8 years ago)

Author:

davidb

Message:

Generalization of audio support to allow playback/mixer to be stereo, plus some edits to comments

Location:

trunk/src/org/apollo

Files:

• audio/ApolloPlaybackMixer.java (modified) (11 diffs)
• audio/SampledAudioManager.java (modified) (6 diffs)
• gui/DualPeakTroughWaveFormRenderer.java (modified) (6 diffs)
• gui/SampledTrackGraphView.java (modified) (1 diff)
• io/AudioIO.java (modified) (8 diffs)
• widgets/SampledTrack.java (modified) (2 diffs)

trunk/src/org/apollo/audio/ApolloPlaybackMixer.java

@@ -324 +324 @@
                 if (playbackThread == null) {
                 
-                        playbackThread = new PlaybackThread();
+                        AudioFormat audio_format = SampledAudioManager.getInstance().getDefaultPlaybackFormat();
+                        if (audio_format.getChannels()==2) {
+                                playbackThread = new StereoPlaybackThread();
+                        }
+                        else {
+                                playbackThread = new MonoPlaybackThread();
+                        }
                         playbackThread.start();
                         
@@ -451 +457 @@
          *
          */
-        private class PlaybackThread extends Thread {
-                
-                private SourceDataLine srcDataLine; // never null
-
-                private boolean isStopping = false;
-                
-                private int bufferFrameLength;
-                private boolean isOutputBigEndian;
+        private abstract class PlaybackThread extends Thread {
+                
+                protected SourceDataLine srcDataLine; // never null
+
+                protected boolean isStopping = false;
+                
+                protected int bufferFrameLength;
+                protected boolean isOutputBigEndian;
                 
                 /**
@@ -465 +471 @@
                  * @throws LineUnavailableException
                  */
-                PlaybackThread() throws LineUnavailableException {
-                        super("Apollo Playback Mixer Thread");
+                protected PlaybackThread(String threadName) throws LineUnavailableException {
+                        super(threadName);
                         super.setPriority(Thread.MAX_PRIORITY);
                         
@@ -494 +500 @@
                  *              If failed to acquire the source data line.
                  */
-                private void aquireSourceDataLine() throws LineUnavailableException {
+                protected void aquireSourceDataLine() throws LineUnavailableException {
 
                         // Select an audio output format
@@ -508 +514 @@
                         
                         // Cache useful data
-                        bufferFrameLength = srcDataLine.getBufferSize() / 2;
+                        bufferFrameLength = srcDataLine.getBufferSize() / (2*2); // 2=stereo, 2=16-bit
                         isOutputBigEndian = srcDataLine.getFormat().isBigEndian();
                         
@@ -527 +533 @@
                 
                 /**
-                 * Note: even if all tracks have been proccessed in the audio pipeline, it will
+                 * Note: even if all tracks have been processed in the audio pipeline, it will
                  * commence another pass to check for new tracks added to the graph before finishing.
                  * 
@@ -540 +546 @@
                  * @return the best audio format for playback...
                  */
-                private AudioFormat getAudioFormat() {
+                protected AudioFormat getAudioFormat() {
                         return SampledAudioManager.getInstance().getDefaultPlaybackFormat();
                 }
 
+                /**
+                 * The audio mixing pipeline
+                 */
+                public abstract void run();
+        
+
+                
+        }
+
+    private class StereoPlaybackThread extends PlaybackThread {
+                
+
+                
+                /**
+                 * Initantly prepares for audio playback: Opens the (stereo) source data line for output
+                 * 
+                 * @throws LineUnavailableException
+                 */
+                StereoPlaybackThread() throws LineUnavailableException {
+                        super("Apollo Stereo Playback Mixer Thread");
+                        
+                }
+                
+        
+                /**
+                 * The audio mixing pipeline
+                 */
+                public void run() {
+
+                        // Notify observers that some audio has started playing
+                        ApolloPlaybackMixer.this.fireSubjectChangedLaterOnSwingThread(
+                                new SubjectChangedEvent(ApolloSubjectChangedEvent.PLAYBACK_STARTED));
+                        
+                        // All tracks to play per pass
+                        List<TrackSequence> tracksToPlay = new LinkedList<TrackSequence>();
+                        
+                        // Keeps track of tracks to remove
+                        List<TrackSequence> completedTracks = new LinkedList<TrackSequence>();
+                        
+                        // The buffer written directly to the source data line
+                        byte[] sampleBuffer = new byte[2 * 2 * bufferFrameLength]; // 2=stereo, 2=16-bit samples
+                        
+                        // The mixed frames, where each element refers to a frame
+                        int[] mixedFrameBufferL = new int[bufferFrameLength];
+                        int[] mixedFrameBufferR = new int[bufferFrameLength];
+                        
+                        // Helpers declared outside loop for mz efficiency
+                        int msbL, lsbL;
+                        int msbR, lsbR;
+                        int sampleL;
+                        int sampleR;
+                        int totalFramesMixed;
+                        int trackCount; // tracks to play at a given pass
+                        boolean isMoreQueued; // True if there are more tracks queued. 
+                        int frameIndex; 
+                        int i;
+                        
+                        // Begin writing to the source data line
+                        if (srcDataLine.isOpen())
+                                srcDataLine.start();
+                        else return;
+
+                        // keep playing as long as line is open (and there is something to play)
+                        try 
+                        {
+                                while (srcDataLine.isOpen()) { // The audio mixing pipline
+
+                                        // First decide on which tracks to play ... and remove any finished tracks.
+                                        synchronized(sequenceGraph) {
+                                                
+                                                // If there are no more tracks queued for playing, then exit the
+                                                // playback thread.
+                                                if (sequenceGraph.isEmpty()) 
+                                                        return;
+                
+                                                isMoreQueued = false;
+                                                completedTracks.clear();
+                                                tracksToPlay.clear();
+                                                
+                                                for (TrackSequence ts : sequenceGraph) {
+                                                        
+                                                        // Has this track sequence finished?
+                                                        if (ts.currentFrame > ts.endFrame || ts.stopPending)
+                                                                completedTracks.add(ts);
+                                                        
+                                                        // Is this track playing / is meant to start laying in this pass?
+                                                        else if (ts.initiationFrame <= (timelineFrame + bufferFrameLength))
+                                                                tracksToPlay.add(ts);
+        
+                                                        // If it is not time to play the track yet, then
+                                                        // neither will it for all proceeding tracks either
+                                                        // since they are ordered by their initiation time.
+                                                        else break;
+                                                        
+                                                }
+                                                
+                                                // Get rid of tracks that have finished playing. Notify models that they have stopped
+                                                for (TrackSequence staleTS : completedTracks) {
+                                                        
+                                                        sequenceGraph.remove(staleTS);
+                                                        
+                                                        staleTS.onStopped((staleTS.currentFrame > staleTS.endFrame)
+                                                                        ? staleTS.endFrame : staleTS.currentFrame);
+                                                        
+                                                        //removeTrackFromGraph(staleTS, staleTS.endFrame);
+                                                }
+
+                                                trackCount = tracksToPlay.size();
+                                                isMoreQueued = sequenceGraph.size() > trackCount;
+                                                
+                                                // If there is nothing queued and there are no tracks to play,
+                                                // then playback is finished.
+                                                if (!isMoreQueued && trackCount == 0) 
+                                                        return;
+                                                
+                                        } // release lock
+                                        
+                                        totalFramesMixed = 0; // this will be set to the maximum amount of frames that were mixed accross all tracks
+                                        
+                                        // Clear audio buffer
+                                        for (i = 0; i < bufferFrameLength; i++) {
+                                                // TODO: Efficient way of clearing buffer?
+                                                mixedFrameBufferL[i] = 0;
+                                                mixedFrameBufferR[i] = 0; 
+                                        }
+                                        
+                                        // Perform Mixing : 
+                                        // Convert the sample size to 16-bit always for best precision while
+                                        // processing audio in the mix pipeline....
+                                        for (TrackSequence ts : tracksToPlay) {
+                                                
+                                                // Notify model that initiated
+                                                if (!ts.isPlaying()) ts.onInitiated(timelineFrame);
+
+                                                // Skip muted / unsoloed tracks - they add nothing to the sample mix
+                                                if (ts.isMuted || (isSoloEnable && !ts.isSolo)) { 
+                                                        
+                                                        // Make sure start where initiated, if not already initiated
+                                                        if (ts.initiationFrame >= timelineFrame && ts.initiationFrame < (timelineFrame + bufferFrameLength)) {
+                                                                
+                                                                // Get index in frame buffer where to initiate
+                                                                frameIndex = (int)(ts.initiationFrame - timelineFrame);
+                                                                
+                                                                // Calcuate the length of frames to buffer - adjust silent tracks position
+                                                                ts.currentFrame += (bufferFrameLength - frameIndex);
+
+                                                        } else { // skip full buffer of bytes ... silenced
+                                                                
+                                                                ts.currentFrame += bufferFrameLength; // currentFrame can go outside endframe boundry of the track
+                                
+                                                        }
+                                                        
+                                                        totalFramesMixed = bufferFrameLength;
+                                                        
+                                                } else { // Get samples and add to mix
+        
+                                                        // If the track is yet to initiate - part way through the buffer, then start adding bytes
+                                                        // at initiation point
+                                                        if (ts.initiationFrame >= timelineFrame && ts.initiationFrame < (timelineFrame + bufferFrameLength)) {
+                                                                
+                                                                frameIndex = (int)(ts.initiationFrame - timelineFrame);
+                                                                
+                                                        } else { 
+                                                                
+                                                                frameIndex = 0; 
+                                                                
+                                                        }
+                
+                                                        // For each frame
+                                                        for (;frameIndex < bufferFrameLength && ts.currentFrame <= ts.endFrame; frameIndex++) {
+                                                                
+                                                                // Get sample according to byte order
+                                                                int base_posL = ts.currentFrame * (2*2); // 2=stereo, 2=16-bit
+                                                                int base_posR = base_posL+2;
+                                                                
+                                                                if (ts.isBigEndian) {
+                                                                        
+                                                                        // First byte is MSB (high order)
+                                                                        msbL = (int)ts.playbackAudioBytes[base_posL];
+                                                                         
+                                                                         // Second byte is LSB (low order)
+                                                                        lsbL = (int)ts.playbackAudioBytes[base_posL + 1];
+                                                                        
+                                                                        // And again for the right channel
+                                                                        msbR= (int)ts.playbackAudioBytes[base_posR];
+                                                                        lsbR = (int)ts.playbackAudioBytes[base_posR + 1];
+                                                                
+                                                                 } else {
+                                                                         
+                                                                        // First byte is LSB (low order)
+                                                                        lsbL = (int)ts.playbackAudioBytes[base_posL];
+                                                                         
+                                                                        // Second byte is MSB (high order)
+                                                                        msbL = (int)ts.playbackAudioBytes[base_posL+1];
+                                                                        
+                                                                        // And again for the right channel
+                                                                        lsbR = (int)ts.playbackAudioBytes[base_posR];
+                                                                        msbR = (int)ts.playbackAudioBytes[base_posR+1];
+                                                                }
+                                                                
+                                                                sampleL = (msbL << 0x8) | (0xFF & lsbL);
+                                                                sampleR = (msbR << 0x8) | (0xFF & lsbR);
+                                                                
+                                                                // Apply track volume
+                                                                sampleL = (int)(sampleL * ts.volume);
+                                                                sampleR = (int)(sampleR * ts.volume);
+                                                                
+                                                                // Add to current mix
+                                                                mixedFrameBufferL[frameIndex] += sampleL;
+                                                                mixedFrameBufferR[frameIndex] += sampleR;
+                                                                
+                                                                // Get next sample
+                                                                ts.currentFrame++;
+                                                        }
+                                                        
+                                                        
+                                                        // Keep track of total frames mixed in buffer
+                                                        if (frameIndex > totalFramesMixed)
+                                                                totalFramesMixed = frameIndex;
+                                                }
+                
+                                        } // Mix in next track
+        
+                                        // totalFramesMixed is the amount of frames to play.
+                                        // If it is zero then it means that there are tracks yet to be initiated, and nothing currently playing
+                                        assert (totalFramesMixed <= bufferFrameLength);
+                                        assert (totalFramesMixed > 0 ||
+                                                        (totalFramesMixed == 0 && trackCount == 0 && isMoreQueued));
+                                        
+                                        // Post mix with master settings 
+                                        if (isMasterMuteOn) { // Silence sample buffer if master mute is on
+        
+                                                for (i = 0; i < sampleBuffer.length; i++) {
+                                                        sampleBuffer[i] = 0;
+                                                }
+                                                
+                                                // Let the muted bytes play
+                                                totalFramesMixed = bufferFrameLength;
+                                                
+                                        } else { // otherwise apply master volume
+                                                
+                                                for (i = 0; i < totalFramesMixed; i++) {
+                
+                                                        // Average tracks
+                                                        //mixedFrameBuffer[i] /= trackCount; // depreciated
+                                                        
+                                                        // Apply master volume
+                                                        mixedFrameBufferL[i] = (int)(mixedFrameBufferL[i] * masterVolume);
+                                                        mixedFrameBufferR[i] = (int)(mixedFrameBufferR[i] * masterVolume);
+                                                        
+                                                        // Clip
+                                                        if (mixedFrameBufferL[i] > Short.MAX_VALUE) mixedFrameBufferL[i] = Short.MAX_VALUE;
+                                                        else if (mixedFrameBufferL[i] < Short.MIN_VALUE) mixedFrameBufferL[i] = Short.MIN_VALUE; 
+                                                        
+                                                        if (mixedFrameBufferR[i] > Short.MAX_VALUE) mixedFrameBufferR[i] = Short.MAX_VALUE;
+                                                        else if (mixedFrameBufferR[i] < Short.MIN_VALUE) mixedFrameBufferR[i] = Short.MIN_VALUE; 
+                                                        
+                                                        // Convert to output format
+                                                        lsbL = (mixedFrameBufferL[i] & 0xFF);
+                                                        msbL = ((mixedFrameBufferL[i] >> 8) & 0xFF);
+                                                        lsbR = (mixedFrameBufferR[i] & 0xFF);
+                                                        msbR = ((mixedFrameBufferR[i] >> 8) & 0xFF);
+                                                        
+                                                        int base_posL = i * (2 * 2); // 2=stereo, 2=16-bits
+                                                        int base_posR = base_posL + 2;
+                                                        if (isOutputBigEndian) {
+                                                                sampleBuffer[base_posL]   = (byte)msbL;
+                                                                sampleBuffer[base_posL+1] = (byte)lsbL;
+                                                                sampleBuffer[base_posR]   = (byte)msbR;
+                                                                sampleBuffer[base_posR+1] = (byte)lsbR;
+                                                        } else {
+                                                                sampleBuffer[base_posL]   = (byte)lsbL;
+                                                                sampleBuffer[base_posL+1] = (byte)msbL;
+                                                                sampleBuffer[base_posR]   = (byte)lsbR;
+                                                                sampleBuffer[base_posR+1] = (byte)msbR;
+                                                        }
+
+                                                }
+
+                                        }
+                                        
+                                        // Generate silence only if there are more tracks to be played.
+                                        // Note that this could be false, but a track might have been queued after
+                                        // setting the isMoreQueued flag. In such cases... silence is not wanted anyway!
+                                        if (isMoreQueued) {
+                                                for (i = totalFramesMixed; i < bufferFrameLength; i++) { // will skip if no need to generate silence
+                                                        int base_posL = i * (2 * 2); // 2=stereo, 2=16-bits
+                                                        int base_posR = base_posL + 2;
+                                                        
+                                                        sampleBuffer[base_posL]   = 0;
+                                                        sampleBuffer[base_posL+1] = 0;
+                                                        sampleBuffer[base_posR]   = 0;
+                                                        sampleBuffer[base_posR+1] = 0;
+                                                }
+                                                // Ensure that full buffer is played ... including the silence
+                                                totalFramesMixed = bufferFrameLength;
+                                        }
+        
+                                        // Write processed bytes to line out stream and update the timeline frame
+                                        srcDataLine.write(
+                                                        sampleBuffer, 
+                                                        0, 
+                                                        totalFramesMixed * (2 * 2)); // 2=stereo, 2=16-bits
+                                        
+                                        // Update timeline counter for sequencing management
+                                        timelineFrame += totalFramesMixed;
+                                        
+                                        // The timelineFrame should always be larger or equal to the live frame position
+                                        assert(timelineFrame >= srcDataLine.getLongFramePosition());
+                                        
+                                } // Next pass
+                        
+                        } finally { 
+                                
+                                isStopping = true;
+                                
+                                // Ensure line freed
+                                if (srcDataLine.isOpen()) {
+                                        srcDataLine.drain(); // avoids chopping off last buffered chunk
+                                        srcDataLine.close();
+                                }
+                                
+                                // Clear sequence graph. 
+                                synchronized(sequenceGraph) {
+                                        
+                                        for (TrackSequence track : sequenceGraph) {
+                                                
+                                                track.onStopped((track.currentFrame > track.endFrame)
+                                                                ? track.endFrame : track.currentFrame);
+                                        }
+                                        
+                                        sequenceGraph.clear();
+                                        
+                                }
+
+                                // Notify observers that playback has finished.
+                                ApolloPlaybackMixer.this.fireSubjectChangedLaterOnSwingThread(
+                                                new SubjectChangedEvent(ApolloSubjectChangedEvent.PLAYBACK_STOPPED));
+                                
+                        }
+                        
+                }
+        }
+    
+    private class MonoPlaybackThread extends PlaybackThread {
+                
+
+                
+                /**
+                 * Initantly prepares for audio playback: Opens the (stereo) source data line for output
+                 * 
+                 * @throws LineUnavailableException
+                 */
+                MonoPlaybackThread() throws LineUnavailableException {
+                        super("Apollo Mono Playback Mixer Thread");
+                        
+                }
+                
                 /**
                  * The audio mixing pipeline
@@ -637 +1001 @@
                                         
                                         // Clear audio buffer
-                                        for (i = 0; i < bufferFrameLength; i++) // TODO: Effecient way of clearing buffer?
+                                        for (i = 0; i < bufferFrameLength; i++) // TODO: Efficient way of clearing buffer?
                                                 mixedFrameBuffer[i] = 0; 
                                         
@@ -746 +1110 @@
                                                         //mixedFrameBuffer[i] /= trackCount; // depreciated
                                                         
-                                                        // Apply mastar volume
+                                                        // Apply master volume
                                                         mixedFrameBuffer[i] = (int)(mixedFrameBuffer[i] * masterVolume);
                                                         
@@ -781 +1145 @@
                                         }
         
-                                        // Write proccessed bytes to line out stream and update the timeline frame
+                                        // Write processed bytes to line out stream and update the timeline frame
                                         srcDataLine.write(
                                                         sampleBuffer, 
@@ -826 +1190 @@
                 }
                 
-
-                
-        }
+    }
 
         

trunk/src/org/apollo/audio/SampledAudioManager.java

@@ -14 +14 @@
 import org.apollo.mvc.SubjectChangedEvent;
 import org.apollo.util.ApolloSystemLog;
+
 
 /**
@@ -27 +28 @@
         
         /** All internal formats have the same sample rate. */
-        public static final float PLAYBACK_SAMPLE_RATE = 44100.0f; // Audacitys default
-        
-        //public static final float PLAYBACK_SAMPLE_RATE = 22050.0f; // Meldexes internal rate .. todo: fix conversions to use better rate
-
-        // Used for describing the ideal default format for recorded audio and converting un-supported 
+        // The following is based on Audacity's defaults for playback
+        public static final float PLAYBACK_SAMPLE_RATE      = 44100.0f;
+        public static final int   PLAYBACK_BITS_PER_SAMPLE  = 16;      
+        public static final int   PLAYBACK_NUM_CHANNELS     = 2; // stereo
+        
+        //public static final float PLAYBACK_SAMPLE_RATE = 22050.0f; // Meldexe's internal rate .. todo: fix conversions to use better rate
+
+        // Used for describing the ideal default format for recorded audio and converting unsupported 
         // imported audio to... The actual formats may differ depending on the data lines used
         
-        // note: Must be PCM, Mono, 16 bit.
+        // note: Must be PCM, with values as defined for PLAYBACK_... above
         private static final AudioFormat DESIRED_FORMAT = new AudioFormat( // Linear PCM Encoding
-                        PLAYBACK_SAMPLE_RATE, // Always conform to PLAYBACK_SAMPLE_RATE
-                        16, // bits per sample. Must be 16. Audacitys default
-                        1, // Always use mono. Audacitys default
+                        PLAYBACK_SAMPLE_RATE, // Always conform to PLAYBACK_SAMPLE_RATE etc
+                        PLAYBACK_BITS_PER_SAMPLE, 
+                        PLAYBACK_NUM_CHANNELS, 
                         false, // ALWAYS USED SIGNED FOR BEST PERFORMACE - JAVA DOES NOT HAVE UNSIGNED TYPES
                         true // Byte order
@@ -231 +235 @@
                         // Not cadidate if not in appollos format.
                         if (!candiate.getEncoding().toString().startsWith("PCM") 
-                                        || candiate.getChannels() != 1
-                                        || candiate.getSampleSizeInBits() != 16
+                                        || candiate.getChannels() != PLAYBACK_NUM_CHANNELS
+                                        || candiate.getSampleSizeInBits() != PLAYBACK_BITS_PER_SAMPLE
                                         || (candiate.getSampleRate() != AudioSystem.NOT_SPECIFIED &&
                                                         candiate.getSampleRate() != PLAYBACK_SAMPLE_RATE))
@@ -285 +289 @@
         /**
          * Determines if an audio format requires conversion in order to be used 
-         * in Apollos. 
-         * 
-         * Audio formats must be in PCM, mono, 16-bit sample-size,
+         * in Apollo's. 
+         * 
+         * Audio formats must be in PCM, SampledAudioManager#PLAYBACK_NUM_CHANNELS, 
+         * SampledAudioManager#PLAYBACK_BITS_PER_SAMPLE sample-size,
          * SampledAudioManager#PLAYBACK_SAMPLE_RATE sample-rate and be supported
          * by the output mixer.
@@ -304 +309 @@
                 if (format == null) throw new NullPointerException("format");
                 
-                if(!format.getEncoding().toString().startsWith("PCM") || format.getChannels() != 1
-                                || format.getSampleSizeInBits() != 16
+                if(!format.getEncoding().toString().startsWith("PCM") || format.getChannels() != PLAYBACK_NUM_CHANNELS
+                                || format.getSampleSizeInBits() != PLAYBACK_BITS_PER_SAMPLE
                                 || (format.getSampleRate() != AudioSystem.NOT_SPECIFIED &&
                                                 format.getSampleRate() != PLAYBACK_SAMPLE_RATE)) {
@@ -313 +318 @@
                 // Check that the format is supported by the output mixer
                 for (AudioFormat supported : supportedPlaybackFormats) {
-                        if (supported.getChannels() != 1) continue;
+                        if (supported.getChannels() != PLAYBACK_NUM_CHANNELS) continue;
                         if (
                                         format.getEncoding() == supported.getEncoding()

trunk/src/org/apollo/gui/DualPeakTroughWaveFormRenderer.java

@@ -14 +14 @@
         
         private int sampleSize;
+        private int numChannels;
         private boolean isBigEndian;
         private boolean isSigned;
@@ -36 +37 @@
 
                 sampleSize = audioFormat.getSampleSizeInBits();
+                numChannels = audioFormat.getChannels();
                 isSigned = audioFormat.getEncoding().toString().startsWith("PCM_SIGN");
                 isBigEndian = audioFormat.isBigEndian();
@@ -81 +83 @@
                 if (sampleSize == 16) {
                                          
+                        int shift_multiplier = numChannels; // <<1=16-bit-mono, <<2=16-bit-stereo 
                         for (int i = 0; i < aggregationCount; i++) {
                                 
                                 int max = 0, min = 0, sample; // could use short, but int avoids casting everywhere
                                 
-                                int startFrameIndex = (startFrame + (i * aggregationSize)) << 1;
-                                int endFrameIndex = startFrameIndex + (aggregationSize << 1);
+                                int startFrameIndex = (startFrame + (i * aggregationSize)) << shift_multiplier;
+                                int endFrameIndex = startFrameIndex + (aggregationSize << shift_multiplier);
                                 
                                 for (int k = startFrameIndex; k < endFrameIndex; k+=2) {
                         
+                                        // k+=2 works for both mono and stereo
+                                        // in the case of stereo k+=2 alternates between L and R values.
+                                        // net effect is that it still finds the min and max values across
+                                        // all samples: startFrameIndex .. endFrameIndex
+                                         
                                         int lsb, msb;
                                                                  
@@ -128 +136 @@
                 } else if (sampleSize == 8) {
                         
+                        int shift_multiplier = numChannels-1; // <<0=8-bit-mono, <<1=8-bit-stereo
+                        
+                        // 'i' loop below works for either mono or stereo without any adjustment
+                        // for same reason above given for 'k' loop
+                        
                         if (isSigned) {
                   
+                                
                                 // Find the peak within the block of aggregated frames
                                 for (int i = 0; i < amplitudes.length; i++) {
@@ -135 +149 @@
                                         byte max = 0, absmax = -1, sample, abssample;
 
-                                        int startFrameIndex = startFrame + (i * aggregationSize);
-                                        int endFrameIndex = startFrameIndex + aggregationSize;
+                                        int startFrameIndex = (startFrame + (i * aggregationSize)) << shift_multiplier;
+                                        int endFrameIndex = startFrameIndex + (aggregationSize << shift_multiplier);
                                         
                                         for (int k = startFrameIndex; k < endFrameIndex; k++) {
@@ -160 +174 @@
                                         int max = 0, absmax = -1, sample, abssample; // could use short, but int avoid casting everywhere
 
-                                        int startFrameIndex = startFrame + (i * aggregationSize);
-                                        int endFrameIndex = startFrameIndex + aggregationSize;
+                                        int startFrameIndex = (startFrame + (i * aggregationSize)) << shift_multiplier;
+                                        int endFrameIndex = startFrameIndex + (aggregationSize<<shift_multiplier);
                                         
                                         for (int k = startFrameIndex; k < endFrameIndex; k++) {

trunk/src/org/apollo/gui/SampledTrackGraphView.java

@@ -92 +92 @@
         public SampledTrackGraphView() {
                 
-                // Keep backings consistant with component resize
+                // Keep backings consistent with component resize
                 this.addComponentListener(new ComponentListener() {
                         public void componentHidden(ComponentEvent e) {

trunk/src/org/apollo/io/AudioIO.java

@@ -21 +21 @@
 import org.apollo.mvc.SubjectChangedEvent;
 import org.apollo.util.AudioMath;
+
 
 /**
@@ -44 +45 @@
          * 
          * @throws IOException
-         *              If failed to create file for saving, or an error occured while writing audio bytes.
+         *              If failed to create file for saving, or an error occurred while writing audio bytes.
          * 
          * @throws UnsupportedAudioFileException
@@ -505 +506 @@
                                 assert (SampledAudioManager.getInstance().isFormatSupportedForPlayback(sampleFormat));
         
-                                // Initialize the ByteBuffer - and size if possible (not possible for vairable frame size encoding)
+                                // Initialize the ByteBuffer - and size if possible (not possible for variable frame size encoding)
                                 ByteArrayOutputStream loadedBytes = (fformat.getFrameLength() != AudioSystem.NOT_SPECIFIED) ?
                                                 new ByteArrayOutputStream(fformat.getFrameLength() * sampleFormat.getFrameSize()) : 
@@ -511 +512 @@
 
                                 byte[] buffer = new byte[sampleFormat.getFrameSize() * (int)sampleFormat.getFrameRate()];
+                                 
                                 int bytesRead = 0;
                                 int totalBytesRead = 0;
@@ -568 +570 @@
          */
         public static void main(String[] args) {
-                if (args.length == 1) {
-                        
-                        System.out.println("Testing with " + args[0]);
+                
+                String args_zero = null;
+                
+                if (args.length==0) {
+                        // Hardwire to whatever is a meaningful example for you!
+                        args_zero = "C:\\Temp\\GoodTime_Preview.mp3";
+                }
+                else if (args.length==1) {
+                        args_zero = args[0];
+                        
+                }
+        
+                System.out.println("Testing with " + args_zero);
                         
                         try {
-                                LoadedAudioData loaded = loadAudioFile(new File(args[0]), null);
+                                LoadedAudioData loaded = loadAudioFile(new File(args_zero), null);
+                                
                                 if (loaded != null && loaded.getAudioBytes() != null) {
                                         
@@ -580 +593 @@
                                         if (loaded.wasConverted()) {
                                                 savePCMAudioToWaveFile(
-                                                        args[0] + "_pre-converted.wav", 
+                                                        args_zero + "_pre-converted.wav", 
                                                         loaded.getAudioBytes(),
                                                         loaded.getAudioFormat());
@@ -603 +616 @@
                                                 
                                                 savePCMAudioToWaveFile(
-                                                                args[0] + "_converted.wav", 
+                                                                args_zero + "_converted.wav", 
                                                                 stdData,
                                                                 lowQualFormat);
@@ -625 +638 @@
                         return;
                         
-                }
-                
-                System.err.println("Must supply 1 argument: the file path to convert");
+                
+                //System.err.println("Must supply 1 argument: the file path to convert");
                 
                 

trunk/src/org/apollo/widgets/SampledTrack.java

@@ -88 +88 @@
         private SampledTrackModel trackModel = null;
         
-        /** Used for the loading phase. Can change serveal times of a lifetime. for example after import and save it becomes local */
+        /** Used for the loading phase. Can change several times of a lifetime. for example after import and save it becomes local */
         private String loadFilenameArgument = null; // preproceeds with ARG_IMPORT_TAG if importing.
         
-        private String localFileName; // Immutable - assigned on constuction
+        private String localFileName; // Immutable - assigned on construction
         
         /** Used for dumping audio to a temp file when deleted - to free memory.
@@ -152 +152 @@
                 trackModel = new SampledTrackModel(audioBytes, format, localFileName);
                 
-                // Ensure that the model is marked as modiefied so that it will save
+                // Ensure that the model is marked as modified so that it will save
                 trackModel.setAudioModifiedFlag(true);