Android: MediaPlayer setVolume funzione

circa params
Set di ciò che il giocatore non suono suono pieno e

Grazie

InformationsquelleAutor Qing | 2011-03-07

 

10 Replies
  1. 111

    Questa funzione è in realtà meraviglioso. Grazie ad esso è possibile creare un volume di scala con qualsiasi numero di passaggi!

    Supponiamo che si desidera 50 passaggi:

    int maxVolume = 50;

    Quindi per impostare setVolume per qualsiasi valore compreso in questo intervallo (0-49) questo:

    float log1=(float)(Math.log(maxVolume-currVolume)/Math.log(maxVolume));
    yourMediaPlayer.setVolume(log1,log1); //set volume takes two paramater

    Bello e facile! E NON usare AudioManager per impostare il volume! Sarà causa di molti effetti collaterali, come la disattivazione della modalità silenziosa, che renderà i vostri utenti mad!

    • +1000 sto cercando questa soluzione per qualche tempo. Fantastico. Grazie!
    • +1 Funzionato come un fascino! Grazie compagno.
    • Devo usare AudioManager quando si cerca di mute in Text to Speech. C’è un modo migliore per impostare muto sintesi Vocale?
    • Hai provato a manipolare AudioManager.STREAM_MUSIC streaming?
    • setVolume metodo ha due parametri setVolume(float, float). Come si sono sempre via con uno?
    • Hai ragione. Forse ho preso una scorciatoia, la scrittura di questo, forse è un codice di applicazione di volume di alcune custom di media player di classe. Nota che, se hai usato Kotlin invece di Java si potrebbe scrivere un’estensione funzione MediaPlayer che fa questo: MediaPlayer.setVolume(x : Float) {...}
    • log(maxVolume – currVolume) tornerà float infinito quando (maxVolume == currVolum), quindi è meglio controllare questo
    • Qual è la formula se currVolume è un galleggiante che varia tra 0 e 1. Sto utilizzando un animazione per nascondere la vista, e contemporaneamente si abbassa il volume sul lettore. L’animazione è il valore animatore (1F -> 0F), e non ho voglia di fare un esubero di conversione da animazione valore intero volume citato in questa risposta.
    • è un numero intero nell’intervallo [0,maxVolume-1] quindi non dovrebbe essere possibile per avere il valore di maxVolume. Nota che per currVolume == maxVolume-1 si ottiene log1 == 0 e setVolume(1) (o, utilizzando l’attuale firma del metodo: setVolume(1,1)), nel senso pieno volume.
    • Qualsiasi modo di ottenere il volume?

  2. 50

    Seguenti user100858 soluzione ho appena posto il mio codice esatto che funziona:

    private final static int MAX_VOLUME = 100;
    ...
    ...
    final float volume = (float) (1 - (Math.log(MAX_VOLUME - soundVolume) / Math.log(MAX_VOLUME)));
    mediaPlayer.setVolume(volume, volume);

    soundVolume è il volume che si desidera impostare, tra 0 e MAX_VOLUME.
    Così tra 0 e 100 (in questo esempio.

    • che cosa è soundVolume ? Dove ha origine ?
    • Si Arriva da Qualche parte.. 😛
    • Tizio che è il volume che si desidera impostare… 😛
    • Funziona come per magia,grazie Tomasz 🙂
    • Per quelli di voi chiedendo, soundVolume è variabile tra 0 e 100 che si desidera che il volume. Se si desidera un più regolato tune, considerare la creazione maxVolume fino a 1000 e, naturalmente, mantenere il soundVolume tra 0-1000 poi.
    • +1 Funzionato come un fascino, grazie compagno.
    • Grazie @Tomasz…funziona benissimo
    • Si noti che anche se si denota un volume massimo di 100. Che questa funzione restituisce un valore compreso tra 0.0 e 1.0. Se manualmente si desidera ripristinare il volume al max si può usare mediaPlayer.setVolume(1.0, 1.0)

  3. 42

    Per Android MediaPlayer.setVolume,
    la ricerca sul web sembra mostrare 0.0f per nessun suono, 1.0f per un suono pieno.

    • Questa non è la soluzione corretta. Non scala il volume lineally. Voglio dire, il volume cresce rapidamente tra 0 e 0,5 ma molto lentamente tra 0.5 e 1.0. Controllare user100858 soluzione sotto, funziona alla grande.
    • sono corrette 🙂
    • 1.0f è per il suono pieno del flusso di volume di AudioManager. Per esempio, se il flusso di volume è impostato al 20%, il MediaPlayer volume è impostato 1.0 f, il volume sarà pari al 20% del volume massimo.
  4. 12

    Le altre risposte non sono corrette-o almeno, non sono configurati correttamente.

    Eseguire il seguente test, utilizzando il loro codice (ad esempio, Tomasz o ssuukk):

    1) situato a 100 come il “volume massimo”/numero di passi, e per presentare il volume 50.

    Restituisce: 0.150514997831991

    2) 1000 come il “volume massimo”/numero di passi, e per presentare il volume 500.

    Cosa vuol tornare? Lo stesso valore, 0.150514997831991, giusto?

    No. Invece, è: 0.100343331887994

    In altre parole, esistenti risposte modificare come si scala il volume di ingresso per cento (cioè la curva di trasformazione) in base a quanti volume-passi si imposta.

    Ho passato le ultime ore di questo problema; basta che non me la sento di andare troppo nel dettaglio spiegando il problema. Invece mi limiterò a postare il codice di grandi/blocco di commento nel mio programma riguardano. (è in C#, per Xamarin Android, ma la funzionalità dovrebbe essere lo stesso per Java)

    public enum VolumeScaleType
    {
        //Energy, //what MediaPlayer possibly treats passed values as
        Amplitude, //what MediaPlayer most likely treats passed values as
        Loudness //what people treat everyday volume values as (as in "that sounded 2 times as loud")
    }
    
    //MediaPlayer
    /*public static void SetVolume_IncorrectSOApproach(this MediaPlayer s, double volume, VolumeScaleType volumeType = VolumeScaleType.Loudness)
    {
        const int maxVolume = 100;
        var volume_toScale = volume * maxVolume;
        double volume_scalar = volumeType == VolumeScaleType.Amplitude ? volume : (1 - (Math.Log(maxVolume - volume_toScale) /Math.Log(maxVolume)));
        s.SetVolume((float)volume_scalar, (float)volume_scalar);
    }*/
    
    public static void SetVolume_MyPossiblyCorrectApproach(this MediaPlayer s, double volume, VolumeScaleType volumeType = VolumeScaleType.Loudness)
    {
        //Links:
        //1) http://en.wikipedia.org/wiki/Decibel
        //2) http://trace.wisc.edu/docs/2004-About-dB
        //3) http://hyperphysics.phy-astr.gsu.edu/hbase/sound/loud.html
        //4) http://www.animations.physics.unsw.edu.au/jw/dB.htm
        //5) http://www.soundmaskingblog.com/2012/06/saved_by_the_bell
        //6) http://www.campanellaacoustics.com/faq.html
        //7) http://physics.stackexchange.com/questions/9113/how-sound-intensity-db-and-sound-pressure-level-db-are-related
        //8) http://www.sengpielaudio.com/calculator-loudness.htm (note: page uses terms 'power/intensity' and 'pressure' differently; power/intensity: for whole shell at distance, pressure: field-quantity?)
        //basic idea: you can think of one decibel (of gain), + or -, as *translating into* the given changes-in/multipliers-for energy, amplitude, or loudness
        //(i.e. one decibel provides a specific amount to multiply energy, amplitude, and loudness values, such that they remain aligned realistically)
        //note: the 'one decibel' unit is set up to correspond roughly to a change in loudness just substantial enough to be noticeable
        //note: the 'quietest perceivable sound' example (standard) base has these absolute values: 'e' is 1 pico-watt per square-foot, 'a' is 20 micropascals, 'l' is the quietest-perceivable-loudness
    
        //references (for q.p.s. base)   | db (gain) | energy           | amplitude            | loudness
        //===============================================================================================
        //actual silence                 | -inf      | 0                | 0                    | 0
        //(a seeming silence)            | -20       | e /100          | a /10               | 0 (would be l /4, if 'l' weren't already for the quietest-perceivable-sound)
        //(a seeming silence)            | -10       | e /10           | a /3.16227/sqrt(10) | 0 (would be l /2, if 'l' weren't already for the quietest-perceivable-sound)
        //quietest perceivable sound     | 0         | e                | a                    | l
        //?                              | 1         | e * 1.258925     | a * 1.122018         | l * 1.071773
        //rustling leaves                | 10        | e * 10           | a * 3.16227/sqrt(10) | l * 2
        //whisper, or rural nighttime    | 20        | e * 100          | a * 10               | l * 4
        //watch ticking                  | 30        | e * 1000         | a * 31.622/sqrt(100) | l * 8
        //quiet speech, or rural daytime | 40        | e * 10000        | a * 100              | l * 16
        //dishwasher in next room        | 50        | e * 100000       | a * 316/sqrt(100000) | l * 32
        //ordinary conversation          | 60        | e * 1000000      | a * 1000             | l * 64
        //===============================================================================================
    
        //assuming MediaPlayer.SetVolume treats passed values as Amplitude
        Func<double, double> convertLoudnessToAmplitude = loudness=>Math.Pow(10, Math.Log(loudness, 4));
        var volume_amplitude = volumeType == VolumeScaleType.Amplitude ? volume : convertLoudnessToAmplitude(volume);
        s.SetVolume((float)volume_amplitude, (float)volume_amplitude);
        //assuming MediaPlayer.SetVolume treats passed values as Energy
        //Func<double, double> convertLoudnessToEnergy = loudness=>Math.Pow(100, Math.Log(loudness, 4));
        //var volume_energy = volumeType == VolumeScaleType.Energy ? volume : convertLoudnessToEnergy(volume);
        //s.SetVolume((float)volume_energy, (float)volume_energy);
    }

    Conclusione

    La documentazione è scarsa, quindi non posso sapere con certezza se ho il diritto di scala di sistema/tipo di unità SetVolume metodo prevede.

    Supponendo che si aspetta un valore di Ampiezza, il codice di cui sopra può essere corretta impostazione del volume del codice. (prendendo il Volume desiderato, lineare, come input e l’output di/impostazione del valore di Ampiezza necessaria per il built-in SetVolume metodo)

    Io non sono sicuro che sia corretta, però, e sono troppo stanco per confermare. Se qualcuno ha altri pensieri, sentitevi liberi di aggiungere loro. (3+ ore è sufficiente per passare su una questione come questa, in un giorno)

    Modifica

    Dopo aver ascoltato attentamente, e confrontando il volume-effetto di dissolvenza da:

    1. Solo di presentare il volume desiderato per il SetVolume metodo.
    2. Exponentiating (sostanzialmente) il desiderato-volume prima di inviarlo, per renderlo un Ampiezza (o simili) del valore che il SetVolume metodo dice che si aspetta.

    Trovo che l’opzione 1 sembra essere più vicino a un lineare volume di fade-in! In altre parole… dal fatto di ascolto e di confronto tra l’approccio di base, con la trasformazione vari approcci mostrate qui, sembra che la documentazione è sbagliato e il SetVolume metodo, infatti, basta aspettare il volume valore su una scala lineare. (forse non l’ho aggiornato a lavorare in modo più intuitivo in una delle ultime versioni di API, ma non ha aggiornato i documenti?)

    Se è così, assicurarsi che la rende facile. Che è quello che sto andando ora. (anche se mi terrò la elevamento a potenza/scala-fissaggio approccio come un programma di impostazione, suppongo, solo per avere una scusa per mantenere un certo risultato di tutto quello che il tempo investito!)

  5. 8

    Raccomandati risposta è sbagliata, come indicato Venryx. Registro la matematica non funziona in questo modo (si deve sottrarre, dividere i registri per farli lavorare come vuoi).

    Non importa, sembra che Android impostazione del Volume è ora proporzionate al Volume linearmente… così 0,5 è il 50% più forte 1.0, e da 0,1 a 10%, etc. Non sono necessarie complesse Registro di matematica per convertire i decibel di volume. Basta impostare in modo lineare, come è intuitivo per la maggior parte delle persone.

  6. 5

    Ho provato Android MediaPlayer.setVolume, ma questa funzione è inutile.

    Penso che dovremmo usare la funzione riportata di seguito

    AudioManager mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
    mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, maxVolume * mLastProgress / 10, 0);
    • Che cosa ha fatto MediaPlayer.setVolume inutile? Quello che non eri in grado di fare?
    • AudioManager imposta il volume di sistema, che non si vuole fare. Se l’utente ha il telefono in modalità silenziosa, e improvvisamente saltare fuori la musica, non apprezzo 😉
  7. 1

    Questo codice si rompe volume in 10 sezioni uguali e aumentare o diminuire il volume.

    Button decreaseVolButton = (Button) findViewById(R.id.decrease_volumn);
    Button increaseVolButton = (Button) findViewById(R.id.increase_volumn);
    
    final MediaPlayer mediaPlayer = MediaPlayer.create(MainActivity.this, R.raw.sample);
    
    decreaseVolButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            volume = (float) (volume - 0.1);
            mediaPlayer.setVolume(volume, volume);
        }
    });
    increaseVolButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            volume = (float) (volume + 0.1);
            mediaPlayer.setVolume(volume, volume);
        }
    });

    Se si desidera impostare il volume per l’audio non poi passare (0f 0f)

    Se si desidera impostare il volume del suono per poi passare (1f 1f)

  8. 1

    Tutto quello che ho visto qui ha deluso le mie aspettative. Il problema principale che ho avuto è stata che su una scala da 0 a 50, 25 non è mai stato in mezzo, ma piuttosto molto più vicino al massimo del volume. Il registro di funzioni proposte qui fatto quasi nessuna differenza per me.

    Per saperne di più sulla matematica, vedere questa risposta.

    Variabili

    Linear input value   = x      //User-specified input value
    Linear scale min,max = x1,x2  //My pre-determined range of 0-50 on my UI
    Log scale min,max    = y1,y2  //Normalizes the log result to between 0-1
    Log value result     = z      //The output to pass to the setVolume() method

    Formula in cui il cambiamento decelera come valore aumenta (forma più semplice)

    Problema con questo approccio è che questo è l’opposto di ciò che vogliamo con android, perché sembra di essere già facendo questo per impostazione predefinita. È già incremento troppo veloce quando i valori sono ancora bassi quando si passa lineare dei valori e questo accentua questo effetto ulteriormente.

    x1 + (log(x) - log(x1)) / (log(x2) - log(x1)) * (y2 - y1) = z

    I risultati di questa funzione

    Formula in cui il cambiamento accelera come valore va

    Questo è l’approccio che funziona per me, lanciando l’ingresso di mantenere lo stesso tasso di cambiamento, ma in modo inverso. Con questo, non ottenere una perfetta e la metà del volume intorno ai 25 ed è molto liscia esperienza di ascolto da 0 fino a 50.

    y2 - (x1 + (log(x2 + x1 - x) - log(x1)) / (log(x2) - log(x1)) * (y2 - y1)) = z

    I risultati di questa funzione

  9. 0

    Perché rende così complicato? Sto usando questa semplice formula:

    public float getVolume() {
        float currVolume = (float) sp.getInt("volume", 10);
        float maxVolume = 15.0f;
        float result = currVolume / maxVolume;
        return result;
    }

    e l’impostazione di questo valore nella media player, come:

    player.setVolume(getVolume(), getVolume());
    • Cosa c’è di sp in questo frammento di codice sopra? SharedPreferences?
    • MediaPlayer consiglia di documentazione: “si noti che l’superato i valori di volume sono prime scalari nel range da 0.0 a 1.0. I controlli dell’interfaccia utente dovrebbe essere in scala logaritmica.”.
    • FuzzyAmi , sì sp è condivisa preferenza.
    • dopo la divisione con volume massimo , il risultato sarà uguale o inferiore a 1,0.
    • sì, ma non su scala logaritmica 🙂 Quindi, il tuo approccio è corretto, ma non consigliato da documentazione ufficiale.
  10. 0

    Bene, ho fatto il seguente codice e leggermente opere:

    public class MainActivity extends Activity {
    
        float volumeLevel = 0.5f;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            volumeUp = findViewById(R.id.volUp);
            volumeDown = findViewById(R.id.volDown);
    
            song = MediaPlayer.create(this, R.raw.audioFile);    
    
            volumeUp.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v){
                    volumeLevel = volumeLevel + 0.1f;
                    song.setVolume(volumeLevel,volumeLevel);
                }
            });
    
            volumeDown.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    volumeLevel = volumeLevel - 0.1f;
                    song.setVolume(volumeLevel,volumeLevel);
                }
            });
        }
    }

Lascia un commento