Mikser audio w Androidzie programowo

Question

Chcę stworzyć mikser audio (utwór muzyki DJ), który może stworzyć mikser DJ'a piosenki audio. Użytkownik może wybrać ścieżkę utworu muzycznego, którą można miksować z dwoma lub więcej oddzielnymi ścieżkami rytmicznymi, basowymi lub beatowymi, aby utworzyć nową zmodyfikowaną muzykę Dj.

Zrobiłem dużo badań nad tym, ale nie mogłem znaleźć żadnego pomysłu ani wskazówki.

Jeśli ktoś ma jakiś pomysł lub jakiś odnośnikowy adres URL dotyczący tego, proszę go udostępnić.

Answer 1

To brzmi jak najtrudniejszą częścią tego będzie odtwarzanie wielu utworów na raz, a reszta może być wykonana za pomocą interfejsu użytkownika. Jednym linkiem, który może ci pomóc, jest How to play multiple ogg or mp3 at the same time..? Dokumentacja SoundPool, która umożliwia odtwarzanie wielu dźwięków na raz, można znaleźć pod numerem here.

Answer 2

Na Androidzie nie ma wbudowanej biblioteki obsługującej miksowanie dźwięku (połączenie dwóch strumieni wejściowych audio w jeden strumień wyjściowy). Biblioteka Java javax.sound, która obsługuje miksowanie dźwięku, nie została przeniesiona na Androida - w Google Groups jest interesująca discussion z inżynierem Google Diane Hackborn o decyzji o nieprzeniesieniu numeru javax.sound na Androida.

Wygląda na to, że musisz opracować własne rozwiązanie od zera. Istnieje kilka osób odpowiada na tak dalej, jak połączyć dwa strumienie audio w jednym:

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(); 
    } 
}