channel_layout.c 9.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
23
 * audio channel layout utility functions
24 25
 */

26 27
#include <stdint.h>

28 29
#include "avstring.h"
#include "avutil.h"
30
#include "channel_layout.h"
31
#include "bprint.h"
32
#include "common.h"
33

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
struct channel_name {
    const char *name;
    const char *description;
};

static const struct channel_name channel_names[] = {
     [0] = { "FL",        "front left"            },
     [1] = { "FR",        "front right"           },
     [2] = { "FC",        "front center"          },
     [3] = { "LFE",       "low frequency"         },
     [4] = { "BL",        "back left"             },
     [5] = { "BR",        "back right"            },
     [6] = { "FLC",       "front left-of-center"  },
     [7] = { "FRC",       "front right-of-center" },
     [8] = { "BC",        "back center"           },
     [9] = { "SL",        "side left"             },
    [10] = { "SR",        "side right"            },
    [11] = { "TC",        "top center"            },
    [12] = { "TFL",       "top front left"        },
    [13] = { "TFC",       "top front center"      },
    [14] = { "TFR",       "top front right"       },
    [15] = { "TBL",       "top back left"         },
    [16] = { "TBC",       "top back center"       },
    [17] = { "TBR",       "top back right"        },
    [29] = { "DL",        "downmix left"          },
    [30] = { "DR",        "downmix right"         },
    [31] = { "WL",        "wide left"             },
    [32] = { "WR",        "wide right"            },
    [33] = { "SDL",       "surround direct left"  },
    [34] = { "SDR",       "surround direct right" },
64
    [35] = { "LFE2",      "low frequency 2"       },
65 66 67 68 69 70
};

static const char *get_channel_name(int channel_id)
{
    if (channel_id < 0 || channel_id >= FF_ARRAY_ELEMS(channel_names))
        return NULL;
71
    return channel_names[channel_id].name;
72 73 74 75 76
}

static const struct {
    const char *name;
    int         nb_channels;
77
    uint64_t     layout;
78 79 80
} channel_layout_map[] = {
    { "mono",        1,  AV_CH_LAYOUT_MONO },
    { "stereo",      2,  AV_CH_LAYOUT_STEREO },
81
    { "2.1",         3,  AV_CH_LAYOUT_2POINT1 },
82 83
    { "3.0",         3,  AV_CH_LAYOUT_SURROUND },
    { "3.0(back)",   3,  AV_CH_LAYOUT_2_1 },
84 85
    { "4.0",         4,  AV_CH_LAYOUT_4POINT0 },
    { "quad",        4,  AV_CH_LAYOUT_QUAD },
86
    { "quad(side)",  4,  AV_CH_LAYOUT_2_2 },
87
    { "3.1",         4,  AV_CH_LAYOUT_3POINT1 },
88
    { "5.0",         5,  AV_CH_LAYOUT_5POINT0_BACK },
89
    { "5.0(side)",   5,  AV_CH_LAYOUT_5POINT0 },
90
    { "4.1",         5,  AV_CH_LAYOUT_4POINT1 },
91
    { "5.1",         6,  AV_CH_LAYOUT_5POINT1_BACK },
92
    { "5.1(side)",   6,  AV_CH_LAYOUT_5POINT1 },
93 94 95 96
    { "6.0",         6,  AV_CH_LAYOUT_6POINT0 },
    { "6.0(front)",  6,  AV_CH_LAYOUT_6POINT0_FRONT },
    { "hexagonal",   6,  AV_CH_LAYOUT_HEXAGONAL },
    { "6.1",         7,  AV_CH_LAYOUT_6POINT1 },
97
    { "6.1(back)",   7,  AV_CH_LAYOUT_6POINT1_BACK },
98 99 100
    { "6.1(front)",  7,  AV_CH_LAYOUT_6POINT1_FRONT },
    { "7.0",         7,  AV_CH_LAYOUT_7POINT0 },
    { "7.0(front)",  7,  AV_CH_LAYOUT_7POINT0_FRONT },
101
    { "7.1",         8,  AV_CH_LAYOUT_7POINT1 },
102 103
    { "7.1(wide)",   8,  AV_CH_LAYOUT_7POINT1_WIDE_BACK },
    { "7.1(wide-side)",   8,  AV_CH_LAYOUT_7POINT1_WIDE },
104
    { "octagonal",   8,  AV_CH_LAYOUT_OCTAGONAL },
105
    { "hexadecagonal", 16, AV_CH_LAYOUT_HEXADECAGONAL },
106
    { "downmix",     2,  AV_CH_LAYOUT_STEREO_DOWNMIX, },
107 108
};

109
static uint64_t get_channel_layout_single(const char *name, int name_len)
110
{
111 112 113
    int i;
    char *end;
    int64_t layout;
114

115
    for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++) {
116 117 118 119 120
        if (strlen(channel_layout_map[i].name) == name_len &&
            !memcmp(channel_layout_map[i].name, name, name_len))
            return channel_layout_map[i].layout;
    }
    for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++)
121 122 123
        if (channel_names[i].name &&
            strlen(channel_names[i].name) == name_len &&
            !memcmp(channel_names[i].name, name, name_len))
124
            return (int64_t)1 << i;
125 126

    errno = 0;
127
    i = strtol(name, &end, 10);
128

129
    if (!errno && (end + 1 - name == name_len && *end  == 'c'))
130
        return av_get_default_channel_layout(i);
131

132
    errno = 0;
133
    layout = strtoll(name, &end, 0);
134
    if (!errno && end - name == name_len)
135
        return FFMAX(layout, 0);
136 137 138
    return 0;
}

139
uint64_t av_get_channel_layout(const char *name)
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
{
    const char *n, *e;
    const char *name_end = name + strlen(name);
    int64_t layout = 0, layout_single;

    for (n = name; n < name_end; n = e + 1) {
        for (e = n; e < name_end && *e != '+' && *e != '|'; e++);
        layout_single = get_channel_layout_single(n, e - n);
        if (!layout_single)
            return 0;
        layout |= layout_single;
    }
    return layout;
}

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels)
{
    int nb = 0;
    char *end;
    uint64_t layout = av_get_channel_layout(name);

    if (layout) {
        *channel_layout = layout;
        *nb_channels = av_get_channel_layout_nb_channels(layout);
        return 0;
    }

    nb = strtol(name, &end, 10);
    if (!errno && *end  == 'C' && *(end + 1) == '\0' && nb > 0 && nb < 64) {
        *channel_layout = 0;
        *nb_channels = nb;
        return 0;
    }

    return AVERROR(EINVAL);
}

177 178
void av_bprint_channel_layout(struct AVBPrint *bp,
                              int nb_channels, uint64_t channel_layout)
179 180 181
{
    int i;

182 183 184
    if (nb_channels <= 0)
        nb_channels = av_get_channel_layout_nb_channels(channel_layout);

185
    for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
186 187
        if (nb_channels    == channel_layout_map[i].nb_channels &&
            channel_layout == channel_layout_map[i].layout) {
188
            av_bprintf(bp, "%s", channel_layout_map[i].name);
189 190 191
            return;
        }

192
    av_bprintf(bp, "%d channels", nb_channels);
193
    if (channel_layout) {
194
        int i, ch;
195
        av_bprintf(bp, " (");
196
        for (i = 0, ch = 0; i < 64; i++) {
197
            if ((channel_layout & (UINT64_C(1) << i))) {
198 199
                const char *name = get_channel_name(i);
                if (name) {
200
                    if (ch > 0)
201 202
                        av_bprintf(bp, "+");
                    av_bprintf(bp, "%s", name);
203 204 205 206
                }
                ch++;
            }
        }
207
        av_bprintf(bp, ")");
208 209 210
    }
}

211 212 213 214 215 216 217 218 219
void av_get_channel_layout_string(char *buf, int buf_size,
                                  int nb_channels, uint64_t channel_layout)
{
    AVBPrint bp;

    av_bprint_init_for_buffer(&bp, buf, buf_size);
    av_bprint_channel_layout(&bp, nb_channels, channel_layout);
}

220
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
221
{
222
    return av_popcount64(channel_layout);
223
}
224

225
int64_t av_get_default_channel_layout(int nb_channels) {
226
    int i;
227
    for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
228 229 230 231
        if (nb_channels == channel_layout_map[i].nb_channels)
            return channel_layout_map[i].layout;
    return 0;
}
232 233 234 235 236 237 238 239 240 241

int av_get_channel_layout_channel_index(uint64_t channel_layout,
                                        uint64_t channel)
{
    if (!(channel_layout & channel) ||
        av_get_channel_layout_nb_channels(channel) != 1)
        return AVERROR(EINVAL);
    channel_layout &= channel - 1;
    return av_get_channel_layout_nb_channels(channel_layout);
}
242 243 244 245 246 247 248 249 250 251 252

const char *av_get_channel_name(uint64_t channel)
{
    int i;
    if (av_get_channel_layout_nb_channels(channel) != 1)
        return NULL;
    for (i = 0; i < 64; i++)
        if ((1ULL<<i) & channel)
            return get_channel_name(i);
    return NULL;
}
253

254 255 256 257 258 259 260 261 262 263 264
const char *av_get_channel_description(uint64_t channel)
{
    int i;
    if (av_get_channel_layout_nb_channels(channel) != 1)
        return NULL;
    for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++)
        if ((1ULL<<i) & channel)
            return channel_names[i].description;
    return NULL;
}

265 266 267 268 269 270 271 272 273 274 275 276 277
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
{
    int i;

    if (av_get_channel_layout_nb_channels(channel_layout) <= index)
        return 0;

    for (i = 0; i < 64; i++) {
        if ((1ULL << i) & channel_layout && !index--)
            return 1ULL << i;
    }
    return 0;
}
278 279 280 281 282 283 284 285 286 287

int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
                                   const char **name)
{
    if (index >= FF_ARRAY_ELEMS(channel_layout_map))
        return AVERROR_EOF;
    if (layout) *layout = channel_layout_map[index].layout;
    if (name)   *name   = channel_layout_map[index].name;
    return 0;
}