mirror of
https://github.com/mpv-player/mpv
synced 2024-07-31 16:29:58 +02:00
157a6c1e83
The volume filter was automatically inserted if setting AO volume failed. Remove that logic, and instead enable softvol mode fully if querying current volume (which will happen before any set attempts) fails. Fully switching to softvol mode is more robust, and any case where the behavior would differ (the behavior is neither that both querying/setting always work nor that both always fail) would have been buggy.
200 lines
6.2 KiB
C
200 lines
6.2 KiB
C
/*
|
|
* This file is part of MPlayer.
|
|
*
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* MPlayer is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <string.h>
|
|
|
|
#include <libavutil/common.h>
|
|
|
|
#include "config.h"
|
|
#include "libao2/audio_out.h"
|
|
#include "libaf/af.h"
|
|
#include "mp_msg.h"
|
|
#include "mixer.h"
|
|
|
|
|
|
static void checkvolume(struct mixer *mixer)
|
|
{
|
|
if (!mixer->ao)
|
|
return;
|
|
|
|
ao_control_vol_t vol;
|
|
if (mixer->softvol || CONTROL_OK != ao_control(mixer->ao,
|
|
AOCONTROL_GET_VOLUME, &vol)) {
|
|
mixer->softvol = true;
|
|
if (!mixer->afilter)
|
|
return;
|
|
float db_vals[AF_NCH];
|
|
if (!af_control_any_rev(mixer->afilter,
|
|
AF_CONTROL_VOLUME_LEVEL | AF_CONTROL_GET, db_vals))
|
|
db_vals[0] = db_vals[1] = 1.0;
|
|
else
|
|
af_from_dB(2, db_vals, db_vals, 20.0, -200.0, 60.0);
|
|
vol.left = (db_vals[0] / (mixer->softvol_max / 100.0)) * 100.0;
|
|
vol.right = (db_vals[1] / (mixer->softvol_max / 100.0)) * 100.0;
|
|
}
|
|
float l = mixer->vol_l;
|
|
float r = mixer->vol_r;
|
|
if (mixer->muted)
|
|
l = r = 0;
|
|
/* Try to detect cases where the volume has been changed by some external
|
|
* action (such as something else changing a shared system-wide volume).
|
|
* We don't test for exact equality, as some AOs may round the value
|
|
* we last set to some nearby supported value. 3 has been the default
|
|
* volume step for increase/decrease keys, and is apparently big enough
|
|
* to step to the next possible value in most setups.
|
|
*/
|
|
if (FFABS(vol.left - l) >= 3 || FFABS(vol.right - r) >= 3) {
|
|
mixer->vol_l = vol.left;
|
|
mixer->vol_r = vol.right;
|
|
mixer->muted = false;
|
|
}
|
|
}
|
|
|
|
void mixer_getvolume(mixer_t *mixer, float *l, float *r)
|
|
{
|
|
checkvolume(mixer);
|
|
*l = mixer->vol_l;
|
|
*r = mixer->vol_r;
|
|
}
|
|
|
|
static void setvolume_internal(mixer_t *mixer, float l, float r)
|
|
{
|
|
struct ao_control_vol vol = {.left = l, .right = r};
|
|
if (!mixer->softvol) {
|
|
if (ao_control(mixer->ao, AOCONTROL_SET_VOLUME, &vol) != CONTROL_OK)
|
|
mp_tmsg(MSGT_GLOBAL, MSGL_ERR,
|
|
"[Mixer] Failed to change audio output volume.\n");
|
|
return;
|
|
}
|
|
// af_volume uses values in dB
|
|
float db_vals[AF_NCH];
|
|
int i;
|
|
db_vals[0] = (l / 100.0) * (mixer->softvol_max / 100.0);
|
|
db_vals[1] = (r / 100.0) * (mixer->softvol_max / 100.0);
|
|
for (i = 2; i < AF_NCH; i++)
|
|
db_vals[i] = ((l + r) / 100.0) * (mixer->softvol_max / 100.0) / 2.0;
|
|
af_to_dB(AF_NCH, db_vals, db_vals, 20.0);
|
|
if (!af_control_any_rev(mixer->afilter,
|
|
AF_CONTROL_VOLUME_LEVEL | AF_CONTROL_SET,
|
|
db_vals)) {
|
|
mp_tmsg(MSGT_GLOBAL, MSGL_INFO,
|
|
"[Mixer] No hardware mixing, inserting volume filter.\n");
|
|
if (!(af_add(mixer->afilter, "volume")
|
|
&& af_control_any_rev(mixer->afilter,
|
|
AF_CONTROL_VOLUME_LEVEL | AF_CONTROL_SET,
|
|
db_vals)))
|
|
mp_tmsg(MSGT_GLOBAL, MSGL_ERR,
|
|
"[Mixer] No volume control available.\n");
|
|
}
|
|
}
|
|
|
|
void mixer_setvolume(mixer_t *mixer, float l, float r)
|
|
{
|
|
checkvolume(mixer); // to check mute status and AO support for volume
|
|
mixer->vol_l = av_clip(l, 0, 100);
|
|
mixer->vol_r = av_clip(r, 0, 100);
|
|
if (!mixer->ao || mixer->muted)
|
|
return;
|
|
setvolume_internal(mixer, mixer->vol_l, mixer->vol_r);
|
|
}
|
|
|
|
void mixer_getbothvolume(mixer_t *mixer, float *b)
|
|
{
|
|
float mixer_l, mixer_r;
|
|
mixer_getvolume(mixer, &mixer_l, &mixer_r);
|
|
*b = (mixer_l + mixer_r) / 2;
|
|
}
|
|
|
|
void mixer_setmute(struct mixer *mixer, bool mute)
|
|
{
|
|
checkvolume(mixer);
|
|
if (mute != mixer->muted) {
|
|
mixer->muted = mute;
|
|
setvolume_internal(mixer, mixer->vol_l * !mute, mixer->vol_r * !mute);
|
|
}
|
|
}
|
|
|
|
bool mixer_getmute(struct mixer *mixer)
|
|
{
|
|
checkvolume(mixer);
|
|
return mixer->muted;
|
|
}
|
|
|
|
static void addvolume(struct mixer *mixer, float d)
|
|
{
|
|
checkvolume(mixer);
|
|
mixer_setvolume(mixer, mixer->vol_l + d, mixer->vol_r + d);
|
|
if (d > 0)
|
|
mixer_setmute(mixer, false);
|
|
}
|
|
|
|
void mixer_incvolume(mixer_t *mixer)
|
|
{
|
|
addvolume(mixer, mixer->volstep);
|
|
}
|
|
|
|
void mixer_decvolume(mixer_t *mixer)
|
|
{
|
|
addvolume(mixer, -mixer->volstep);
|
|
}
|
|
|
|
void mixer_getbalance(mixer_t *mixer, float *val)
|
|
{
|
|
*val = 0.f;
|
|
if (!mixer->afilter)
|
|
return;
|
|
af_control_any_rev(mixer->afilter, AF_CONTROL_PAN_BALANCE | AF_CONTROL_GET,
|
|
val);
|
|
}
|
|
|
|
void mixer_setbalance(mixer_t *mixer, float val)
|
|
{
|
|
float level[AF_NCH];
|
|
int i;
|
|
af_control_ext_t arg_ext = { .arg = level };
|
|
af_instance_t *af_pan_balance;
|
|
|
|
if (!mixer->afilter)
|
|
return;
|
|
|
|
if (af_control_any_rev(mixer->afilter,
|
|
AF_CONTROL_PAN_BALANCE | AF_CONTROL_SET, &val))
|
|
return;
|
|
|
|
if (!(af_pan_balance = af_add(mixer->afilter, "pan"))) {
|
|
mp_tmsg(MSGT_GLOBAL, MSGL_ERR,
|
|
"[Mixer] No balance control available.\n");
|
|
return;
|
|
}
|
|
|
|
af_init(mixer->afilter);
|
|
/* make all other channels pass thru since by default pan blocks all */
|
|
memset(level, 0, sizeof(level));
|
|
for (i = 2; i < AF_NCH; i++) {
|
|
arg_ext.ch = i;
|
|
level[i] = 1.f;
|
|
af_pan_balance->control(af_pan_balance,
|
|
AF_CONTROL_PAN_LEVEL | AF_CONTROL_SET,
|
|
&arg_ext);
|
|
level[i] = 0.f;
|
|
}
|
|
|
|
af_pan_balance->control(af_pan_balance,
|
|
AF_CONTROL_PAN_BALANCE | AF_CONTROL_SET, &val);
|
|
}
|