Merge branch 'audio_changes'

Conflicts:
	audio/out/ao_lavc.c

62 files changed, 3143 insertions, 3498 deletions

diff --git a/audio/audio.c b/audio/audio.c
new file mode 100644
index 0000000000..c9d5c9231c
--- /dev/null
+++ b/audio/audio.c
@@ -0,0 +1,76 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+
+#include "core/mp_talloc.h"
+#include "audio.h"
+
+void mp_audio_set_format(struct mp_audio *mpa, int format)
+{
+    mpa->format = format;
+    mpa->bps = af_fmt2bits(format) / 8;
+}
+
+void mp_audio_set_num_channels(struct mp_audio *mpa, int num_channels)
+{
+    struct mp_chmap map;
+    mp_chmap_from_channels(&map, num_channels);
+    mp_audio_set_channels(mpa, &map);
+}
+
+// Use old MPlayer/ALSA channel layout.
+void mp_audio_set_channels_old(struct mp_audio *mpa, int num_channels)
+{
+    struct mp_chmap map;
+    mp_chmap_from_channels_alsa(&map, num_channels);
+    mp_audio_set_channels(mpa, &map);
+}
+
+void mp_audio_set_channels(struct mp_audio *mpa, const struct mp_chmap *chmap)
+{
+    assert(mp_chmap_is_empty(chmap) || mp_chmap_is_valid(chmap));
+    mpa->channels = *chmap;
+    mpa->nch = mpa->channels.num;
+}
+
+void mp_audio_copy_config(struct mp_audio *dst, const struct mp_audio *src)
+{
+    mp_audio_set_format(dst, src->format);
+    mp_audio_set_channels(dst, &src->channels);
+    dst->rate = src->rate;
+}
+
+bool mp_audio_config_equals(const struct mp_audio *a, const struct mp_audio *b)
+{
+    return a->format == b->format && a->rate == b->rate &&
+           mp_chmap_equals(&a->channels, &b->channels);
+}
+
+char *mp_audio_fmt_to_str(int srate, const struct mp_chmap *chmap, int format)
+{
+    char *chstr = mp_chmap_to_str(chmap);
+    char *res = talloc_asprintf(NULL, "%dHz %s %dch %s", srate, chstr,
+                                chmap->num, af_fmt2str_short(format));
+    talloc_free(chstr);
+    return res;
+}
+
+char *mp_audio_config_to_str(struct mp_audio *mpa)
+{
+    return mp_audio_fmt_to_str(mpa->rate, &mpa->channels, mpa->format);
+}
diff --git a/audio/audio.h b/audio/audio.h
new file mode 100644
index 0000000000..de35e697c8
--- /dev/null
+++ b/audio/audio.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MP_AUDIO_H
+#define MP_AUDIO_H
+
+#include "format.h"
+#include "chmap.h"
+
+// Audio data chunk
+struct mp_audio {
+    void *audio; // data buffer
+    int len;    // buffer length (in bytes)
+    int rate;   // sample rate
+    struct mp_chmap channels; // channel layout, use mp_audio_set_*() to set
+    int format; // format (AF_FORMAT_...), use mp_audio_set_format() to set
+    // Redundant fields, for convenience
+    int nch;    // number of channels (redundant with chmap)
+    int bps;    // bytes per sample (redundant with format)
+};
+
+void mp_audio_set_format(struct mp_audio *mpa, int format);
+void mp_audio_set_num_channels(struct mp_audio *mpa, int num_channels);
+void mp_audio_set_channels_old(struct mp_audio *mpa, int num_channels);
+void mp_audio_set_channels(struct mp_audio *mpa, const struct mp_chmap *chmap);
+void mp_audio_copy_config(struct mp_audio *dst, const struct mp_audio *src);
+bool mp_audio_config_equals(const struct mp_audio *a, const struct mp_audio *b);
+
+char *mp_audio_fmt_to_str(int srate, const struct mp_chmap *chmap, int format);
+char *mp_audio_config_to_str(struct mp_audio *mpa);
+
+#endif
diff --git a/audio/chmap.c b/audio/chmap.c
new file mode 100644
index 0000000000..fcdb95edb3
--- /dev/null
+++ b/audio/chmap.c
@@ -0,0 +1,486 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include "core/mp_msg.h"
+#include "chmap.h"
+
+// Names taken from libavutil/channel_layout.c (Not accessible by API.)
+// Use of these names is hard-coded in some places (e.g. ao_alsa.c)
+static const char *speaker_names[MP_SPEAKER_ID_COUNT][2] = {
+    [MP_SPEAKER_ID_FL]          = {"fl",   "front left"},
+    [MP_SPEAKER_ID_FR]          = {"fr",   "front right"},
+    [MP_SPEAKER_ID_FC]          = {"fc",   "front center"},
+    [MP_SPEAKER_ID_LFE]         = {"lfe",  "low frequency"},
+    [MP_SPEAKER_ID_BL]          = {"bl",   "back left"},
+    [MP_SPEAKER_ID_BR]          = {"br",   "back right"},
+    [MP_SPEAKER_ID_FLC]         = {"flc",  "front left-of-center"},
+    [MP_SPEAKER_ID_FRC]         = {"frc",  "front right-of-center"},
+    [MP_SPEAKER_ID_BC]          = {"bc",   "back center"},
+    [MP_SPEAKER_ID_SL]          = {"sl",   "side left"},
+    [MP_SPEAKER_ID_SR]          = {"sr",   "side right"},
+    [MP_SPEAKER_ID_TC]          = {"tc",   "top center"},
+    [MP_SPEAKER_ID_TFL]         = {"tfl",  "top front left"},
+    [MP_SPEAKER_ID_TFC]         = {"tfc",  "top front center"},
+    [MP_SPEAKER_ID_TFR]         = {"tfr",  "top front right"},
+    [MP_SPEAKER_ID_TBL]         = {"tbl",  "top back left"},
+    [MP_SPEAKER_ID_TBC]         = {"tbc",  "top back center"},
+    [MP_SPEAKER_ID_TBR]         = {"tbr",  "top back right"},
+    [MP_SPEAKER_ID_DL]          = {"dl",   "downmix left"},
+    [MP_SPEAKER_ID_DR]          = {"dr",   "downmix right"},
+    [MP_SPEAKER_ID_WL]          = {"wl",   "wide left"},
+    [MP_SPEAKER_ID_WR]          = {"wr",   "wide right"},
+    [MP_SPEAKER_ID_SDL]         = {"sdl",  "surround direct left"},
+    [MP_SPEAKER_ID_SDR]         = {"sdr",  "surround direct right"},
+    [MP_SPEAKER_ID_LFE2]        = {"lfe2", "low frequency 2"},
+};
+
+// Names taken from libavutil/channel_layout.c (Not accessible by API.)
+// Channel order corresponds to lavc/waveex, except for the alsa entries.
+static const char *std_layout_names[][2] = {
+    {"empty",           ""}, // not in lavc
+    {"mono",            "fc"},
+    {"stereo",          "fl-fr"},
+    {"2.1",             "fl-fr-lfe"},
+    {"3.0",             "fl-fr-fc"},
+    {"3.0(back)",       "fl-fr-bc"},
+    {"4.0",             "fl-fr-fc-bc"},
+    {"quad",            "fl-fr-bl-br"},
+    {"quad(side)",      "fl-fr-sl-sr"},
+    {"3.1",             "fl-fr-fc-lfe"},
+    {"5.0",             "fl-fr-fc-bl-br"},
+    {"5.0(alsa)",       "fl-fr-bl-br-fc"}, // not in lavc
+    {"5.0(side)",       "fl-fr-fc-sl-sr"},
+    {"4.1",             "fl-fr-fc-lfe-bc"},
+    {"4.1(alsa)",       "fl-fr-bl-br-lfe"}, // not in lavc
+    {"5.1",             "fl-fr-fc-lfe-bl-br"},
+    {"5.1(alsa)",       "fl-fr-bl-br-fc-lfe"}, // not in lavc
+    {"5.1(side)",       "fl-fr-fc-lfe-sl-sr"},
+    {"6.0",             "fl-fr-fc-bc-sl-sr"},
+    {"6.0(front)",      "fl-fr-flc-frc-sl-sr"},
+    {"hexagonal",       "fl-fr-fc-bl-br-bc"},
+    {"6.1",             "fl-fr-fc-lfe-bl-br-bc"},
+    {"6.1(front)",      "fl-fr-lfe-flc-frc-sl-sr"},
+    {"7.0",             "fl-fr-fc-bl-br-sl-sr"},
+    {"7.0(front)",      "fl-fr-fc-flc-frc-sl-sr"},
+    {"7.1",             "fl-fr-fc-lfe-bl-br-sl-sr"},
+    {"7.1(alsa)",       "fl-fr-bl-br-fc-lfe-sl-sr"}, // not in lavc
+    {"7.1(wide)",       "fl-fr-fc-lfe-bl-br-flc-frc"},
+    {"7.1(wide-side)",  "fl-fr-fc-lfe-flc-frc-sl-sr"},
+    {"octagonal",       "fl-fr-fc-bl-br-bc-sl-sr"},
+    {"downmix",         "dl-dr"},
+    {0}
+};
+
+static const struct mp_chmap default_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, FC, BC),                  // 4.0
+    MP_CHMAP5(FL, FR, FC, BL,  BR),             // 5.0
+    MP_CHMAP6(FL, FR, FC, LFE, BL, BR),         // 5.1
+    MP_CHMAP7(FL, FR, FC, LFE, BL, BR, BC),     // 6.1
+    MP_CHMAP8(FL, FR, FC, LFE, BL, BR, SL, SR), // 7.1
+};
+
+// The channel order was lavc/waveex, but differs from lavc for 5, 6 and 8
+// channels. 3 and 7 channels were likely undefined (no ALSA support).
+static const char *mplayer_layouts[MP_NUM_CHANNELS + 1] = {
+    [1] = "mono",
+    [2] = "stereo",
+    [4] = "4.0",
+    [5] = "5.0(alsa)",
+    [6] = "5.1(alsa)",
+    [8] = "7.1(alsa)",
+};
+
+// Returns true if speakers are mapped uniquely, and there's at least 1 channel.
+bool mp_chmap_is_valid(const struct mp_chmap *src)
+{
+    bool mapped[MP_SPEAKER_ID_COUNT] = {0};
+    for (int n = 0; n < src->num; n++) {
+        int sp = src->speaker[n];
+        if (sp >= MP_SPEAKER_ID_COUNT || mapped[sp])
+            return false;
+        mapped[sp] = true;
+    }
+    return src->num > 0;
+}
+
+bool mp_chmap_is_empty(const struct mp_chmap *src)
+{
+    return src->num == 0;
+}
+
+// Return true if the channel map defines the number of the channels only, and
+// the channels have to meaning associated with them.
+bool mp_chmap_is_unknown(const struct mp_chmap *src)
+{
+    for (int n = 0; n < src->num; n++) {
+        int speaker = src->speaker[n];
+        if (speaker >= MP_SPEAKER_ID_UNKNOWN0 &&
+            speaker <= MP_SPEAKER_ID_UNKNOWN_LAST)
+            return true;
+    }
+    return false;
+}
+
+// Note: empty channel maps compare as equal. Invalid ones can equal too.
+bool mp_chmap_equals(const struct mp_chmap *a, const struct mp_chmap *b)
+{
+    if (a->num != b->num)
+        return false;
+    for (int n = 0; n < a->num; n++) {
+        if (a->speaker[n] != b->speaker[n])
+            return false;
+    }
+    return true;
+}
+
+// Whether they use the same speakers (even if in different order).
+bool mp_chmap_equals_reordered(const struct mp_chmap *a, const struct mp_chmap *b)
+{
+    struct mp_chmap t1 = *a, t2 = *b;
+    mp_chmap_reorder_norm(&t1);
+    mp_chmap_reorder_norm(&t2);
+    return mp_chmap_equals(&t1, &t2);
+}
+
+bool mp_chmap_is_compatible(const struct mp_chmap *a, const struct mp_chmap *b)
+{
+    if (mp_chmap_equals(a, b))
+        return true;
+    if (a->num == b->num && (mp_chmap_is_unknown(a) || mp_chmap_is_unknown(b)))
+        return true;
+    return false;
+}
+
+bool mp_chmap_is_stereo(const struct mp_chmap *src)
+{
+    static const struct mp_chmap stereo = MP_CHMAP_INIT_STEREO;
+    return mp_chmap_equals(src, &stereo);
+}
+
+static int comp_uint8(const void *a, const void *b)
+{
+    return *(const uint8_t *)a - *(const uint8_t *)b;
+}
+
+// Reorder channels to normal order, with monotonically increasing speaker IDs.
+// We define this order as the same order used with waveex.
+void mp_chmap_reorder_norm(struct mp_chmap *map)
+{
+    uint8_t *arr = &map->speaker[0];
+    qsort(arr, map->num, 1, comp_uint8);
+}
+
+// Set *dst to a standard layout with the given number of channels.
+// If the number of channels is invalid, an invalid map is set, and
+// mp_chmap_is_valid(dst) will return false.
+void mp_chmap_from_channels(struct mp_chmap *dst, int num_channels)
+{
+    if (num_channels < 0 || num_channels > MP_NUM_CHANNELS) {
+        *dst = (struct mp_chmap) {0};
+    } else {
+        *dst = default_layouts[num_channels];
+    }
+}
+
+// Try to do what mplayer/mplayer2/mpv did before channel layouts were
+// introduced, i.e. get the old default channel order.
+void mp_chmap_from_channels_alsa(struct mp_chmap *dst, int num_channels)
+{
+    if (num_channels < 0 || num_channels > MP_NUM_CHANNELS) {
+        *dst = (struct mp_chmap) {0};
+    } else {
+        mp_chmap_from_str(dst, bstr0(mplayer_layouts[num_channels]));
+        if (!dst->num)
+            mp_chmap_from_channels(dst, num_channels);
+    }
+}
+
+// Set *dst to an unknown layout for the given numbers of channels.
+// If the number of channels is invalid, an invalid map is set, and
+// mp_chmap_is_valid(dst) will return false.
+void mp_chmap_set_unknown(struct mp_chmap *dst, int num_channels)
+{
+    if (num_channels < 0 || num_channels > MP_NUM_CHANNELS) {
+        *dst = (struct mp_chmap) {0};
+    } else {
+        dst->num = num_channels;
+        for (int n = 0; n < dst->num; n++)
+            dst->speaker[n] = MP_SPEAKER_ID_UNKNOWN0 + n;
+    }
+}
+
+// Return channel index of the given speaker, or -1.
+static int mp_chmap_find_speaker(const struct mp_chmap *map, int speaker)
+{
+    for (int n = 0; n < map->num; n++) {
+        if (map->speaker[n] == speaker)
+            return n;
+    }
+    return -1;
+}
+
+static void mp_chmap_remove_speaker(struct mp_chmap *map, int speaker)
+{
+    int index = mp_chmap_find_speaker(map, speaker);
+    if (index >= 0) {
+        for (int n = index; n < map->num - 1; n++)
+            map->speaker[n] = map->speaker[n + 1];
+        map->num--;
+    }
+}
+
+// Some decoders output additional, redundant channels, which are usually
+// useless and will mess up proper audio output channel handling.
+// map: channel map from which the channels should be removed
+// requested: if not NULL, and if it contains any of the "useless" channels,
+//            don't remove them (this is for convenience)
+void mp_chmap_remove_useless_channels(struct mp_chmap *map,
+                                      const struct mp_chmap *requested)
+{
+    if (requested &&
+        mp_chmap_find_speaker(requested, MP_SPEAKER_ID_DL) >= 0)
+        return;
+
+    if (map->num > 2) {
+        mp_chmap_remove_speaker(map, MP_SPEAKER_ID_DL);
+        mp_chmap_remove_speaker(map, MP_SPEAKER_ID_DR);
+    }
+}
+
+// Return the ffmpeg/libav channel layout as in <libavutil/channel_layout.h>.
+// Warning: this ignores the order of the channels, and will return a channel
+//          mask even if the order is different from libavcodec's.
+uint64_t mp_chmap_to_lavc_unchecked(const struct mp_chmap *src)
+{
+    // lavc has no concept for unknown layouts yet, so pick a default
+    struct mp_chmap t = *src;
+    if (mp_chmap_is_unknown(&t))
+        mp_chmap_from_channels(&t, t.num);
+    uint64_t mask = 0;
+    for (int n = 0; n < t.num; n++)
+        mask |= 1ULL << t.speaker[n];
+    return mask;
+}
+
+// Return the ffmpeg/libav channel layout as in <libavutil/channel_layout.h>.
+// Returns 0 if the channel order doesn't match lavc's or if it's invalid.
+uint64_t mp_chmap_to_lavc(const struct mp_chmap *src)
+{
+    if (!mp_chmap_is_lavc(src))
+        return 0;
+    return mp_chmap_to_lavc_unchecked(src);
+}
+
+// Set channel map from the ffmpeg/libav channel layout as in
+// <libavutil/channel_layout.h>.
+// If the number of channels exceed MP_NUM_CHANNELS, set dst to empty.
+void mp_chmap_from_lavc(struct mp_chmap *dst, uint64_t src)
+{
+    dst->num = 0;
+    for (int n = 0; n < 64; n++) {
+        if (src & (1ULL << n)) {
+            if (dst->num >= MP_NUM_CHANNELS) {
+                dst->num = 0;
+                return;
+            }
+            dst->speaker[dst->num] = n;
+            dst->num++;
+        }
+    }
+}
+
+bool mp_chmap_is_lavc(const struct mp_chmap *src)
+{
+    if (!mp_chmap_is_valid(src))
+        return false;
+    if (mp_chmap_is_unknown(src))
+        return true;
+    // lavc's channel layout is a bit mask, and channels are always ordered
+    // from LSB to MSB speaker bits, so speaker IDs have to increase.
+    assert(src->num > 0);
+    for (int n = 1; n < src->num; n++) {
+        if (src->speaker[n - 1] >= src->speaker[n])
+            return false;
+    }
+    for (int n = 0; n < src->num; n++) {
+        if (src->speaker[n] >= 64)
+            return false;
+    }
+    return true;
+}
+
+void mp_chmap_reorder_to_lavc(struct mp_chmap *map)
+{
+    if (!mp_chmap_is_valid(map))
+        return;
+    uint64_t mask = mp_chmap_to_lavc_unchecked(map);
+    mp_chmap_from_lavc(map, mask);
+}
+
+// Get reordering array for from->to reordering. from->to must have the same set
+// of speakers (i.e. same number and speaker IDs, just different order). Then,
+// for each speaker n, dst[n] will be set such that:
+//      to->speaker[dst[n]] = from->speaker[n]
+// (dst[n] gives the source channel for destination channel n)
+void mp_chmap_get_reorder(int dst[MP_NUM_CHANNELS], const struct mp_chmap *from,
+                          const struct mp_chmap *to)
+{
+    assert(from->num == to->num);
+    if (mp_chmap_is_unknown(from) || mp_chmap_is_unknown(to)) {
+        for (int n = 0; n < from->num; n++)
+            dst[n] = n;
+        return;
+    }
+    // Same set of speakers required
+    assert(mp_chmap_equals_reordered(from, to));
+    for (int n = 0; n < from->num; n++) {
+        int src = from->speaker[n];
+        dst[n] = -1;
+        for (int i = 0; i < to->num; i++) {
+            if (src == to->speaker[i]) {
+                dst[n] = i;
+                break;
+            }
+        }
+        assert(dst[n] != -1);
+    }
+    for (int n = 0; n < from->num; n++)
+        assert(to->speaker[dst[n]] == from->speaker[n]);
+}
+
+// Returns something like "fl-fr-fc". If there's a standard layout in lavc
+// order, return that, e.g. "3.0" instead of "fl-fr-fc".
+// Unassigned but valid speakers get names like "sp28".
+char *mp_chmap_to_str(const struct mp_chmap *src)
+{
+    char *res = talloc_strdup(NULL, "");
+
+    if (mp_chmap_is_unknown(src))
+        return talloc_asprintf_append_buffer(res, "unknown%d", src->num);
+
+    for (int n = 0; n < src->num; n++) {
+        int sp = src->speaker[n];
+        const char *s = sp < MP_SPEAKER_ID_COUNT ? speaker_names[sp][0] : NULL;
+        char buf[10];
+        if (!s) {
+            snprintf(buf, sizeof(buf), "sp%d", sp);
+            s = buf;
+        }
+        res = talloc_asprintf_append_buffer(res, "%s%s", n > 0 ? "-" : "", s);
+    }
+
+    // To standard layout name
+    for (int n = 0; std_layout_names[n][0]; n++) {
+        if (res && strcmp(res, std_layout_names[n][1]) == 0) {