Of course! Converting AMR (Adaptive Multi-Rate) audio to MP3 in Java can be done in a few ways. The most reliable and recommended approach is to use a well-established, pure-Java audio processing library.

Here’s a breakdown of the best methods, with a complete, step-by-step example using the most popular library.

Method 1: Using the JAVE (Java Audio Video Encoder) Library (Recommended)

JAVE is a Java wrapper for the powerful FFmpeg command-line tool. It provides a simple Java API to perform complex audio/video conversions. This is the easiest and most robust method.

Why JAVE?

• Highly Reliable: It leverages the battle-tested FFmpeg engine.
• Simple API: The code is very clean and easy to understand.
• Handles Complexities: It manages the command-line arguments and process execution for you.
• Cross-Platform: Works on Windows, macOS, and Linux.

Step-by-Step Guide with JAVE

Step 1: Add the JAVE Dependency

You need to add the JAVE library to your project. If you're using a build tool like Maven or Gradle, add the following dependency.

Maven (pom.xml):

<dependency>
    <groupId>it.sauronsoftware</groupId>
    <artifactId>jave</artifactId>
    <!-- Check for the latest version on Maven Central -->
    <version>1.0.2</version>
</dependency>

Gradle (build.gradle):

implementation 'it.sauronsoftware:jave:1.0.2'

Step 2: The Java Conversion Code

Here is a complete, runnable Java class that converts an AMR file to an MP3 file.

import it.sauronsoftware.jave.Encoder;
import it.sauronsoftware.jave.EncoderException;
import it.sauronsoftware.jave.ProgressListener;
import it.sauronsoftware.jave.InputFormatException;
import java.io.File;
public class AmrToMp3Converter {
    public static void main(String[] args) {
        // Define input and output file paths
        File sourceAmrFile = new File("path/to/your/input.amr");
        File targetMp3File = new File("path/to/your/output.mp3");
        // Basic validation
        if (!sourceAmrFile.exists()) {
            System.err.println("Error: Input file not found at " + sourceAmrFile.getAbsolutePath());
            return;
        }
        System.out.println("Starting conversion from AMR to MP3...");
        System.out.println("Input:  " + sourceAmrFile.getName());
        System.out.println("Output: " + targetMp3File.getName());
        try {
            // 1. Create an Encoder instance
            Encoder encoder = new Encoder();
            // 2. Define the audio encoding format
            // We are converting AMR to MP3.
            // The output format is specified by the target file's extension (.mp3).
            // JAVE automatically handles the input format based on the source file's extension (.amr).
            // Optional: Set a progress listener to monitor the conversion
            encoder.setProgressListener(new ProgressListener() {
                public void progressUpdate(EncoderProgressEvent event) {
                    long percent = event.getPercentage();
                    System.out.printf("Progress: %d%%\n", percent);
                }
            });
            // 3. Perform the encoding
            encoder.encode(sourceAmrFile, targetMp3File);
            System.out.println("\nConversion completed successfully!");
        } catch (InputFormatException e) {
            System.err.println("Error: The input file is not a valid AMR file or is corrupted.");
            e.printStackTrace();
        } catch (EncoderException e) {
            System.err.println("Error: An error occurred during the audio encoding process.");
            e.printStackTrace();
        }
    }
}

How to Run the Code:

1. Replace the Paths: Change "path/to/your/input.amr" and "path/to/your/output.mp3" to the actual paths of your files.
2. Compile and Run:
   • If using an IDE (like IntelliJ or Eclipse), just run the main method.
   • If using the command line, make sure the JAVE JAR is in your classpath:

     java -cp ".:path/to/jave-1.0.2.jar" AmrToMp3Converter

     (Note: The classpath separator is on Linux/macOS and on Windows).

Method 2: Using the Tritonus Library (Pure Java, but more complex)

Tritonus is a collection of Java libraries for audio and MIDI. It can decode AMR without needing an external native library like FFmpeg. However, its API is more complex and less user-friendly than JAVE.

This method is good if you want a pure Java solution without any external dependencies (other than the Tritonus JARs), but be prepared for a steeper learning curve.

Steps:

1. Download Tritonus: Get the tritonus_share and tritonus_samples JARs from the Tritonus website.
2. Write the Code: You would need to:
   • Set up an AudioInputStream for the AMR file.
   • Use an AudioSystem to get the appropriate decoder.
   • Read the decoded PCM data.
   • Write this PCM data to an AudioFormat for MP3.
   • Use an AudioSystem to get an encoder for MP3 and write the output.

This is a much lower-level process and requires a deeper understanding of the Java Sound API. For most use cases, JAVE is the superior choice.

Method 3: Manual Process Execution (Not Recommended for Production)

You could manually execute the ffmpeg command-line tool from Java using Runtime.exec() or ProcessBuilder.

import java.io.File;
public class FfmpegManualRunner {
    public static void main(String[] args) {
        String inputPath = "path/to/your/input.amr";
        String outputPath = "path/to/your/output.mp3";
        // Make sure ffmpeg is in your system's PATH or provide the full path
        String ffmpegPath = "ffmpeg"; 
        ProcessBuilder pb = new ProcessBuilder(
            ffmpegPath,
            "-i", inputPath,         // Input file
            "-vn",                   // Disable video recording
            "-ab", "192k",           // Set audio bitrate to 192k
            "-ar", "44100",          // Set audio sampling rate to 44.1kHz
            "-y",                    // Overwrite output file if it exists
            outputPath               // Output file
        );
        try {
            System.out.println("Executing command: " + pb.command());
            Process process = pb.start();
            // Optional: Read input and error streams to prevent deadlocks
            StreamGobbler outputGobbler = new StreamGobbler(process.getInputStream(), System.out::println);
            StreamGobbler errorGobbler = new StreamGobbler(process.getErrorStream(), System.err::println);
            outputGobbler.start();
            errorGobbler.start();
            int exitCode = process.waitFor();
            if (exitCode == 0) {
                System.out.println("Conversion successful!");
            } else {
                System.err.println("Conversion failed with exit code: " + exitCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // Helper class to consume streams from the process
    static class StreamGobbler extends Thread {
        private final InputStream inputStream;
        private final java.util.function.Consumer<String> consumer;
        public StreamGobbler(InputStream inputStream, java.util.function.Consumer<String> consumer) {
            this.inputStream = inputStream;
            this.consumer = consumer;
        }
        @Override
        public void run() {
            new BufferedReader(new InputStreamReader(inputStream)).lines()
              .forEach(consumer);
        }
    }
}

Why this is not recommended:

• Error-Prone: You have to handle command-line arguments, process streams, and potential OS differences.
• No Progress Tracking: It's much harder to get real-time progress updates.
• Less Robust: JAVE handles all the edge cases and provides a clean abstraction.

Summary and Recommendation

For any serious Java project, use JAVE. It provides the perfect balance of simplicity, power, and reliability for converting AMR to MP3.