2009-01-26 16:06:44 +01:00
|
|
|
/*
|
|
|
|
* OSS audio output driver
|
|
|
|
*
|
|
|
|
* This file is part of MPlayer.
|
|
|
|
*
|
2013-10-23 19:07:27 +02:00
|
|
|
* Original author: A'rpi
|
2013-06-07 14:29:59 +02:00
|
|
|
* Support for >2 output channels added 2001-11-25
|
|
|
|
* - Steve Davies <steve@daviesfam.org>
|
|
|
|
*
|
2009-01-26 16:06:44 +01:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2001-06-03 01:25:43 +02:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
2014-09-11 01:56:20 +02:00
|
|
|
#include <poll.h>
|
2002-03-19 20:16:01 +01:00
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
2014-07-10 08:28:03 +02:00
|
|
|
#include <strings.h>
|
2001-06-03 01:25:43 +02:00
|
|
|
|
2004-12-07 03:24:15 +01:00
|
|
|
#include "config.h"
|
2013-12-17 02:02:25 +01:00
|
|
|
#include "options/options.h"
|
2013-12-17 02:39:45 +01:00
|
|
|
#include "common/msg.h"
|
2014-09-15 22:25:01 +02:00
|
|
|
#include "osdep/timer.h"
|
2014-09-23 21:04:37 +02:00
|
|
|
#include "osdep/endian.h"
|
2001-06-03 01:25:43 +02:00
|
|
|
|
2013-07-16 13:28:28 +02:00
|
|
|
#if HAVE_SYS_SOUNDCARD_H
|
2004-12-27 18:30:15 +01:00
|
|
|
#include <sys/soundcard.h>
|
|
|
|
#else
|
2013-07-16 13:28:28 +02:00
|
|
|
#if HAVE_SOUNDCARD_H
|
2004-12-27 18:30:15 +01:00
|
|
|
#include <soundcard.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2012-11-09 01:06:43 +01:00
|
|
|
#include "audio/format.h"
|
2001-08-15 19:32:47 +02:00
|
|
|
|
2012-11-09 01:06:43 +01:00
|
|
|
#include "ao.h"
|
2014-03-07 15:24:32 +01:00
|
|
|
#include "internal.h"
|
2001-06-03 01:25:43 +02:00
|
|
|
|
2014-09-15 20:37:07 +02:00
|
|
|
// Define to 0 if the device must be reopened to reset it (stop all playback,
|
|
|
|
// clear the buffer), and the device should be closed when unused.
|
|
|
|
// Define to 1 if SNDCTL_DSP_RESET should be used to reset without close.
|
|
|
|
#define KEEP_DEVICE (defined(SNDCTL_DSP_RESET) && !defined(__NetBSD__))
|
|
|
|
|
2013-06-07 15:20:07 +02:00
|
|
|
struct priv {
|
|
|
|
int audio_fd;
|
2014-09-15 22:25:01 +02:00
|
|
|
int prepause_samples;
|
2013-06-07 15:20:07 +02:00
|
|
|
int oss_mixer_channel;
|
|
|
|
int audio_delay_method;
|
2013-06-16 19:15:32 +02:00
|
|
|
int buffersize;
|
|
|
|
int outburst;
|
2014-09-15 22:25:01 +02:00
|
|
|
bool device_failed;
|
|
|
|
double audio_end;
|
2013-07-21 23:52:40 +02:00
|
|
|
|
|
|
|
char *dsp;
|
|
|
|
char *oss_mixer_device;
|
|
|
|
char *cfg_oss_mixer_channel;
|
2013-06-07 15:20:07 +02:00
|
|
|
};
|
|
|
|
|
2014-06-10 23:56:05 +02:00
|
|
|
static const char *const mixer_channels[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
|
2013-07-21 23:52:40 +02:00
|
|
|
|
2013-11-30 08:46:36 +01:00
|
|
|
/* like alsa except for 6.1 and 7.1, from pcm/matrix_map.h */
|
|
|
|
static const struct mp_chmap oss_layouts[MP_NUM_CHANNELS + 1] = {
|
|
|
|
{0}, // empty
|
|
|
|
MP_CHMAP_INIT_MONO, // mono
|
|
|
|
MP_CHMAP2(FL, FR), // stereo
|
|
|
|
MP_CHMAP3(FL, FR, LFE), // 2.1
|
|
|
|
MP_CHMAP4(FL, FR, BL, BR), // 4.0
|
|
|
|
MP_CHMAP5(FL, FR, BL, BR, FC), // 5.0
|
|
|
|
MP_CHMAP6(FL, FR, BL, BR, FC, LFE), // 5.1
|
|
|
|
MP_CHMAP7(FL, FR, BL, BR, FC, LFE, BC), // 6.1
|
|
|
|
MP_CHMAP8(FL, FR, BL, BR, FC, LFE, SL, SR), // 7.1
|
|
|
|
};
|
|
|
|
|
2014-09-23 21:04:37 +02:00
|
|
|
#if !defined(AFMT_S16_NE) && defined(AFMT_S16_LE) && defined(AFMT_S16_BE)
|
|
|
|
#define AFMT_S16_NE MP_SELECT_LE_BE(AFMT_S16_LE, AFMT_S16_BE)
|
2004-12-27 18:30:15 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
|
|
|
|
#if !defined(AFMT_U16_NE) && defined(AFMT_U16_LE) && defined(AFMT_U16_BE)
|
|
|
|
#define AFMT_U16_NE MP_SELECT_LE_BE(AFMT_U16_LE, AFMT_U16_BE)
|
2013-12-03 21:56:03 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
|
|
|
|
#if !defined(AFMT_U24_NE) && defined(AFMT_U24_LE) && defined(AFMT_U24_BE)
|
|
|
|
#define AFMT_U24_NE MP_SELECT_LE_BE(AFMT_U24_LE, AFMT_U24_BE)
|
2013-12-03 21:56:03 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
|
|
|
|
#if !defined(AFMT_S24_NE) && defined(AFMT_S24_LE) && defined(AFMT_S24_BE)
|
|
|
|
#define AFMT_S24_NE MP_SELECT_LE_BE(AFMT_S24_LE, AFMT_S24_BE)
|
2013-12-03 21:56:03 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
|
|
|
|
#if !defined(AFMT_U32_NE) && defined(AFMT_U32_LE) && defined(AFMT_U32_BE)
|
|
|
|
#define AFMT_U32MP_SELECT_LE_BE(AFMT_U32_LE, AFMT_U32_BE)
|
2013-12-03 21:56:03 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
|
|
|
|
#if !defined(AFMT_S32_NE) && defined(AFMT_S32_LE) && defined(AFMT_S32_BE)
|
|
|
|
#define AFMT_S32MP_SELECT_LE_BE(AFMT_S32_LE, AFMT_S32_BE)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const int format_table[][2] = {
|
|
|
|
{AFMT_U8, AF_FORMAT_U8},
|
|
|
|
{AFMT_S8, AF_FORMAT_S8},
|
|
|
|
{AFMT_U16_NE, AF_FORMAT_U16},
|
|
|
|
{AFMT_S16_NE, AF_FORMAT_S16},
|
|
|
|
#ifdef AFMT_U24_NE
|
|
|
|
{AFMT_U24_NE, AF_FORMAT_U24},
|
2005-01-06 14:15:53 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
#ifdef AFMT_S24_NE
|
|
|
|
{AFMT_S24_NE, AF_FORMAT_S24},
|
2005-01-06 14:15:53 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
#ifdef AFMT_U32_NE
|
|
|
|
{AFMT_U32_NE, AF_FORMAT_U32},
|
2005-01-06 14:15:53 +01:00
|
|
|
#endif
|
2014-09-23 21:04:37 +02:00
|
|
|
#ifdef AFMT_S32_NE
|
|
|
|
{AFMT_S32_NE, AF_FORMAT_S32},
|
2004-12-27 18:30:15 +01:00
|
|
|
#endif
|
|
|
|
#ifdef AFMT_FLOAT
|
2013-11-15 21:25:05 +01:00
|
|
|
{AFMT_FLOAT, AF_FORMAT_FLOAT},
|
2004-12-27 18:30:15 +01:00
|
|
|
#endif
|
2013-06-07 15:29:51 +02:00
|
|
|
{-1, -1}
|
|
|
|
};
|
|
|
|
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 22:44:54 +02:00
|
|
|
#ifndef AFMT_AC3
|
|
|
|
#define AFMT_AC3 -1
|
|
|
|
#endif
|
|
|
|
|
2013-06-07 15:29:51 +02:00
|
|
|
static int format2oss(int format)
|
|
|
|
{
|
|
|
|
for (int n = 0; format_table[n][0] != -1; n++) {
|
|
|
|
if (format_table[n][1] == format)
|
|
|
|
return format_table[n][0];
|
2004-12-27 18:30:15 +01:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int oss2format(int format)
|
|
|
|
{
|
2013-06-07 15:29:51 +02:00
|
|
|
for (int n = 0; format_table[n][0] != -1; n++) {
|
|
|
|
if (format_table[n][0] == format)
|
|
|
|
return format_table[n][1];
|
2004-12-27 18:30:15 +01:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-06-22 01:07:15 +02:00
|
|
|
|
2009-06-23 06:31:13 +02:00
|
|
|
#ifdef SNDCTL_DSP_GETPLAYVOL
|
2013-06-11 12:21:57 +02:00
|
|
|
static int volume_oss4(struct ao *ao, ao_control_vol_t *vol, int cmd)
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2013-06-11 12:21:57 +02:00
|
|
|
struct priv *p = ao->priv;
|
2009-06-23 06:31:13 +02:00
|
|
|
int v;
|
|
|
|
|
2013-06-07 15:20:07 +02:00
|
|
|
if (p->audio_fd < 0)
|
2009-06-23 06:31:13 +02:00
|
|
|
return CONTROL_ERROR;
|
|
|
|
|
|
|
|
if (cmd == AOCONTROL_GET_VOLUME) {
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_GETPLAYVOL, &v) == -1)
|
2009-06-23 06:31:13 +02:00
|
|
|
return CONTROL_ERROR;
|
|
|
|
vol->right = (v & 0xff00) >> 8;
|
|
|
|
vol->left = v & 0x00ff;
|
|
|
|
return CONTROL_OK;
|
|
|
|
} else if (cmd == AOCONTROL_SET_VOLUME) {
|
|
|
|
v = ((int) vol->right << 8) | (int) vol->left;
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_SETPLAYVOL, &v) == -1)
|
2009-06-23 06:31:13 +02:00
|
|
|
return CONTROL_ERROR;
|
|
|
|
return CONTROL_OK;
|
|
|
|
} else
|
|
|
|
return CONTROL_UNKNOWN;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-06-03 01:25:43 +02:00
|
|
|
// to set/get/query special features/parameters
|
2013-06-07 15:05:20 +02:00
|
|
|
static int control(struct ao *ao, enum aocontrol cmd, void *arg)
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2013-06-07 15:20:07 +02:00
|
|
|
struct priv *p = ao->priv;
|
2013-06-07 14:29:59 +02:00
|
|
|
switch (cmd) {
|
|
|
|
case AOCONTROL_GET_VOLUME:
|
2014-09-06 02:30:57 +02:00
|
|
|
case AOCONTROL_SET_VOLUME: {
|
2013-06-07 14:29:59 +02:00
|
|
|
ao_control_vol_t *vol = (ao_control_vol_t *)arg;
|
|
|
|
int fd, v, devs;
|
2001-08-15 13:50:55 +02:00
|
|
|
|
2009-06-23 06:31:13 +02:00
|
|
|
#ifdef SNDCTL_DSP_GETPLAYVOL
|
|
|
|
// Try OSS4 first
|
2013-06-11 12:21:57 +02:00
|
|
|
if (volume_oss4(ao, vol, cmd) == CONTROL_OK)
|
2009-06-23 06:31:13 +02:00
|
|
|
return CONTROL_OK;
|
|
|
|
#endif
|
|
|
|
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 22:44:54 +02:00
|
|
|
if (AF_FORMAT_IS_SPECIAL(ao->format))
|
2013-06-07 14:29:59 +02:00
|
|
|
return CONTROL_TRUE;
|
|
|
|
|
2013-06-07 15:20:07 +02:00
|
|
|
if ((fd = open(p->oss_mixer_device, O_RDONLY)) != -1) {
|
2013-06-07 14:29:59 +02:00
|
|
|
ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devs);
|
2013-06-07 15:20:07 +02:00
|
|
|
if (devs & (1 << p->oss_mixer_channel)) {
|
2013-06-07 14:29:59 +02:00
|
|
|
if (cmd == AOCONTROL_GET_VOLUME) {
|
2013-06-07 15:20:07 +02:00
|
|
|
ioctl(fd, MIXER_READ(p->oss_mixer_channel), &v);
|
2013-06-07 14:29:59 +02:00
|
|
|
vol->right = (v & 0xFF00) >> 8;
|
|
|
|
vol->left = v & 0x00FF;
|
|
|
|
} else {
|
|
|
|
v = ((int)vol->right << 8) | (int)vol->left;
|
2013-06-07 15:20:07 +02:00
|
|
|
ioctl(fd, MIXER_WRITE(p->oss_mixer_channel), &v);
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
close(fd);
|
|
|
|
return CONTROL_ERROR;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
return CONTROL_OK;
|
|
|
|
}
|
|
|
|
return CONTROL_ERROR;
|
2001-06-03 01:25:43 +02:00
|
|
|
}
|
2014-09-06 02:30:57 +02:00
|
|
|
#ifdef SNDCTL_DSP_GETPLAYVOL
|
|
|
|
case AOCONTROL_HAS_SOFT_VOLUME:
|
|
|
|
return CONTROL_TRUE;
|
|
|
|
#endif
|
|
|
|
}
|
2001-06-03 01:25:43 +02:00
|
|
|
return CONTROL_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2014-09-11 01:56:20 +02:00
|
|
|
// 1: ok, 0: not writable, -1: error
|
|
|
|
static int device_writable(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct priv *p = ao->priv;
|
|
|
|
struct pollfd fd = {.fd = p->audio_fd, .events = POLLOUT};
|
|
|
|
return poll(&fd, 1, 0);
|
|
|
|
}
|
|
|
|
|
2014-09-15 21:01:27 +02:00
|
|
|
static void close_device(struct ao *ao)
|
2014-09-11 02:05:12 +02:00
|
|
|
{
|
|
|
|
struct priv *p = ao->priv;
|
2014-09-15 22:25:01 +02:00
|
|
|
p->device_failed = false;
|
2014-09-11 02:05:12 +02:00
|
|
|
if (p->audio_fd == -1)
|
|
|
|
return;
|
2014-09-15 20:37:07 +02:00
|
|
|
#if defined(SNDCTL_DSP_RESET)
|
2014-09-11 02:05:12 +02:00
|
|
|
ioctl(p->audio_fd, SNDCTL_DSP_RESET, NULL);
|
|
|
|
#endif
|
|
|
|
close(p->audio_fd);
|
|
|
|
p->audio_fd = -1;
|
|
|
|
}
|
|
|
|
|
2014-09-15 21:01:27 +02:00
|
|
|
// close audio device
|
|
|
|
static void uninit(struct ao *ao)
|
|
|
|
{
|
|
|
|
close_device(ao);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int reopen_device(struct ao *ao, bool allow_format_changes)
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2013-07-21 23:52:40 +02:00
|
|
|
struct priv *p = ao->priv;
|
2013-06-07 14:29:59 +02:00
|
|
|
int oss_format;
|
2013-07-21 23:52:40 +02:00
|
|
|
|
2014-09-15 21:01:27 +02:00
|
|
|
int samplerate = ao->samplerate;
|
|
|
|
int format = ao->format;
|
|
|
|
struct mp_chmap channels = ao->channels;
|
2001-06-22 01:07:15 +02:00
|
|
|
|
2002-04-29 22:42:15 +02:00
|
|
|
#ifdef __linux__
|
2013-06-07 15:20:07 +02:00
|
|
|
p->audio_fd = open(p->dsp, O_WRONLY | O_NONBLOCK);
|
2002-04-29 22:42:15 +02:00
|
|
|
#else
|
2013-06-07 15:20:07 +02:00
|
|
|
p->audio_fd = open(p->dsp, O_WRONLY);
|
2002-04-29 22:42:15 +02:00
|
|
|
#endif
|
2013-06-07 15:20:07 +02:00
|
|
|
if (p->audio_fd < 0) {
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_ERR(ao, "Can't open audio device %s: %s\n", p->dsp, strerror(errno));
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2001-06-03 01:25:43 +02:00
|
|
|
|
2002-04-29 22:42:15 +02:00
|
|
|
#ifdef __linux__
|
2013-06-07 14:29:59 +02:00
|
|
|
/* Remove the non-blocking flag */
|
2013-06-07 15:20:07 +02:00
|
|
|
if (fcntl(p->audio_fd, F_SETFL, 0) < 0) {
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_ERR(ao, "Can't make file descriptor blocking: %s\n", strerror(errno));
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2002-04-29 22:42:15 +02:00
|
|
|
#endif
|
2002-11-28 17:14:08 +01:00
|
|
|
|
|
|
|
#if defined(FD_CLOEXEC) && defined(F_SETFD)
|
2013-06-07 15:20:07 +02:00
|
|
|
fcntl(p->audio_fd, F_SETFD, FD_CLOEXEC);
|
2002-11-28 17:14:08 +01:00
|
|
|
#endif
|
2009-07-07 01:26:13 +02:00
|
|
|
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 22:44:54 +02:00
|
|
|
if (AF_FORMAT_IS_IEC61937(format)) {
|
2014-09-15 21:01:27 +02:00
|
|
|
ioctl(p->audio_fd, SNDCTL_DSP_SPEED, &samplerate);
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2002-04-23 00:33:06 +02:00
|
|
|
|
2009-07-07 01:26:13 +02:00
|
|
|
ac3_retry:
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 22:44:54 +02:00
|
|
|
if (AF_FORMAT_IS_IEC61937(format)) {
|
|
|
|
oss_format = AFMT_AC3;
|
2014-09-23 23:34:30 +02:00
|
|
|
} else {
|
|
|
|
oss_format = format2oss(format);
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 22:44:54 +02:00
|
|
|
}
|
2013-06-07 14:29:59 +02:00
|
|
|
if (oss_format == -1) {
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_VERBOSE(ao, "Unknown/not supported internal format: %s\n",
|
2014-09-15 21:01:27 +02:00
|
|
|
af_fmt_to_str(format));
|
2013-12-03 21:43:31 +01:00
|
|
|
#if defined(AFMT_S32_LE) && defined(AFMT_S32_BE)
|
|
|
|
#if BYTE_ORDER == BIG_ENDIAN
|
|
|
|
oss_format = AFMT_S32_BE;
|
|
|
|
#else
|
|
|
|
oss_format = AFMT_S32_LE;
|
|
|
|
#endif
|
2014-09-15 21:01:27 +02:00
|
|
|
format = AF_FORMAT_S32;
|
2013-12-03 21:43:31 +01:00
|
|
|
#elif defined(AFMT_S24_LE) && defined(AFMT_S24_BE)
|
|
|
|
#if BYTE_ORDER == BIG_ENDIAN
|
|
|
|
oss_format = AFMT_S24_BE;
|
|
|
|
#else
|
|
|
|
oss_format = AFMT_S24_LE;
|
|
|
|
#endif
|
2014-09-15 21:01:27 +02:00
|
|
|
format = AF_FORMAT_S24;
|
2013-12-03 21:43:31 +01:00
|
|
|
#else
|
Remove compile time/runtime CPU detection, and drop some platforms
mplayer had three ways of enabling CPU specific assembler routines:
a) Enable them at compile time; crash if the CPU can't handle it.
b) Enable them at compile time, but let the configure script detect
your CPU. Your binary will only crash if you try to run it on a
different system that has less features than yours.
This was the default, I think.
c) Runtime detection.
The implementation of b) and c) suck. a) is not really feasible (it
sucks for users). Remove all code related to this, and use libav's CPU
detection instead. Now the configure script will always enable CPU
specific features, and disable them at runtime if libav reports them
not as available.
One implication is that now the compiler is always expected to handle
SSE (etc.) inline assembly at runtime, unless it's explicitly disabled.
Only checks for x86 CPU specific features are kept, the rest is either
unused or barely used.
Get rid of all the dump -mpcu, -march etc. flags. Trust the compiler
to select decent settings.
Get rid of support for the following operating systems:
- BSD/OS (some ancient BSD fork)
- QNX (don't care)
- BeOS (dead, Haiku support is still welcome)
- AIX (don't care)
- HP-UX (don't care)
- OS/2 (dead, actual support has been removed a while ago)
Remove the configure code for detecting the endianness. Instead, use
the standard header <endian.h>, which can be used if _GNU_SOURCE or
_BSD_SOURCE is defined. (Maybe these changes should have been in a
separate commit.)
Since this is a quite violent code removal orgy, and I'm testing only
on x86 32 bit Linux, expect regressions.
2012-07-29 17:20:57 +02:00
|
|
|
#if BYTE_ORDER == BIG_ENDIAN
|
2013-06-07 14:29:59 +02:00
|
|
|
oss_format = AFMT_S16_BE;
|
2004-12-28 02:59:12 +01:00
|
|
|
#else
|
2013-06-07 14:29:59 +02:00
|
|
|
oss_format = AFMT_S16_LE;
|
2004-12-28 02:59:12 +01:00
|
|
|
#endif
|
2014-09-15 21:01:27 +02:00
|
|
|
format = AF_FORMAT_S16;
|
2013-12-03 21:43:31 +01:00
|
|
|
#endif
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_SETFMT, &oss_format) < 0 ||
|
2014-09-15 21:01:27 +02:00
|
|
|
oss_format != format2oss(format))
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_WARN(ao, "Can't set audio device %s to %s output, trying %s...\n",
|
2014-09-15 21:01:27 +02:00
|
|
|
p->dsp, af_fmt_to_str(format),
|
2013-11-15 21:25:05 +01:00
|
|
|
af_fmt_to_str(AF_FORMAT_S16));
|
2014-09-15 21:01:27 +02:00
|
|
|
format = AF_FORMAT_S16;
|
2013-06-07 14:29:59 +02:00
|
|
|
goto ac3_retry;
|
2001-11-28 13:46:23 +01:00
|
|
|
}
|
2013-06-07 14:29:59 +02:00
|
|
|
|
2014-09-15 21:01:27 +02:00
|
|
|
format = oss2format(oss_format);
|
|
|
|
if (format == -1) {
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_ERR(ao, "Unknown/Unsupported OSS format: %x.\n", oss_format);
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-08-23 23:30:09 +02:00
|
|
|
}
|
2013-06-07 14:29:59 +02:00
|
|
|
|
2014-09-15 21:01:27 +02:00
|
|
|
MP_VERBOSE(ao, "sample format: %s\n", af_fmt_to_str(format));
|
2013-06-07 14:29:59 +02:00
|
|
|
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 22:44:54 +02:00
|
|
|
if (!AF_FORMAT_IS_IEC61937(format)) {
|
2013-06-07 14:29:59 +02:00
|
|
|
struct mp_chmap_sel sel = {0};
|
2013-11-30 08:46:36 +01:00
|
|
|
for (int n = 0; n < MP_NUM_CHANNELS + 1; n++)
|
|
|
|
mp_chmap_sel_add_map(&sel, &oss_layouts[n]);
|
2014-09-15 21:01:27 +02:00
|
|
|
if (!ao_chmap_sel_adjust(ao, &sel, &channels))
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2014-09-15 21:01:27 +02:00
|
|
|
int reqchannels = channels.num;
|
2013-06-07 14:29:59 +02:00
|
|
|
// We only use SNDCTL_DSP_CHANNELS for >2 channels, in case some drivers don't have it
|
|
|
|
if (reqchannels > 2) {
|
|
|
|
int nchannels = reqchannels;
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_CHANNELS, &nchannels) == -1 ||
|
2013-06-07 14:29:59 +02:00
|
|
|
nchannels != reqchannels)
|
|
|
|
{
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_ERR(ao, "Failed to set audio device to %d channels.\n",
|
|
|
|
reqchannels);
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
int c = reqchannels - 1;
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_STEREO, &c) == -1) {
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_ERR(ao, "Failed to set audio device to %d channels.\n",
|
|
|
|
reqchannels);
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2014-09-15 21:01:27 +02:00
|
|
|
if (!ao_chmap_sel_get_def(ao, &sel, &channels, c + 1))
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_VERBOSE(ao, "using %d channels (requested: %d)\n",
|
2014-09-15 21:01:27 +02:00
|
|
|
channels.num, reqchannels);
|
2013-06-07 14:29:59 +02:00
|
|
|
// set rate
|
2014-09-15 21:01:27 +02:00
|
|
|
ioctl(p->audio_fd, SNDCTL_DSP_SPEED, &samplerate);
|
|
|
|
MP_VERBOSE(ao, "using %d Hz samplerate\n", samplerate);
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
|
|
|
|
2014-09-15 21:22:02 +02:00
|
|
|
audio_buf_info zz = {0};
|
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_GETOSPACE, &zz) == -1) {
|
2013-06-07 14:29:59 +02:00
|
|
|
int r = 0;
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_WARN(ao, "driver doesn't support SNDCTL_DSP_GETOSPACE\n");
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_GETBLKSIZE, &r) == -1)
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_VERBOSE(ao, "%d bytes/frag (config.h)\n", p->outburst);
|
2013-06-07 14:29:59 +02:00
|
|
|
else {
|
2013-06-16 19:15:32 +02:00
|
|
|
p->outburst = r;
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_VERBOSE(ao, "%d bytes/frag (GETBLKSIZE)\n", p->outburst);
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
|
|
|
} else {
|
2013-08-23 23:30:09 +02:00
|
|
|
MP_VERBOSE(ao, "frags: %3d/%d (%d bytes/frag) free: %6d\n",
|
2014-09-15 21:22:02 +02:00
|
|
|
zz.fragments, zz.fragstotal, zz.fragsize, zz.bytes);
|
|
|
|
p->buffersize = zz.bytes;
|
|
|
|
p->outburst = zz.fragsize;
|
2001-11-28 13:46:23 +01:00
|
|
|
}
|
2013-06-07 14:29:59 +02:00
|
|
|
|
2014-09-15 21:01:27 +02:00
|
|
|
if (allow_format_changes) {
|
|
|
|
ao->format = format;
|
|
|
|
ao->samplerate = samplerate;
|
|
|
|
ao->channels = channels;
|
|
|
|
} else {
|
|
|
|
if (format != ao->format || samplerate != ao->samplerate ||
|
|
|
|
!mp_chmap_equals(&channels, &ao->channels))
|
|
|
|
{
|
|
|
|
MP_ERR(ao, "Could not reselect previous audio format.\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
p->outburst -= p->outburst % (channels.num * af_fmt2bps(format)); // round down
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
close_device(ao);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// open & setup audio device
|
|
|
|
// return: 0=success -1=fail
|
|
|
|
static int init(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct priv *p = ao->priv;
|
|
|
|
|
|
|
|
const char *mchan = NULL;
|
|
|
|
if (p->cfg_oss_mixer_channel && p->cfg_oss_mixer_channel[0])
|
|
|
|
mchan = p->cfg_oss_mixer_channel;
|
|
|
|
|
|
|
|
if (mchan) {
|
|
|
|
int fd, devs, i;
|
|
|
|
|
|
|
|
if ((fd = open(p->oss_mixer_device, O_RDONLY)) == -1) {
|
|
|
|
MP_ERR(ao, "Can't open mixer device %s: %s\n",
|
|
|
|
p->oss_mixer_device, strerror(errno));
|
|
|
|
} else {
|
|
|
|
ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devs);
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
|
|
|
|
if (!strcasecmp(mixer_channels[i], mchan)) {
|
|
|
|
if (!(devs & (1 << i))) {
|
|
|
|
MP_ERR(ao, "Audio card mixer does not have "
|
|
|
|
"channel '%s', using default.\n", mchan);
|
|
|
|
i = SOUND_MIXER_NRDEVICES + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p->oss_mixer_channel = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i == SOUND_MIXER_NRDEVICES) {
|
|
|
|
MP_ERR(ao, "Audio card mixer does not have "
|
|
|
|
"channel '%s', using default.\n", mchan);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
p->oss_mixer_channel = SOUND_MIXER_PCM;
|
|
|
|
}
|
|
|
|
|
|
|
|
MP_VERBOSE(ao, "using '%s' dsp device\n", p->dsp);
|
|
|
|
MP_VERBOSE(ao, "using '%s' mixer device\n", p->oss_mixer_device);
|
|
|
|
MP_VERBOSE(ao, "using '%s' mixer device\n", mixer_channels[p->oss_mixer_channel]);
|
|
|
|
|
|
|
|
ao->format = af_fmt_from_planar(ao->format);
|
|
|
|
|
|
|
|
if (reopen_device(ao, true) < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2013-06-16 19:15:32 +02:00
|
|
|
if (p->buffersize == -1) {
|
2013-06-07 14:29:59 +02:00
|
|
|
// Measuring buffer size:
|
2014-09-11 01:56:20 +02:00
|
|
|
void *data = malloc(p->outburst);
|
|
|
|
if (!data) {
|
|
|
|
MP_ERR(ao, "Out of memory, or broken outburst size.\n");
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2014-09-11 01:56:20 +02:00
|
|
|
}
|
2013-06-16 19:15:32 +02:00
|
|
|
p->buffersize = 0;
|
|
|
|
memset(data, 0, p->outburst);
|
2014-09-11 01:56:20 +02:00
|
|
|
while (p->buffersize < 0x40000 && device_writable(ao) > 0) {
|
2013-06-16 19:15:32 +02:00
|
|
|
write(p->audio_fd, data, p->outburst);
|
|
|
|
p->buffersize += p->outburst;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
|
|
|
free(data);
|
2013-06-16 19:15:32 +02:00
|
|
|
if (p->buffersize == 0) {
|
2014-09-11 01:56:20 +02:00
|
|
|
MP_ERR(ao, "Your OSS audio driver DOES NOT support poll().\n");
|
2014-09-11 02:05:12 +02:00
|
|
|
goto fail;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2001-06-03 01:25:43 +02:00
|
|
|
}
|
2013-06-07 14:29:59 +02:00
|
|
|
|
2013-06-07 15:05:20 +02:00
|
|
|
return 0;
|
2001-06-03 01:25:43 +02:00
|
|
|
|
2014-09-11 02:05:12 +02:00
|
|
|
fail:
|
|
|
|
uninit(ao);
|
|
|
|
return -1;
|
2013-06-07 15:20:07 +02:00
|
|
|
}
|
|
|
|
|
2014-03-09 00:49:39 +01:00
|
|
|
static void drain(struct ao *ao)
|
|
|
|
{
|
|
|
|
#ifdef SNDCTL_DSP_SYNC
|
|
|
|
struct priv *p = ao->priv;
|
|
|
|
// to get the buffer played
|
|
|
|
if (p->audio_fd != -1)
|
|
|
|
ioctl(p->audio_fd, SNDCTL_DSP_SYNC, NULL);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2001-06-03 01:25:43 +02:00
|
|
|
// stop playing and empty buffers (for seeking/pause)
|
2013-06-07 15:05:20 +02:00
|
|
|
static void reset(struct ao *ao)
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2014-09-15 20:37:07 +02:00
|
|
|
#if KEEP_DEVICE
|
2014-09-15 21:01:27 +02:00
|
|
|
struct priv *p = ao->priv;
|
2013-11-04 21:54:11 +01:00
|
|
|
ioctl(p->audio_fd, SNDCTL_DSP_RESET, NULL);
|
|
|
|
#else
|
2013-06-07 15:20:07 +02:00
|
|
|
close_device(ao);
|
2014-09-15 20:40:30 +02:00
|
|
|
#endif
|
2001-06-05 20:40:44 +02:00
|
|
|
}
|
|
|
|
|
2014-09-15 20:22:12 +02:00
|
|
|
// plays 'len' samples of 'data'
|
2001-06-03 01:25:43 +02:00
|
|
|
// it should round it down to outburst*n
|
2014-09-15 20:22:12 +02:00
|
|
|
// return: number of samples played
|
2013-11-10 23:24:21 +01:00
|
|
|
static int play(struct ao *ao, void **data, int samples, int flags)
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2013-06-07 15:20:07 +02:00
|
|
|
struct priv *p = ao->priv;
|
2013-11-10 23:24:21 +01:00
|
|
|
int len = samples * ao->sstride;
|
2013-06-07 14:29:59 +02:00
|
|
|
if (len == 0)
|
2006-06-28 21:22:27 +02:00
|
|
|
return len;
|
2014-09-15 22:25:01 +02:00
|
|
|
|
|
|
|
if (p->audio_fd < 0 && !p->device_failed && reopen_device(ao, false) < 0)
|
|
|
|
MP_ERR(ao, "Fatal error: *** CANNOT RE-OPEN / RESET AUDIO DEVICE ***\n");
|
|
|
|
if (p->audio_fd < 0) {
|
|
|
|
// Let playback continue normally, even with a closed device.
|
|
|
|
p->device_failed = true;
|
|
|
|
double now = mp_time_sec();
|
|
|
|
if (p->audio_end < now)
|
|
|
|
p->audio_end = now;
|
|
|
|
p->audio_end += samples / (double)ao->samplerate;
|
|
|
|
return samples;
|
|
|
|
}
|
|
|
|
|
2013-06-16 19:15:32 +02:00
|
|
|
if (len > p->outburst || !(flags & AOPLAY_FINAL_CHUNK)) {
|
|
|
|
len /= p->outburst;
|
|
|
|
len *= p->outburst;
|
2006-06-28 21:22:27 +02:00
|
|
|
}
|
2013-11-10 23:24:21 +01:00
|
|
|
len = write(p->audio_fd, data[0], len);
|
|
|
|
return len / ao->sstride;
|
2001-06-03 01:25:43 +02:00
|
|
|
}
|
|
|
|
|
2001-11-24 06:21:22 +01:00
|
|
|
// return: delay in seconds between first and last sample in buffer
|
2013-06-07 15:05:20 +02:00
|
|
|
static float get_delay(struct ao *ao)
|
2013-06-07 14:29:59 +02:00
|
|
|
{
|
2013-06-07 15:20:07 +02:00
|
|
|
struct priv *p = ao->priv;
|
2014-09-15 22:25:01 +02:00
|
|
|
if (p->audio_fd < 0) {
|
|
|
|
double rest = p->audio_end - mp_time_sec();
|
|
|
|
if (rest > 0)
|
|
|
|
return rest;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-06-07 14:29:59 +02:00
|
|
|
/* Calculate how many bytes/second is sent out */
|
2013-06-07 15:20:07 +02:00
|
|
|
if (p->audio_delay_method == 2) {
|
2002-04-28 00:42:27 +02:00
|
|
|
#ifdef SNDCTL_DSP_GETODELAY
|
2013-06-07 14:29:59 +02:00
|
|
|
int r = 0;
|
2013-06-07 15:20:07 +02:00
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_GETODELAY, &r) != -1)
|
2013-06-07 15:05:20 +02:00
|
|
|
return ((float)r) / (float)ao->bps;
|
2002-04-28 00:42:27 +02:00
|
|
|
#endif
|
2013-06-07 15:20:07 +02:00
|
|
|
p->audio_delay_method = 1; // fallback if not supported
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2013-06-07 15:20:07 +02:00
|
|
|
if (p->audio_delay_method == 1) {
|
2014-09-15 21:22:02 +02:00
|
|
|
audio_buf_info zz = {0};
|
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_GETOSPACE, &zz) != -1) {
|
|
|
|
return ((float)(p->buffersize - zz.bytes)) / (float)ao->bps;
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2013-06-07 15:20:07 +02:00
|
|
|
p->audio_delay_method = 0; // fallback if not supported
|
2013-06-07 14:29:59 +02:00
|
|
|
}
|
2013-06-16 19:15:32 +02:00
|
|
|
return ((float)p->buffersize) / (float)ao->bps;
|
2001-06-03 01:25:43 +02:00
|
|
|
}
|
2013-06-07 15:05:20 +02:00
|
|
|
|
2014-09-17 00:14:21 +02:00
|
|
|
|
|
|
|
// return: how many samples can be played without blocking
|
|
|
|
static int get_space(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct priv *p = ao->priv;
|
|
|
|
|
|
|
|
audio_buf_info zz = {0};
|
|
|
|
if (ioctl(p->audio_fd, SNDCTL_DSP_GETOSPACE, &zz) != -1) {
|
|
|
|
// calculate exact buffer space:
|
|
|
|
return zz.fragments * zz.fragsize / ao->sstride;
|
|
|
|
}
|
|
|
|
|
2014-09-17 00:20:20 +02:00
|
|
|
if (p->audio_fd < 0 && p->device_failed && get_delay(ao) > 0.2)
|
|
|
|
return 0;
|
|
|
|
|
2014-09-17 00:14:21 +02:00
|
|
|
if (p->audio_fd < 0 || device_writable(ao) > 0)
|
|
|
|
return p->outburst / ao->sstride;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-15 22:25:01 +02:00
|
|
|
// stop playing, keep buffers (for pause)
|
|
|
|
static void audio_pause(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct priv *p = ao->priv;
|
|
|
|
p->prepause_samples = get_delay(ao) * ao->samplerate;
|
|
|
|
#if KEEP_DEVICE
|
|
|
|
ioctl(p->audio_fd, SNDCTL_DSP_RESET, NULL);
|
|
|
|
#else
|
|
|
|
close_device(ao);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-09-17 00:14:21 +02:00
|
|
|
// resume playing, after audio_pause()
|
|
|
|
static void audio_resume(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct priv *p = ao->priv;
|
|
|
|
p->audio_end = 0;
|
|
|
|
if (p->prepause_samples > 0)
|
|
|
|
ao_play_silence(ao, p->prepause_samples);
|
|
|
|
}
|
|
|
|
|
2013-07-21 23:52:40 +02:00
|
|
|
#define OPT_BASE_STRUCT struct priv
|
|
|
|
|
2013-06-07 15:05:20 +02:00
|
|
|
const struct ao_driver audio_out_oss = {
|
2013-10-23 19:07:27 +02:00
|
|
|
.description = "OSS/ioctl audio output",
|
|
|
|
.name = "oss",
|
2013-06-07 15:05:20 +02:00
|
|
|
.init = init,
|
|
|
|
.uninit = uninit,
|
|
|
|
.control = control,
|
|
|
|
.get_space = get_space,
|
|
|
|
.play = play,
|
|
|
|
.get_delay = get_delay,
|
|
|
|
.pause = audio_pause,
|
|
|
|
.resume = audio_resume,
|
|
|
|
.reset = reset,
|
2014-03-09 00:49:39 +01:00
|
|
|
.drain = drain,
|
2013-07-21 23:52:40 +02:00
|
|
|
.priv_size = sizeof(struct priv),
|
|
|
|
.priv_defaults = &(const struct priv) {
|
|
|
|
.audio_fd = -1,
|
|
|
|
.audio_delay_method = 2,
|
|
|
|
.buffersize = -1,
|
|
|
|
.outburst = 512,
|
|
|
|
.oss_mixer_channel = SOUND_MIXER_PCM,
|
|
|
|
|
|
|
|
.dsp = PATH_DEV_DSP,
|
|
|
|
.oss_mixer_device = PATH_DEV_MIXER,
|
|
|
|
},
|
|
|
|
.options = (const struct m_option[]) {
|
|
|
|
OPT_STRING("device", dsp, 0),
|
|
|
|
OPT_STRING("mixer-device", oss_mixer_device, 0),
|
|
|
|
OPT_STRING("mixer-channel", cfg_oss_mixer_channel, 0),
|
|
|
|
{0}
|
|
|
|
},
|
2013-06-07 15:05:20 +02:00
|
|
|
};
|