2 * Copyright (C) 2011 Michael Niedermayer (michaelni@gmx.at)
3 * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "libavutil/libm.h"
25 #include "libavutil/samplefmt.h"
26 #include "avresample.h"
28 #include "audio_data.h"
29 #include "audio_mix.h"
31 /* channel positions */
34 #define FRONT_CENTER 2
35 #define LOW_FREQUENCY 3
38 #define FRONT_LEFT_OF_CENTER 6
39 #define FRONT_RIGHT_OF_CENTER 7
44 #define TOP_FRONT_LEFT 12
45 #define TOP_FRONT_CENTER 13
46 #define TOP_FRONT_RIGHT 14
47 #define TOP_BACK_LEFT 15
48 #define TOP_BACK_CENTER 16
49 #define TOP_BACK_RIGHT 17
50 #define STEREO_LEFT 29
51 #define STEREO_RIGHT 30
54 #define SURROUND_DIRECT_LEFT 33
55 #define SURROUND_DIRECT_RIGHT 34
57 #define SQRT3_2 1.22474487139158904909 /* sqrt(3/2) */
59 static av_always_inline int even(uint64_t layout)
61 return (!layout || (layout & (layout - 1)));
64 static int sane_layout(uint64_t layout)
66 /* check that there is at least 1 front speaker */
67 if (!(layout & AV_CH_LAYOUT_SURROUND))
70 /* check for left/right symmetry */
71 if (!even(layout & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)) ||
72 !even(layout & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)) ||
73 !even(layout & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)) ||
74 !even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)) ||
75 !even(layout & (AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT)) ||
76 !even(layout & (AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT)) ||
77 !even(layout & (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)) ||
78 !even(layout & (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)) ||
79 !even(layout & (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)))
85 int avresample_build_matrix(uint64_t in_layout, uint64_t out_layout,
86 double center_mix_level, double surround_mix_level,
87 double lfe_mix_level, int normalize,
88 double *matrix_out, int stride,
89 enum AVMatrixEncoding matrix_encoding)
91 int i, j, out_i, out_j;
92 double matrix[64][64] = {{0}};
95 int in_channels, out_channels;
97 if ((out_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == AV_CH_LAYOUT_STEREO_DOWNMIX) {
98 out_layout = AV_CH_LAYOUT_STEREO;
101 unaccounted = in_layout & ~out_layout;
103 in_channels = av_get_channel_layout_nb_channels( in_layout);
104 out_channels = av_get_channel_layout_nb_channels(out_layout);
106 memset(matrix_out, 0, out_channels * stride * sizeof(*matrix_out));
108 /* check if layouts are supported */
109 if (!in_layout || in_channels > AVRESAMPLE_MAX_CHANNELS)
110 return AVERROR(EINVAL);
111 if (!out_layout || out_channels > AVRESAMPLE_MAX_CHANNELS)
112 return AVERROR(EINVAL);
114 /* check if layouts are unbalanced or abnormal */
115 if (!sane_layout(in_layout) || !sane_layout(out_layout))
116 return AVERROR_PATCHWELCOME;
118 /* route matching input/output channels */
119 for (i = 0; i < 64; i++) {
120 if (in_layout & out_layout & (1ULL << i))
124 /* mix front center to front left/right */
125 if (unaccounted & AV_CH_FRONT_CENTER) {
126 if ((out_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
127 matrix[FRONT_LEFT ][FRONT_CENTER] += M_SQRT1_2;
128 matrix[FRONT_RIGHT][FRONT_CENTER] += M_SQRT1_2;
130 return AVERROR_PATCHWELCOME;
132 /* mix front left/right to center */
133 if (unaccounted & AV_CH_LAYOUT_STEREO) {
134 if (out_layout & AV_CH_FRONT_CENTER) {
135 matrix[FRONT_CENTER][FRONT_LEFT ] += M_SQRT1_2;
136 matrix[FRONT_CENTER][FRONT_RIGHT] += M_SQRT1_2;
137 /* mix left/right/center to center */
138 if (in_layout & AV_CH_FRONT_CENTER)
139 matrix[FRONT_CENTER][FRONT_CENTER] = center_mix_level * M_SQRT2;
141 return AVERROR_PATCHWELCOME;
143 /* mix back center to back, side, or front */
144 if (unaccounted & AV_CH_BACK_CENTER) {
145 if (out_layout & AV_CH_BACK_LEFT) {
146 matrix[BACK_LEFT ][BACK_CENTER] += M_SQRT1_2;
147 matrix[BACK_RIGHT][BACK_CENTER] += M_SQRT1_2;
148 } else if (out_layout & AV_CH_SIDE_LEFT) {
149 matrix[SIDE_LEFT ][BACK_CENTER] += M_SQRT1_2;
150 matrix[SIDE_RIGHT][BACK_CENTER] += M_SQRT1_2;
151 } else if (out_layout & AV_CH_FRONT_LEFT) {
152 if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
153 matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
154 if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
155 matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level * M_SQRT1_2;
156 matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
158 matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
159 matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
162 matrix[FRONT_LEFT ][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
163 matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
165 } else if (out_layout & AV_CH_FRONT_CENTER) {
166 matrix[FRONT_CENTER][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
168 return AVERROR_PATCHWELCOME;
170 /* mix back left/right to back center, side, or front */
171 if (unaccounted & AV_CH_BACK_LEFT) {
172 if (out_layout & AV_CH_BACK_CENTER) {
173 matrix[BACK_CENTER][BACK_LEFT ] += M_SQRT1_2;
174 matrix[BACK_CENTER][BACK_RIGHT] += M_SQRT1_2;
175 } else if (out_layout & AV_CH_SIDE_LEFT) {
176 /* if side channels do not exist in the input, just copy back
177 channels to side channels, otherwise mix back into side */
178 if (in_layout & AV_CH_SIDE_LEFT) {
179 matrix[SIDE_LEFT ][BACK_LEFT ] += M_SQRT1_2;
180 matrix[SIDE_RIGHT][BACK_RIGHT] += M_SQRT1_2;
182 matrix[SIDE_LEFT ][BACK_LEFT ] += 1.0;
183 matrix[SIDE_RIGHT][BACK_RIGHT] += 1.0;
185 } else if (out_layout & AV_CH_FRONT_LEFT) {
186 if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
187 matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * M_SQRT1_2;
188 matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
189 matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
190 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
191 } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
192 matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * SQRT3_2;
193 matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
194 matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
195 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * SQRT3_2;
197 matrix[FRONT_LEFT ][BACK_LEFT ] += surround_mix_level;
198 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
200 } else if (out_layout & AV_CH_FRONT_CENTER) {
201 matrix[FRONT_CENTER][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
202 matrix[FRONT_CENTER][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
204 return AVERROR_PATCHWELCOME;
206 /* mix side left/right into back or front */
207 if (unaccounted & AV_CH_SIDE_LEFT) {
208 if (out_layout & AV_CH_BACK_LEFT) {
209 /* if back channels do not exist in the input, just copy side
210 channels to back channels, otherwise mix side into back */
211 if (in_layout & AV_CH_BACK_LEFT) {
212 matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
213 matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
215 matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
216 matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
218 } else if (out_layout & AV_CH_BACK_CENTER) {
219 matrix[BACK_CENTER][SIDE_LEFT ] += M_SQRT1_2;
220 matrix[BACK_CENTER][SIDE_RIGHT] += M_SQRT1_2;
221 } else if (out_layout & AV_CH_FRONT_LEFT) {
222 if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
223 matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * M_SQRT1_2;
224 matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
225 matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
226 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
227 } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
228 matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * SQRT3_2;
229 matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
230 matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
231 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * SQRT3_2;
233 matrix[FRONT_LEFT ][SIDE_LEFT ] += surround_mix_level;
234 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
236 } else if (out_layout & AV_CH_FRONT_CENTER) {
237 matrix[FRONT_CENTER][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
238 matrix[FRONT_CENTER][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
240 return AVERROR_PATCHWELCOME;
242 /* mix left-of-center/right-of-center into front left/right or center */
243 if (unaccounted & AV_CH_FRONT_LEFT_OF_CENTER) {
244 if (out_layout & AV_CH_FRONT_LEFT) {
245 matrix[FRONT_LEFT ][FRONT_LEFT_OF_CENTER ] += 1.0;
246 matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER] += 1.0;
247 } else if (out_layout & AV_CH_FRONT_CENTER) {
248 matrix[FRONT_CENTER][FRONT_LEFT_OF_CENTER ] += M_SQRT1_2;
249 matrix[FRONT_CENTER][FRONT_RIGHT_OF_CENTER] += M_SQRT1_2;
251 return AVERROR_PATCHWELCOME;
253 /* mix LFE into front left/right or center */
254 if (unaccounted & AV_CH_LOW_FREQUENCY) {
255 if (out_layout & AV_CH_FRONT_CENTER) {
256 matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
257 } else if (out_layout & AV_CH_FRONT_LEFT) {
258 matrix[FRONT_LEFT ][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
259 matrix[FRONT_RIGHT][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
261 return AVERROR_PATCHWELCOME;
264 /* transfer internal matrix to output matrix and calculate maximum
265 per-channel coefficient sum */
266 for (out_i = i = 0; out_i < out_channels && i < 64; i++) {
268 for (out_j = j = 0; out_j < in_channels && j < 64; j++) {
269 matrix_out[out_i * stride + out_j] = matrix[i][j];
270 sum += fabs(matrix[i][j]);
271 if (in_layout & (1ULL << j))
274 maxcoef = FFMAX(maxcoef, sum);
275 if (out_layout & (1ULL << i))
280 if (normalize && maxcoef > 1.0) {
281 for (i = 0; i < out_channels; i++)
282 for (j = 0; j < in_channels; j++)
283 matrix_out[i * stride + j] /= maxcoef;
289 int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix,
292 int in_channels, out_channels, i, o;
294 in_channels = av_get_channel_layout_nb_channels(avr->in_channel_layout);
295 out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
297 if ( in_channels < 0 || in_channels > AVRESAMPLE_MAX_CHANNELS ||
298 out_channels < 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
299 av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
300 return AVERROR(EINVAL);
303 switch (avr->mix_coeff_type) {
304 case AV_MIX_COEFF_TYPE_Q8:
305 if (!avr->am->matrix_q8[0]) {
306 av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
307 return AVERROR(EINVAL);
309 for (o = 0; o < out_channels; o++)
310 for (i = 0; i < in_channels; i++)
311 matrix[o * stride + i] = avr->am->matrix_q8[o][i] / 256.0;
313 case AV_MIX_COEFF_TYPE_Q15:
314 if (!avr->am->matrix_q15[0]) {
315 av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
316 return AVERROR(EINVAL);
318 for (o = 0; o < out_channels; o++)
319 for (i = 0; i < in_channels; i++)
320 matrix[o * stride + i] = avr->am->matrix_q15[o][i] / 32768.0;
322 case AV_MIX_COEFF_TYPE_FLT:
323 if (!avr->am->matrix_flt[0]) {
324 av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
325 return AVERROR(EINVAL);
327 for (o = 0; o < out_channels; o++)
328 for (i = 0; i < in_channels; i++)
329 matrix[o * stride + i] = avr->am->matrix_flt[o][i];
332 av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
333 return AVERROR(EINVAL);
338 int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
341 int in_channels, out_channels, i, o;
343 in_channels = av_get_channel_layout_nb_channels(avr->in_channel_layout);
344 out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
346 if ( in_channels < 0 || in_channels > AVRESAMPLE_MAX_CHANNELS ||
347 out_channels < 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
348 av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
349 return AVERROR(EINVAL);
353 av_freep(avr->am->matrix);
355 #define CONVERT_MATRIX(type, expr) \
356 avr->am->matrix_## type[0] = av_mallocz(out_channels * in_channels * \
357 sizeof(*avr->am->matrix_## type[0])); \
358 if (!avr->am->matrix_## type[0]) \
359 return AVERROR(ENOMEM); \
360 for (o = 0; o < out_channels; o++) { \
362 avr->am->matrix_## type[o] = avr->am->matrix_## type[o - 1] + \
364 for (i = 0; i < in_channels; i++) { \
365 double v = matrix[o * stride + i]; \
366 avr->am->matrix_## type[o][i] = expr; \
369 avr->am->matrix = (void **)avr->am->matrix_## type;
371 switch (avr->mix_coeff_type) {
372 case AV_MIX_COEFF_TYPE_Q8:
373 CONVERT_MATRIX(q8, av_clip_int16(lrint(256.0 * v)))
375 case AV_MIX_COEFF_TYPE_Q15:
376 CONVERT_MATRIX(q15, av_clipl_int32(llrint(32768.0 * v)))
378 case AV_MIX_COEFF_TYPE_FLT:
379 CONVERT_MATRIX(flt, v)
382 av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
383 return AVERROR(EINVAL);
386 /* TODO: detect situations where we can just swap around pointers
387 instead of doing matrix multiplications with 0.0 and 1.0 */