musica - virtual dj para android gratis

Mezclador de canciones de audio en Android programáticamente

Question

Quiero crear un tipo de aplicación de mezclador de audio (pista de música DJ) que pueda crear el mezclador de DJ de una canción de audio. El usuario puede seleccionar una pista de canción de música que se puede mezclar con dos o más pistas rítmicas, de bajo o de ritmo separadas para crear una nueva música de Dj modificada.

Investigué mucho sobre esto pero no pude encontrar ninguna idea o pista.

Si alguien tiene alguna idea o alguna URL de referencia sobre esto, por favor compártelo.

Answer 1

Parece que la parte más difícil de esto sería reproducir varias pistas a la vez, y que el resto se puede hacer con la interfaz de usuario. Un enlace que podría ayudarlo es ¿Cómo jugar múltiples ogg o mp3 al mismo tiempo ...? La documentación para SoundPool, que le permite reproducir varios sonidos a la vez, se puede encontrar aquí .

Answer 2

No hay una biblioteca incorporada en Android que admita la mezcla de audio (combinando dos flujos de entrada de audio en una secuencia de salida). La biblioteca javax.sound Java que admite la mezcla de audio no se transfirió a Android: hay una discusión interesante en Google Groups con la ingeniero de Google Diane Hackborn sobre la decisión de no javax.sound a Android.

Parece que tienes que desarrollar tu propia solución desde cero. Hay varias respuestas útiles sobre SO sobre cómo combinar dos flujos de audio en uno:

Mezcla de archivos de audio

Edición de audio en Android

Android - Mezcla múltiples formas de onda estáticas en un solo 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();
    }
}