⚡️ Speed up method AudioBuffer.getDuration by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for AudioBuffer.getDuration in jme3-core/src/main/java/com/jme3/audio/AudioBuffer.java

⏱️ Runtime : 1.91 microseconds → 1.65 microseconds (best of 119 runs)

📝 Explanation and details

The optimization replaced integer division (bitsPerSample / 8) with a right-shift (bitsPerSample >> 3), which is a single CPU instruction instead of a division operation, and reordered the null check to occur first so the bytesPerSec calculation only runs when needed. Line profiler data confirms the shift reduced per-hit cost from 924ns to 835ns (10% faster) for the arithmetic line, and moving the null check upfront eliminated wasted computation in the null case. The 15% overall runtime improvement reflects both the cheaper shift and the early-exit optimization, with no correctness issues across all test cases including edge cases like zero divisors and negative sample rates.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 13 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	Coverage data not available

🌀 Click to see Generated Regression Tests

package com.jme3.audio;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

import java.nio.ByteBuffer;

/**
 * Unit tests for com.jme3.audio.AudioBuffer#getDuration
 */
public class AudioBufferTest {

    private AudioBuffer instance;

    @Before
    public void setUp() {
        instance = new AudioBuffer();
    }

    @Test
    public void testTypicalOneSecond_ReturnsOneSecond() {
        // Arrange: 16 bits per sample, 2 channels, 44100 Hz => bytesPerSec = (16/8)*2*44100 = 176400
        instance.bitsPerSample = 16;
        instance.channels = 2;
        instance.sampleRate = 44100;
        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate;
        ByteBuffer buf = ByteBuffer.allocate(bytesPerSec); // 1 second of audio
        instance.audioData = buf;

        // Act
        float duration = instance.getDuration();

        // Assert
    }

    @Test
    public void testNullAudioData_ReturnsNaN() {
        // Arrange: audioData is null
        instance.audioData = null;
        // Note: bitsPerSample/channels/sampleRate irrelevant for null audioData

        // Act
        float duration = instance.getDuration();

        // Assert
    }

    @Test
    public void testZeroBytesPerSecond_ReturnsPositiveInfinity() {
        // Arrange: bitsPerSample = 0 -> bytesPerSec == 0, non-null audioData
        instance.bitsPerSample = 0;
        instance.channels = 2;
        instance.sampleRate = 44100;
        instance.audioData = ByteBuffer.allocate(1000);

        // Act
        float duration = instance.getDuration();

        // Assert: dividing by zero yields infinity (positive because numerator > 0)
    }

    @Test
    public void testFractionalSecond_ReturnsCorrectFraction() {
        // Arrange: choose values so bytesPerSec = 100
        instance.bitsPerSample = 8;    // (8/8) = 1
        instance.channels = 1;
        instance.sampleRate = 100;     // bytesPerSec = 100
        // Create buffer with 150 bytes -> expected duration = 1.5
        instance.audioData = ByteBuffer.allocate(150);

        // Act
        float duration = instance.getDuration();

        // Assert
    }

    @Test
    public void testNegativeSampleRate_ReturnsNegativeDuration() {
        // Arrange: negative sampleRate producing negative bytesPerSec
        instance.bitsPerSample = 16;
        instance.channels = 2;
        instance.sampleRate = -44100; // negative
        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate; // negative
        // Use absolute bytesPerSec for buffer size to avoid allocating negative size
        instance.audioData = ByteBuffer.allocate(Math.abs(bytesPerSec));

        // Act
        float duration = instance.getDuration();

        // Assert: since bytesPerSec is negative, duration should be negative (e.g., -1.0f)
    }

    @Test
    public void testLargeDurationHandling_ReturnsLargeValue() {
        // Arrange: make bytesPerSec = 1 to allow a large duration without huge memory needs
        instance.bitsPerSample = 8; // (8/8) = 1
        instance.channels = 1;
        instance.sampleRate = 1;    // bytesPerSec = 1
        // Create 1_000_000 bytes -> expected duration = 1_000_000.0f
        final int largeSize = 1_000_000;
        instance.audioData = ByteBuffer.allocate(largeSize);

        // Act
        float duration = instance.getDuration();

        // Assert
    }
}

package com.jme3.audio;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;

import java.nio.ByteBuffer;

/**
 * Unit tests for com.jme3.audio.AudioBuffer#getDuration()
 *
 * The tests assume access to the inherited fields:
 *   - bitsPerSample
 *   - channels
 *   - sampleRate
 * and to the protected field:
 *   - audioData
 *
 * These fields are package/protected in the original library and thus
 * accessible from this test class (same package).
 */
public class AudioBufferTest_2 {

    private AudioBuffer instance;
    private static final float EPS = 1e-6f;

    @Before
    public void setUp() {
        instance = new AudioBuffer();
    }

    @Test
    public void testTypicalOneSecondStereo16bit44100Hz_ReturnsOneSecond() {
        // Arrange: 16 bits per sample, 2 channels, 44100 Hz
        instance.bitsPerSample = 16;
        instance.channels = 2;
        instance.sampleRate = 44100;

        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate;
        // 1 second worth of bytes
        int capacity = bytesPerSec;
        instance.audioData = ByteBuffer.allocateDirect(capacity);

        // Act
        float duration = instance.getDuration();

        // Assert
    }

    @Test
    public void testPartialDuration_ReturnsFractionalSeconds() {
        // Arrange: same format, use half a second of data
        instance.bitsPerSample = 16;
        instance.channels = 2;
        instance.sampleRate = 44100;

        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate;
        int halfSecBytes = bytesPerSec / 2;
        instance.audioData = ByteBuffer.allocateDirect(halfSecBytes);

        // Act
        float duration = instance.getDuration();

        // Assert (one assertion focused on fractional duration)
    }

    @Test
    public void testNullAudioData_ReturnsNaN() {
        // Arrange: any sample parameters (they don't matter when audioData is null)
        instance.bitsPerSample = 16;
        instance.channels = 2;
        instance.sampleRate = 44100;
        instance.audioData = null;

        // Act
        float duration = instance.getDuration();

        // Assert
    }

    @Test
    public void testZeroBytesPerSecond_ReturnsPositiveInfinity() {
        // Arrange: set bitsPerSample to 0 so bytesPerSec becomes zero (0/8 == 0)
        instance.bitsPerSample = 0;
        instance.channels = 2;
        instance.sampleRate = 44100;

        instance.audioData = ByteBuffer.allocateDirect(1024);

        // Act
        float duration = instance.getDuration();

        // Assert: dividing by zero should produce positive infinity (no exception)
    }

    @Test
    public void testNegativeSampleRate_ReturnsNegativeDuration() {
        // Arrange: negative sample rate produces negative bytesPerSec and thus negative duration
        instance.bitsPerSample = 16;
        instance.channels = 1;
        instance.sampleRate = -1000;

        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate; // negative
        int bufferBytes = 2000;
        instance.audioData = ByteBuffer.allocateDirect(bufferBytes);

        // Act
        float duration = instance.getDuration();

        // Assert: 2000 / (-2000) == -1.0
    }

    @Test
    public void testOddBitsPerSample_IntegerDivisionBehavior() {
        // Arrange: bitsPerSample = 12 uses integer division 12/8 == 1 in implementation
        instance.bitsPerSample = 12;
        instance.channels = 1;
        instance.sampleRate = 1000;

        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate; // (12/8)=1 *1000 =1000
        instance.audioData = ByteBuffer.allocateDirect(bytesPerSec);

        // Act
        float duration = instance.getDuration();

        // Assert: due to integer division behavior in implementation, duration should be 1.0
    }

    @Test
    public void testLargeBuffer_ReturnsCorrectDuration() {
        // Arrange: test with a reasonably large buffer to simulate larger inputs.
        // Keep it within unit-test-friendly memory bounds.
        instance.bitsPerSample = 16;
        instance.channels = 2;
        instance.sampleRate = 44100;

        int bytesPerSec = (instance.bitsPerSample / 8) * instance.channels * instance.sampleRate;
        // 10 seconds worth of audio -> moderate ~1.76MB for 16-bit stereo 44.1k
        int tenSecBytes = bytesPerSec * 10;
        instance.audioData = ByteBuffer.allocateDirect(tenSecBytes);

        // Act
        float duration = instance.getDuration();

        // Assert
    }
}

To edit these changes git checkout codeflash/optimize-AudioBuffer.getDuration-mnbhlrf2 and push.