Mixer di song audio in Android a livello di programmazione

Question

Voglio creare un mixer audio (traccia di musica DJ) tipo di app che può creare il mixer DJ di una canzone audio. L'utente può selezionare una traccia di una canzone musicale che può essere mixata con due o più tracce separate di ritmo, basso o battito per creare una nuova musica Dj modificata.

Ho fatto molte ricerche su questo ma non ho trovato alcuna idea o indizio.

Se qualcuno ha qualche idea o qualche URL di riferimento su questo, per favore condividilo.

Answer 1

Sembra che la parte più difficile di questo sarebbe quella di riprodurre più tracce contemporaneamente e che il resto può essere fatto con l'interfaccia utente. Un collegamento che potrebbe essere d'aiuto è How to play multiple ogg or mp3 at the same time..? La documentazione di SoundPool, che consente di riprodurre più suoni contemporaneamente, può essere trovata here.

Answer 2

Non esiste una libreria incorporata su Android che supporti il ​​missaggio audio (combinazione di due flussi di input audio in un flusso di output). La libreria Java javax.sound che supporta il missaggio audio non è stata trasferita su Android - c'è un interessante discussion su Google Gruppi con l'ingegnere di Google Diane Hackborn sulla decisione di non trasferire javax.sound su Android.

Sembra che tu debba sviluppare la tua soluzione da zero. Ci sono diverse risposte utili su SO su come combinare due flussi audio in un:

Mixing Audio Files

Audio editing in Android

Android - Mixing multiple static waveforms into a single AudioTrack

Answer 3

File dir; 
dir = new File(Environment.getExternalStorageDirectory().getAbsolutePath()); 
dir.mkdirs(); 

//Audio Mixer for two .raw file into single .wav file... 
void AudioMixer() { 
    File file_play1 = new File(dir, "Neww.raw"); 
    int shortSizeInBytes = Short.SIZE/Byte.SIZE; 
    int bufferSizeInBytes = (int) (file_play1.length()/shortSizeInBytes); 
    short[] audioData = new short[bufferSizeInBytes]; 

    try { 
     InputStream inputStream = new FileInputStream(file_play1); 
     BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream); 
     DataInputStream dataInputStream = new DataInputStream(bufferedInputStream); 

     InputStream inputStream1 = getResources().openRawResource(R.raw.trainss); //Play form raw folder 
     BufferedInputStream bufferedInputStream1 = new BufferedInputStream(inputStream1); 
     DataInputStream dataInputStream1 = new DataInputStream(bufferedInputStream1); 

     int i = 0; 
     while (dataInputStream.available() > 0 && dataInputStream1.available() > 0) { 
      audioData[i] = (short) (dataInputStream.readShort() + dataInputStream1.readShort()); 
      i++; 
     } 

     dataInputStream.close(); 
     dataInputStream1.close(); 
     AudioTrack audioTrack = new AudioTrack(
       AudioManager.STREAM_MUSIC, 
       11025, 
       AudioFormat.CHANNEL_CONFIGURATION_MONO, 
       AudioFormat.ENCODING_PCM_16BIT, 
       bufferSizeInBytes, 
       AudioTrack.MODE_STREAM); 
     audioTrack.write(audioData, 0, bufferSizeInBytes); 

     //merge two .raw files in single .raw file... 
     File file_record = new File(dir, "testing.raw"); 
     try { 
      OutputStream outputStream = new FileOutputStream(file_record); 
      BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream); 
      DataOutputStream dataOutputStream = new DataOutputStream(bufferedOutputStream); 

      for (int j = 0; j < audioData.length; j++) { 
       dataOutputStream.writeShort(audioData[j]); 
      } 
      dataOutputStream.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     //Convert that .raw (testing.raw) file into .wav (testingNew.wav) file 
     File des = new File(dir, "testingNew.wav"); 
     try { 
      rawToWave(file_record, des); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } catch (FileNotFoundException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } catch (IllegalStateException e) { 
     e.printStackTrace(); 
    } 
} 

//convert .raw file to .wav File... 
private void rawToWave(final File rawFile, final File waveFile) throws IOException { 
    byte[] rawData = new byte[(int) rawFile.length()]; 
    DataInputStream input = null; 
    try { 
     input = new DataInputStream(new FileInputStream(rawFile)); 
     input.read(rawData); 
    } finally { 
     if (input != null) { 
      input.close(); 
     } 
    } 

    DataOutputStream output = null; 
    try { 
     output = new DataOutputStream(new FileOutputStream(waveFile)); 
     // WAVE header 
     writeString(output, "RIFF"); // chunk id 
     writeInt(output, 36 + rawData.length); // chunk size 
     writeString(output, "WAVE"); // format 
     writeString(output, "fmt "); // subchunk 1 id 
     writeInt(output, 16); // subchunk 1 size 
     writeShort(output, (short) 1); // audio format (1 = PCM) 
     writeShort(output, (short) 1); // number of channels 
     writeInt(output, SAMPLE_RATE); // sample rate 
     writeInt(output, SAMPLE_RATE * 2); // byte rate 
     writeShort(output, (short) 2); // block align 
     writeShort(output, (short) 16); // bits per sample 
     writeString(output, "data"); // subchunk 2 id 
     writeInt(output, rawData.length); // subchunk 2 size 
     // Audio data (conversion big endian -> little endian) 
     short[] shorts = new short[rawData.length/2]; 
     ByteBuffer.wrap(rawData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(shorts); 
     ByteBuffer bytes = ByteBuffer.allocate(shorts.length * 2); 
     for (short s : shorts) { 
      bytes.putShort(s); 
     } 
     output.write(bytes.array()); 
    } finally { 
     if (output != null) { 
      output.close(); 
     } 
    } 
} 

private void writeInt(final DataOutputStream output, final int value) throws IOException { 
    output.write(value >> 0); 
    output.write(value >> 8); 
    output.write(value >> 16); 
    output.write(value >> 24); 
} 

private void writeShort(final DataOutputStream output, final short value) throws IOException { 
    output.write(value >> 0); 
    output.write(value >> 8); 
} 

private void writeString(final DataOutputStream output, final String value) throws IOException { 
    for (int i = 0; i < value.length(); i++) { 
     output.write(value.charAt(i)); 
    } 
} 


//playing merged file... 
private void playWavFile() { 
    MediaPlayer recorded_audio_in_sounds = new MediaPlayer(); 
    String outputFile = Environment.getExternalStorageDirectory().getAbsolutePath() + "/testingNew.wav"; 
    try { 
     if (recorded_audio_in_sounds != null) { 
      if (recorded_audio_in_sounds.isPlaying()) { 
       recorded_audio_in_sounds.pause(); 
       recorded_audio_in_sounds.stop(); 
       recorded_audio_in_sounds.reset(); 
       recorded_audio_in_sounds.setDataSource(outputFile); 
       recorded_audio_in_sounds.prepare(); 
       recorded_audio_in_sounds.setAudioStreamType(AudioManager.STREAM_MUSIC); 
       recorded_audio_in_sounds.start(); 
       recorded_audio_in_sounds.start(); 
      } else { 
       recorded_audio_in_sounds.reset(); 
       recorded_audio_in_sounds.setDataSource(outputFile); 
       recorded_audio_in_sounds.prepare(); 
       recorded_audio_in_sounds.start(); 
       recorded_audio_in_sounds.setVolume(2.0f, 2.0f); 
      } 
     } 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
}