Sovrapporre due file MP3 + Salvare output

[DarknessKiller]

Ciao! Felice di essere qui!

Sto lavorando su un'applicazione che per due settimane mi sta facendo cadere i capelli, peggio delle radiazioni:
Sovrapporre due file MP3 (Overlap).

Ho due file: Background.mp3 e Voice.mp3. Lo scopo del programma è quello di leggere i due files e sovrapporli in un unico file, quindi salvarlo.

Mentre andavo a tentativi ho scoperto la classe AudioInputStream. Con questa posso leggere il flusso di dati del file in questione.

Guardando il Javadoc References, ho trovato anche la classe Mixer, ma non ho ancora idea di cosa faccia.

Riassumendo, il programma deve:
[list=1][*]Leggere due flussi audio MP3[*]Sovrapporli in un unico flusso[*]Salvare il flusso che contiene i due flussi MP3 sovrapposti.[/list=1]

Essendo un neonato nel mondo della programmazione, potreste aiutarmi a darmi delle dritte, indicandomi librerie, classi o quant'altro per riuscire nel mio intento?

Grazie in anticipo dell'aiuto!

[DarknessKiller]

Aggiorno dicendo che ho scoperto l'incompatibilità di Java verso l'MP3. In compenso riesce a leggere i WAVE.
Ci sono online delle librerie che aiutano a rendere compatibile l'MP3:
[list=1][*]MP3SPI[*]JMF (ora è stato tolto il funzionamento MP3)[/list=1]
Quindi rimane l'MP3SPI del team di JavaZoom. Voi consigliate altre librerie?

Avete qualche idea sul come potrei sovrapporre i due flussi per poi salvarne l'output?

Rimango in attesa di risposta. Ciao!



PS: Avevo già letto nel regolamento che si deve mettere il linguaggio in questione nel titolo del thread, ma essendo nel forum di Java mi sembrava un po' inutile.

[DarknessKiller]

Ho lasciato da parte la lettura degli MP3 per fare l'overlap. Prima forse è meglio concentrarsi su quello che il linguaggio è supportato a fare, leggere i file WAVE.

Ho scoperto anche un'altra classe del package "com.db.media.audio"
MixingAudioInputStream
che prende come valori un formato audio e una collezione di AudioInputStream.

Grazie a documentazioni varie, sono riuscito a scrivere questa funzione:

public void merge(String s1, String s2, String output)
    {
        int sampleRate = 44100;

        File f1 = new File(s1);
        File f2 = new File(s2);
        File fOut = new File(output);

        AudioInputStream ais1;
        AudioInputStream ais2;

        Collection audioList = new ArrayList();
        
        MixingAudioInputStream mixed;

        try
        {
            AudioFormat af = new AudioFormat((float)sampleRate, 16, 1, true, true );

            // 1st Audio file ----------------------------------------------------------------------
            ais1 = AudioSystem.getAudioInputStream(f1);
            AudioFormat audioFormat1 = ais1.getFormat();
            DataLine.Info dataLine1 = new DataLine.Info(SourceDataLine.class, audioFormat1);
            SourceDataLine source1 = (SourceDataLine) AudioSystem.getLine(dataLine1);
            // 1st Audio file ----------------------------------END---------------------------------

            // 2nd Audio file ----------------------------------------------------------------------
            ais2 = AudioSystem.getAudioInputStream(f2);
            AudioFormat audioFormat2 = ais2.getFormat();
            DataLine.Info dataLine2 = new DataLine.Info(SourceDataLine.class, audioFormat2);
            SourceDataLine source2 = (SourceDataLine) AudioSystem.getLine(dataLine2);
            // 2nd Audio file ----------------------------------END---------------------------------

            audioList.add(ais1.read());
            audioList.add(ais2.read());


            readAudio(ais1, audioFormat1, source1);
            System.out.println("POOOOOOOOOO"); // debug per verificare le letture
            readAudio(ais2, audioFormat2, source2);

            System.out.println(audioList);
            mixed = new MixingAudioInputStream(audioFormat1, audioList);

            AudioInputStream aisM = AudioSystem.getAudioInputStream(mixed);

            AudioSystem.write(aisM, AudioFileFormat.Type.WAVE, fOut);

            System.out.println("1st: " + s1 + ": " + audioFormat1 + " " + ais1.getFrameLength() + "\n2nd: " + s2 + ": " + audioFormat2 + " " + ais2.getFrameLength());
            System.out.println("Created: " + output + ": " + mixed.getFormat() + " " + mixed.getFrameLength());

        } catch (UnsupportedAudioFileException ex)
        {
            Logger.getLogger(MP3Merger.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex)
        {
            Logger.getLogger(MP3Merger.class.getName()).log(Level.SEVERE, null, ex);
        } catch (LineUnavailableException ex)
        {
            Logger.getLogger(MP3Merger.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

ma continuo a ricevere questo errore tentando di leggere un file wave casuale "guitarnote.wav":

Exception in thread "main" java.lang.IllegalArgumentException: No line matching interface SourceDataLine supporting format PCM_SIGNED 44100.0 Hz, 16 bit, stereo, 4 bytes/frame, little-endian

Questo vuol dire che il formato non è supportato. Allora la domanda è: Quali sono i formati supportati da Java?

[DarknessKiller]

Ho fatto altri test con la classe MixingAudioInputStream, e sono venuto a una conclusione dove salva il file MP3 "Fusion.mp3" che fa partire i due file audio mixati.

Il problema è che se non si ferma, questa applicazione va in un loop infinito! Il che vuol dire che se non la si ferma, si potrebbe creare un file di dimensioni apocalittiche.

Quando ho fatto partire questa applicazione, ho visto che si ferma nel loop di "AudioSystem.write".

// AutoImport: desktop_dependencies.jar

import com.db.media.audio.*;
import java.io.*;
import java.util.*;
import java.util.logging.*;
import javax.sound.sampled.*;
 /**
 *
 * @author Leonardo
 */
public class MP3Mixer
{
    public MP3Mixer() {}
    public static void main(String[] args)
    {
        MP3Mixer mp3 = new MP3Mixer();

        mp3.mix("drums.mp3", "guitar.mp3", "Fusion.mp3");
    }

    public void mix(String background, String voice, String output) // Mixes the files
    {
        File f1 = new File(background); // Background
        File f2 = new File(voice); // Voice
        File fOut = new File(output); // Saved file


        AudioInputStream aisBackground;  // Input stream Background
        AudioInputStream daisBackground; // Decoded Input stream

        AudioInputStream aisVoice; // Input stream Voice
        AudioInputStream daisVoice; // Decoded Input stream

        AudioInputStream aisTotal; // The entire MP3

        Collection<AudioInputStream> audioList; // Collection of MP3 files

        try
        {
            // 1st Audio file ----------------------------------------------------------------------
            aisBackground = AudioSystem.getAudioInputStream(f1);
            AudioFormat rawAudioFormat1 = aisBackground.getFormat();
            AudioFormat decodedFormat1 = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                                            rawAudioFormat1.getSampleRate(),
                                            16,
                                            rawAudioFormat1.getChannels(),
                                            rawAudioFormat1.getChannels() * 2,
                                            rawAudioFormat1.getSampleRate(),
                                            false);
            daisBackground = AudioSystem.getAudioInputStream(decodedFormat1, aisBackground);
            // 1st Audio file ----------------------------------END---------------------------------

            // 2nd Audio file ----------------------------------------------------------------------
            aisVoice = AudioSystem.getAudioInputStream(f2);
            AudioFormat rawAudioFormat2 = aisVoice.getFormat();
            AudioFormat decodedFormat2 = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                                            rawAudioFormat2.getSampleRate(),
                                            16,
                                            rawAudioFormat2.getChannels(),
                                            rawAudioFormat2.getChannels() * 2,
                                            rawAudioFormat2.getSampleRate(),
                                            false);
            daisVoice = AudioSystem.getAudioInputStream(decodedFormat2, aisVoice);
            // 2nd Audio file ----------------------------------END---------------------------------

            audioList = new ArrayList<AudioInputStream>();

            audioList.add(daisBackground);
            audioList.add(daisVoice);

            MixingAudioInputStream mixed = new MixingAudioInputStream(decodedFormat1, audioList); // Class mixes MP3s

            aisTotal = new AudioInputStream(mixed, mixed.getFormat(), daisVoice.getFrameLength());

            System.out.println(audioList);
            System.out.println("1st: " + background + ": " + decodedFormat1 + " " + daisBackground.getFrameLength() + "\n2nd: " + voice + ": " + decodedFormat2 + " " + daisVoice.getFrameLength());

            AudioSystem.write(aisTotal, AudioFileFormat.Type.WAVE, fOut); // Saves the file
   
            System.out.println("Created: " + output + ": " + mixed.getFormat() + " " + mixed.getFrameLength());

        } catch (UnsupportedAudioFileException ex)
        {
            Logger.getLogger(WAVMixer.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex)
        {
            Logger.getLogger(WAVMixer.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
}

Avete qualche idea al riguardo?