Mit Android einen beliebigen Ton spielen

92

Gibt es eine Möglichkeit, Android dazu zu bringen, einen Sound mit beliebiger Frequenz zu senden (dh ich möchte keine aufgezeichneten Sounddateien haben)?

Ich habe mich umgesehen und ToneGenerator war das einzige, was ich finden konnte, das sogar nahe war, aber es scheint nur in der Lage zu sein, die Standard-DTMF-Töne auszugeben.

Irgendwelche Ideen?

Jeremy Logan
quelle
2
Haben Sie eine echte Lösung gefunden?
o0 '.
20
Nein, aber am Ende habe ich das Projekt nicht gemacht.
Jeremy Logan
1
@JeremyLogan Und du hast positives negatives Feedback bekommen. lol.
TheRealChx101

Antworten:

109

Ich habe diesen Beispielcode ursprünglich in einem Blog gefunden, aber er enthielt einige Fehler, die einige schreckliche Geräusche erzeugten. Ich habe die Fehler behoben und den resultierenden Code hier gepostet. Scheint gut für mich zu funktionieren!

public class PlaySound extends Activity {
    // originally from http://marblemice.blogspot.com/2010/04/generate-and-play-tone-in-android.html
    // and modified by Steve Pomeroy <[email protected]>
    private final int duration = 3; // seconds
    private final int sampleRate = 8000;
    private final int numSamples = duration * sampleRate;
    private final double sample[] = new double[numSamples];
    private final double freqOfTone = 440; // hz

    private final byte generatedSnd[] = new byte[2 * numSamples];

    Handler handler = new Handler();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Use a new tread as this can take a while
        final Thread thread = new Thread(new Runnable() {
            public void run() {
                genTone();
                handler.post(new Runnable() {

                    public void run() {
                        playSound();
                    }
                });
            }
        });
        thread.start();
    }

    void genTone(){
        // fill out the array
        for (int i = 0; i < numSamples; ++i) {
            sample[i] = Math.sin(2 * Math.PI * i / (sampleRate/freqOfTone));
        }

        // convert to 16 bit pcm sound array
        // assumes the sample buffer is normalised.
        int idx = 0;
        for (final double dVal : sample) {
            // scale to maximum amplitude
            final short val = (short) ((dVal * 32767));
            // in 16 bit wav PCM, first byte is the low order byte
            generatedSnd[idx++] = (byte) (val & 0x00ff);
            generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);

        }
    }

    void playSound(){
        final AudioTrack audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
                sampleRate, AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_16BIT, generatedSnd.length,
                AudioTrack.MODE_STATIC);
        audioTrack.write(generatedSnd, 0, generatedSnd.length);
        audioTrack.play();
    }
}
Steve Pomeroy
quelle
2
Ist diese Zeile korrekt? audioTrack.write (generateSnd, 0, numSamples); oder sollte es numSamples * 2 sein, da es 2 Bytes pro Probe gibt. Die Schreibmethode benötigt auch ein Array von Kurzschlüssen. Was ist also der Vorteil der Erstellung eines Zwischenarrays von Bytes?
Damian Kennedy
2
Dies ist in der Tat ein gutes Beispiel, vielen Dank. Ich habe jedoch einen weiteren bösen Fehler gefunden (wenn Sie den Code erweitern): audioTrack.write (generateSnd, 0, numSamples) sollte audioTrack.write (generateSnd, 0, 2 * numSamples) oder besser audioTrack.write (generateSnd, 0) sein , generateSnd.length);
AudioDroid
6
Anstatt "numSamples" im AudioTrack-Konstruktor zu verwenden, sollten Sie generateSnd.length verwenden, da der fünfte Parameter "Puffergröße in Bytes" ist. Das Beispiel spielt nur die erste Hälfte des Tons.
Torben
5
@ Black27 Die Samples werden in Gleitkommazahlen mit einem Amplitudenbereich von 0.0bis erstellt 1.0. Multiplizieren mit 32767würde es in den 16-Bit-Festpunktbereich konvertieren. Der AudioTrack erwartet, dass der Puffer im Little- Endian- Format vorliegt . Daher konvertieren die nächsten beiden Zeilen nur die Bytereihenfolge von Big Endian in Little Endian.
Ains
2
using private static final int sampleRate = 192000; Ich konnte Ultraschall spielen
user3505444
26

Verbesserung des obigen Codes:

Fügen Sie die Amplitudenrampe hoch und runter, um Klicks zu vermeiden.

Fügen Sie Code hinzu, um festzustellen, wann der Tack beendet ist.

double duration = 1;            // seconds
double freqOfTone = 1000;       // hz
int sampleRate = 8000;          // a number

double dnumSamples = duration * sampleRate;
dnumSamples = Math.ceil(dnumSamples);
int numSamples = (int) dnumSamples;
double sample[] = new double[numSamples];
byte generatedSnd[] = new byte[2 * numSamples];


for (int i = 0; i < numSamples; ++i) {    // Fill the sample array
    sample[i] = Math.sin(freqOfTone * 2 * Math.PI * i / (sampleRate));
}

// convert to 16 bit pcm sound array
// assumes the sample buffer is normalized.
// convert to 16 bit pcm sound array
// assumes the sample buffer is normalised.
int idx = 0;
int i = 0 ;

int ramp = numSamples / 20 ;                                     // Amplitude ramp as a percent of sample count


for (i = 0; i< ramp; ++i) {                                      // Ramp amplitude up (to avoid clicks)
    double dVal = sample[i];
                                                                 // Ramp up to maximum
    final short val = (short) ((dVal * 32767 * i/ramp));
                                                                 // in 16 bit wav PCM, first byte is the low order byte
    generatedSnd[idx++] = (byte) (val & 0x00ff);
    generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
}


for (i = i; i< numSamples - ramp; ++i) {                         // Max amplitude for most of the samples
    double dVal = sample[i];
                                                                 // scale to maximum amplitude
    final short val = (short) ((dVal * 32767));
                                                                 // in 16 bit wav PCM, first byte is the low order byte
    generatedSnd[idx++] = (byte) (val & 0x00ff);
    generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
}

for (i = i; i< numSamples; ++i) {                                // Ramp amplitude down
    double dVal = sample[i];
                                                                 // Ramp down to zero
    final short val = (short) ((dVal * 32767 * (numSamples-i)/ramp ));
                                                                 // in 16 bit wav PCM, first byte is the low order byte
    generatedSnd[idx++] = (byte) (val & 0x00ff);
    generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
}

AudioTrack audioTrack = null;                                    // Get audio track
try {
    audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
        sampleRate, AudioFormat.CHANNEL_CONFIGURATION_MONO,
        AudioFormat.ENCODING_PCM_16BIT, (int)numSamples*2,
        AudioTrack.MODE_STATIC);
    audioTrack.write(generatedSnd, 0, generatedSnd.length);        // Load the track
    audioTrack.play();                                             // Play the track
}
catch (Exception e){
    RunTimeError("Error: " + e);
    return false;
}

int x =0;
do{                                                              // Monitor playback to find when done
    if (audioTrack != null) 
        x = audioTrack.getPlaybackHeadPosition(); 
    else 
        x = numSamples;
} while (x<numSamples);

if (audioTrack != null) audioTrack.release();                    // Track play done. Release track.
Xarph
quelle
1
Die primäre Änderung war das Auf- und Absteigen der Amplitude. Der ursprüngliche Code begann und endete mit maximaler Amplitude. Dies erzeugt Klicks am Anfang und Ende des Tons. Dieser Code erhöht die Amplitude von 0 auf die volle Amplitude über die ersten 20% der Abtastwerte. In den letzten 20% der Proben wird dann die volle Amplitude auf Null gesenkt. Die Töne sind weicher und viel angenehmer. Die andere Änderung bestand darin, die Wiedergabe des Tons zu überwachen und erst fortzufahren, wenn die Wiedergabe des Tons beendet war.
Xarph
Ich kann es nicht zum Laufen bringen. Ich kann das erste ausführen. Aber ich kann nicht wirklich verstehen, wie man es an das anpasst, was du getan hast. Es wäre wirklich hilfreich, da ich den Klick-Sound loswerden möchte. .
Coder
3
+1, aber der Code in dieser Antwort kommt dem Kompilieren nicht nahe. Ich habe es hier richtig implementiert: gist.github.com/SuspendedPhan/7596139 Ersetzen Sie einfach Steves genTone () -Methode durch meine, und Sie erhalten den Ramping-Effekt.
Dylan P
Da es einen Speicherverlust bei MODE_STATIC gibt, habe ich den Code so geändert, dass MODE_STREAM unten verwendet wird
extrem am
Beginnend mit der API ist es möglich, die Rampe mit setVolume () durchzuführen. Dies ermöglicht es, nur ein sehr kleines Sample zu schleifen und sogar einen Sound für eine dynamische Länge abzuspielen (z. B. während der Benutzer einen Buttion hält). Codebeispiel
Stefan Haustein
8

Ich habe die oben genannten wunderbaren Lösungen in ein hübsches kleines Paket verpackt, das sofort als einfacher konfigurierbarer Summer verwendet werden kann. Es wird in einem Hintergrundthread ausgeführt und verfügt über Stop-and-Play-Methoden und eine Handvoll Optionen, die Sie festlegen können.

Es ist in JCenter verfügbar, sodass Sie es wie folgt zu Ihrer Abhängigkeitsliste hinzufügen können

compile 'net.mabboud:android-tone-player:0.2'

und Sie verwenden es so für einen kontinuierlichen Summer

ContinuousBuzzer tonePlayer = new ContinuousBuzzer();
tonePlayer.play();

// just an example don't actually use Thread.sleep in your app
Thread.sleep(1000); 
tonePlayer.stop();

oder ein Summer wird nur einmal gespielt und Sie können Frequenz und Lautstärke so einstellen

OneTimeBuzzer buzzer = new OneTimeBuzzer();
buzzer.setDuration(5);

// volume values are from 0-100
buzzer.setVolume(50);
buzzer.setToneFreqInHz(110);

Erweiterter Blog-Beitrag hier darüber hier GitHub hier

meese
quelle
@ Melchester es ist jetzt behoben. Vielen Dank für die Heads-Ups und Entschuldigung
Meese
4

Da es in einigen älteren Android-Versionen einen Fehler gibt, der bei Verwendung von MODE_STATIC einen Speicherverlust verursacht, habe ich die Antwort von Xarph oben geändert, um MODE_STREAM zu verwenden. Hoffentlich hilft es einigen.

public void playTone(double freqOfTone, double duration) {
 //double duration = 1000;                // seconds
 //   double freqOfTone = 1000;           // hz
    int sampleRate = 8000;              // a number

    double dnumSamples = duration * sampleRate;
    dnumSamples = Math.ceil(dnumSamples);
    int numSamples = (int) dnumSamples;
    double sample[] = new double[numSamples];
    byte generatedSnd[] = new byte[2 * numSamples];


    for (int i = 0; i < numSamples; ++i) {      // Fill the sample array
        sample[i] = Math.sin(freqOfTone * 2 * Math.PI * i / (sampleRate));
    }

    // convert to 16 bit pcm sound array
    // assumes the sample buffer is normalized.
    // convert to 16 bit pcm sound array
    // assumes the sample buffer is normalised.
    int idx = 0;
    int i = 0 ;

    int ramp = numSamples / 20 ;                                    // Amplitude ramp as a percent of sample count


    for (i = 0; i< ramp; ++i) {                                     // Ramp amplitude up (to avoid clicks)
        double dVal = sample[i];
                                                                    // Ramp up to maximum
        final short val = (short) ((dVal * 32767 * i/ramp));
                                                                    // in 16 bit wav PCM, first byte is the low order byte
        generatedSnd[idx++] = (byte) (val & 0x00ff);
        generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
    }


    for (i = i; i< numSamples - ramp; ++i) {                        // Max amplitude for most of the samples
        double dVal = sample[i];
                                                                    // scale to maximum amplitude
        final short val = (short) ((dVal * 32767));
                                                                    // in 16 bit wav PCM, first byte is the low order byte
        generatedSnd[idx++] = (byte) (val & 0x00ff);
        generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
    }

    for (i = i; i< numSamples; ++i) {                               // Ramp amplitude down
        double dVal = sample[i];
                                                                    // Ramp down to zero
        final short val = (short) ((dVal * 32767 * (numSamples-i)/ramp ));
                                                                    // in 16 bit wav PCM, first byte is the low order byte
        generatedSnd[idx++] = (byte) (val & 0x00ff);
        generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
    }

    AudioTrack audioTrack = null;                                   // Get audio track
    try {
         int bufferSize = AudioTrack.getMinBufferSize(sampleRate, AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT);
        audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
                sampleRate, AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_16BIT, bufferSize,
                AudioTrack.MODE_STREAM);
        audioTrack.play();                                          // Play the track
        audioTrack.write(generatedSnd, 0, generatedSnd.length);     // Load the track
    }
    catch (Exception e){
    }
    if (audioTrack != null) audioTrack.release();           // Track play done. Release track.
}
extrem
quelle
3

Geänderter Code Basierend auf Singhaks Antwort

public class MainActivity extends Activity {
    private final int duration = 30; // seconds
    private final int sampleRate = 8000;
    private final int numSamples = duration * sampleRate;
    private final double sample[] = new double[numSamples];
    private final double freqOfTone = 440; // hz
    private final byte generatedSnd[] = new byte[2 * numSamples];
    Handler handler = new Handler();
    private AudioTrack audioTrack;
    private boolean play = false;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
                8000, AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_16BIT, numSamples,
                AudioTrack.MODE_STREAM);
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Use a new tread as this can take a while
        Thread thread = new Thread(new Runnable() {
            public void run() {

                handler.post(new Runnable() {

                    public void run() {
                        playSound();
                        genTone();
                    }
                });
            }   
        });
        thread.start();
    }

    void genTone(){
        // fill out the array
        while(play){
                for (int i = 0; i < numSamples; ++i) {
                //  float angular_frequency = 
                    sample[i] = Math.sin(2 * Math.PI * i / (sampleRate/freqOfTone));
                }
                int idx = 0;

                // convert to 16 bit pcm sound array
                // assumes the sample buffer is normalised.
                for (double dVal : sample) {
                    short val = (short) (dVal * 32767);
                    generatedSnd[idx++] = (byte) (val & 0x00ff);
                    generatedSnd[idx++] = (byte) ((val & 0xff00) >>> 8);
                }
                audioTrack.write(generatedSnd, 0, numSamples);
            }
        }


    void playSound(){
        play = true;
        audioTrack.play();
    }
}
Raju yourPepe
quelle
2
    float synth_frequency = 440;
    int minSize = AudioTrack.getMinBufferSize(SAMPLE_RATE,
AudioFormat.CHANNEL_OUT_MONO,
AudioFormat.ENCODING_PCM_16BIT);
AudioTrack audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
SAMPLE_RATE,
AudioFormat.CHANNEL_OUT_MONO,
AudioFormat.ENCODING_PCM_16BIT,
minSize,
AudioTrack.MODE_STREAM);
audioTrack.play();
short[] buffer = new short[minSize];
float angle = 0;
while (true) 
{
    if (play)
    {
        for (int i = 0; i < buffer.length; i++)
        {
            float angular_frequency =
            (float)(2*Math.PI) * synth_frequency / SAMPLE_RATE;
            buffer[i] = (short)(Short.MAX_VALUE * ((float) Math.sin(angle)));
            angle += angular_frequency;
    }
        audioTrack.write(buffer, 0, buffer.length);
    } 

// Sie können einen beliebigen Wert in synth_frequency hinzufügen, um Änderungssound zu erhalten. Sie können beispielsweise eine Zufallsvariable hinzufügen, um Sound zu erhalten

Singhak
quelle
Am Ende wandeln Sie alles in einen Kurzfilm um. Es gibt keinen Grund, Winkel als Schwimmer zu machen. Doppelmathematik ist die gleiche Geschwindigkeit und erfordert keine Menge Casting.
Tatarize
2

Do major (16 Noten)

 public class MainActivity extends AppCompatActivity {

  private double mInterval = 0.125;
  private int mSampleRate = 8000;
  private byte[] generatedSnd;

  private final double mStandardFreq = 440;

  Handler handler = new Handler();
  private AudioTrack audioTrack;


  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
  }

  @Override
  protected void onResume() {
    super.onResume();

    // Use a new tread as this can take a while
    final Thread thread = new Thread(new Runnable() {
        public void run() {

            byte[] tempByte = new byte[0];
            for (int i = 0; i < 16 ; i++ ){
                double note = getNoteFrequencies(i);
                byte[] tonByteNote = getTone(mInterval, mSampleRate, note);
                tempByte = concat(tonByteNote, tempByte);
            }
            generatedSnd = tempByte;

            handler.post(new Runnable() {
                public void run() {
                    playTrack(generatedSnd);
                }
            });
        }
    });
    thread.start();
  }

  public byte[] concat(byte[] a, byte[] b) {
    int aLen = a.length;
    int bLen = b.length;
    byte[] c= new byte[aLen+bLen];
    System.arraycopy(a, 0, c, 0, aLen);
    System.arraycopy(b, 0, c, aLen, bLen);
    return c;
  }

  private double getNoteFrequencies(int index){
    return mStandardFreq * Math.pow(2, (double) index/12.0d);
  }

  private byte[] getTone(double duration, int rate, double frequencies){

    int maxLength = (int)(duration * rate);
    byte generatedTone[] = new byte[2 * maxLength];

    double[] sample = new double[maxLength];
    int idx = 0;

    for (int x = 0; x < maxLength; x++){
        sample[x] = sine(x, frequencies / rate);
    }


    for (final double dVal : sample) {

        final short val = (short) ((dVal * 32767));

        // in 16 bit wav PCM, first byte is the low order byte
        generatedTone[idx++] = (byte) (val & 0x00ff);
        generatedTone[idx++] = (byte) ((val & 0xff00) >>> 8);

    }

    return generatedTone;
}

  private AudioTrack getAudioTrack(int length){

    if (audioTrack == null)
        audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
                mSampleRate, AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_16BIT, length,
                AudioTrack.MODE_STATIC);

    return audioTrack;
  }

  private double sine(int x, double frequencies){
    return Math.sin(  2*Math.PI * x * frequencies);
  }

  void playTrack(byte[] generatedSnd){
    getAudioTrack(generatedSnd.length)
            .write(generatedSnd, 0, generatedSnd.length);
    audioTrack.play();
  }

}
Vahe Gharibyan
quelle
2

siehe diese hilfreiche Bibliothek

https://github.com/karlotoy/perfectTune

es ist einfach zu bedienen

Fügen Sie dies Ihren Abhängigkeiten hinzu

 compile 'com.github.karlotoy:perfectTune:1.0.2'

Und du benutzt es so:

PerfectTune perfectTune = new PerfectTune();
perfectTune.setTuneFreq(desire_freq);
perfectTune.playTune();

um die Melodie zu stoppen:

perfectTune.stopTune();
Shinta
quelle