FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
channel_layout.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * audio channel layout utility functions
24  */
25 
26 #include "avstring.h"
27 #include "avutil.h"
28 #include "channel_layout.h"
29 #include "bprint.h"
30 #include "common.h"
31 
32 struct channel_name {
33  const char *name;
34  const char *description;
35 };
36 
37 static const struct channel_name channel_names[] = {
38  [0] = { "FL", "front left" },
39  [1] = { "FR", "front right" },
40  [2] = { "FC", "front center" },
41  [3] = { "LFE", "low frequency" },
42  [4] = { "BL", "back left" },
43  [5] = { "BR", "back right" },
44  [6] = { "FLC", "front left-of-center" },
45  [7] = { "FRC", "front right-of-center" },
46  [8] = { "BC", "back center" },
47  [9] = { "SL", "side left" },
48  [10] = { "SR", "side right" },
49  [11] = { "TC", "top center" },
50  [12] = { "TFL", "top front left" },
51  [13] = { "TFC", "top front center" },
52  [14] = { "TFR", "top front right" },
53  [15] = { "TBL", "top back left" },
54  [16] = { "TBC", "top back center" },
55  [17] = { "TBR", "top back right" },
56  [29] = { "DL", "downmix left" },
57  [30] = { "DR", "downmix right" },
58  [31] = { "WL", "wide left" },
59  [32] = { "WR", "wide right" },
60  [33] = { "SDL", "surround direct left" },
61  [34] = { "SDR", "surround direct right" },
62  [35] = { "LFE2", "low frequency 2" },
63 };
64 
65 static const char *get_channel_name(int channel_id)
66 {
67  if (channel_id < 0 || channel_id >= FF_ARRAY_ELEMS(channel_names))
68  return NULL;
69  return channel_names[channel_id].name;
70 }
71 
72 static const struct {
73  const char *name;
74  int nb_channels;
75  uint64_t layout;
76 } channel_layout_map[] = {
77  { "mono", 1, AV_CH_LAYOUT_MONO },
78  { "stereo", 2, AV_CH_LAYOUT_STEREO },
79  { "2.1", 3, AV_CH_LAYOUT_2POINT1 },
80  { "3.0", 3, AV_CH_LAYOUT_SURROUND },
81  { "3.0(back)", 3, AV_CH_LAYOUT_2_1 },
82  { "4.0", 4, AV_CH_LAYOUT_4POINT0 },
83  { "quad", 4, AV_CH_LAYOUT_QUAD },
84  { "quad(side)", 4, AV_CH_LAYOUT_2_2 },
85  { "3.1", 4, AV_CH_LAYOUT_3POINT1 },
86  { "5.0", 5, AV_CH_LAYOUT_5POINT0_BACK },
87  { "5.0(side)", 5, AV_CH_LAYOUT_5POINT0 },
88  { "4.1", 5, AV_CH_LAYOUT_4POINT1 },
89  { "5.1", 6, AV_CH_LAYOUT_5POINT1_BACK },
90  { "5.1(side)", 6, AV_CH_LAYOUT_5POINT1 },
91  { "6.0", 6, AV_CH_LAYOUT_6POINT0 },
92  { "6.0(front)", 6, AV_CH_LAYOUT_6POINT0_FRONT },
93  { "hexagonal", 6, AV_CH_LAYOUT_HEXAGONAL },
94  { "6.1", 7, AV_CH_LAYOUT_6POINT1 },
95  { "6.1", 7, AV_CH_LAYOUT_6POINT1_BACK },
96  { "6.1(front)", 7, AV_CH_LAYOUT_6POINT1_FRONT },
97  { "7.0", 7, AV_CH_LAYOUT_7POINT0 },
98  { "7.0(front)", 7, AV_CH_LAYOUT_7POINT0_FRONT },
99  { "7.1", 8, AV_CH_LAYOUT_7POINT1 },
100  { "7.1(wide)", 8, AV_CH_LAYOUT_7POINT1_WIDE },
101  { "octagonal", 8, AV_CH_LAYOUT_OCTAGONAL },
102  { "downmix", 2, AV_CH_LAYOUT_STEREO_DOWNMIX, },
103 };
104 
105 static uint64_t get_channel_layout_single(const char *name, int name_len)
106 {
107  int i;
108  char *end;
109  int64_t layout;
110 
111  for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++) {
112  if (strlen(channel_layout_map[i].name) == name_len &&
113  !memcmp(channel_layout_map[i].name, name, name_len))
114  return channel_layout_map[i].layout;
115  }
116  for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++)
117  if (channel_names[i].name &&
118  strlen(channel_names[i].name) == name_len &&
119  !memcmp(channel_names[i].name, name, name_len))
120  return (int64_t)1 << i;
121  i = strtol(name, &end, 10);
122  if (end - name == name_len ||
123  (end + 1 - name == name_len && *end == 'c'))
124  return av_get_default_channel_layout(i);
125  layout = strtoll(name, &end, 0);
126  if (end - name == name_len)
127  return FFMAX(layout, 0);
128  return 0;
129 }
130 
131 uint64_t av_get_channel_layout(const char *name)
132 {
133  const char *n, *e;
134  const char *name_end = name + strlen(name);
135  int64_t layout = 0, layout_single;
136 
137  for (n = name; n < name_end; n = e + 1) {
138  for (e = n; e < name_end && *e != '+' && *e != '|'; e++);
139  layout_single = get_channel_layout_single(n, e - n);
140  if (!layout_single)
141  return 0;
142  layout |= layout_single;
143  }
144  return layout;
145 }
146 
147 void av_bprint_channel_layout(struct AVBPrint *bp,
148  int nb_channels, uint64_t channel_layout)
149 {
150  int i;
151 
152  if (nb_channels <= 0)
153  nb_channels = av_get_channel_layout_nb_channels(channel_layout);
154 
155  for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
156  if (nb_channels == channel_layout_map[i].nb_channels &&
157  channel_layout == channel_layout_map[i].layout) {
158  av_bprintf(bp, "%s", channel_layout_map[i].name);
159  return;
160  }
161 
162  av_bprintf(bp, "%d channels", nb_channels);
163  if (channel_layout) {
164  int i, ch;
165  av_bprintf(bp, " (");
166  for (i = 0, ch = 0; i < 64; i++) {
167  if ((channel_layout & (UINT64_C(1) << i))) {
168  const char *name = get_channel_name(i);
169  if (name) {
170  if (ch > 0)
171  av_bprintf(bp, "+");
172  av_bprintf(bp, "%s", name);
173  }
174  ch++;
175  }
176  }
177  av_bprintf(bp, ")");
178  }
179 }
180 
181 void av_get_channel_layout_string(char *buf, int buf_size,
182  int nb_channels, uint64_t channel_layout)
183 {
184  AVBPrint bp;
185 
186  av_bprint_init_for_buffer(&bp, buf, buf_size);
187  av_bprint_channel_layout(&bp, nb_channels, channel_layout);
188 }
189 
190 int av_get_channel_layout_nb_channels(uint64_t channel_layout)
191 {
192  return av_popcount64(channel_layout);
193 }
194 
195 int64_t av_get_default_channel_layout(int nb_channels) {
196  int i;
197  for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
198  if (nb_channels == channel_layout_map[i].nb_channels)
199  return channel_layout_map[i].layout;
200  return 0;
201 }
202 
203 int av_get_channel_layout_channel_index(uint64_t channel_layout,
204  uint64_t channel)
205 {
206  if (!(channel_layout & channel) ||
207  av_get_channel_layout_nb_channels(channel) != 1)
208  return AVERROR(EINVAL);
209  channel_layout &= channel - 1;
210  return av_get_channel_layout_nb_channels(channel_layout);
211 }
212 
213 const char *av_get_channel_name(uint64_t channel)
214 {
215  int i;
216  if (av_get_channel_layout_nb_channels(channel) != 1)
217  return NULL;
218  for (i = 0; i < 64; i++)
219  if ((1ULL<<i) & channel)
220  return get_channel_name(i);
221  return NULL;
222 }
223 
224 const char *av_get_channel_description(uint64_t channel)
225 {
226  int i;
227  if (av_get_channel_layout_nb_channels(channel) != 1)
228  return NULL;
229  for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++)
230  if ((1ULL<<i) & channel)
231  return channel_names[i].description;
232  return NULL;
233 }
234 
235 uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
236 {
237  int i;
238 
239  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
240  return 0;
241 
242  for (i = 0; i < 64; i++) {
243  if ((1ULL << i) & channel_layout && !index--)
244  return 1ULL << i;
245  }
246  return 0;
247 }
248 
249 int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
250  const char **name)
251 {
252  if (index >= FF_ARRAY_ELEMS(channel_layout_map))
253  return AVERROR_EOF;
254  if (layout) *layout = channel_layout_map[index].layout;
255  if (name) *name = channel_layout_map[index].name;
256  return 0;
257 }
Generated on Sat May 25 2013 03:58:50 for FFmpeg by   doxygen 1.8.2