lavf: factor codec id forcing out
[ffmpeg.git] / libavresample / audio_mix_matrix.c
1 /*
2  * Copyright (C) 2011 Michael Niedermayer (michaelni@gmx.at)
3  * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
4  *
5  * This file is part of Libav.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include <stdint.h>
23
24 #include "libavutil/common.h"
25 #include "libavutil/libm.h"
26 #include "libavutil/samplefmt.h"
27 #include "avresample.h"
28 #include "internal.h"
29 #include "audio_data.h"
30 #include "audio_mix.h"
31
32 /* channel positions */
33 #define FRONT_LEFT              0
34 #define FRONT_RIGHT             1
35 #define FRONT_CENTER            2
36 #define LOW_FREQUENCY           3
37 #define BACK_LEFT               4
38 #define BACK_RIGHT              5
39 #define FRONT_LEFT_OF_CENTER    6
40 #define FRONT_RIGHT_OF_CENTER   7
41 #define BACK_CENTER             8
42 #define SIDE_LEFT               9
43 #define SIDE_RIGHT             10
44 #define TOP_CENTER             11
45 #define TOP_FRONT_LEFT         12
46 #define TOP_FRONT_CENTER       13
47 #define TOP_FRONT_RIGHT        14
48 #define TOP_BACK_LEFT          15
49 #define TOP_BACK_CENTER        16
50 #define TOP_BACK_RIGHT         17
51 #define STEREO_LEFT            29
52 #define STEREO_RIGHT           30
53 #define WIDE_LEFT              31
54 #define WIDE_RIGHT             32
55 #define SURROUND_DIRECT_LEFT   33
56 #define SURROUND_DIRECT_RIGHT  34
57
58 #define SQRT3_2      1.22474487139158904909  /* sqrt(3/2) */
59
60 static av_always_inline int even(uint64_t layout)
61 {
62     return (!layout || (layout & (layout - 1)));
63 }
64
65 static int sane_layout(uint64_t layout)
66 {
67     /* check that there is at least 1 front speaker */
68     if (!(layout & AV_CH_LAYOUT_SURROUND))
69         return 0;
70
71     /* check for left/right symmetry */
72     if (!even(layout & (AV_CH_FRONT_LEFT           | AV_CH_FRONT_RIGHT))           ||
73         !even(layout & (AV_CH_SIDE_LEFT            | AV_CH_SIDE_RIGHT))            ||
74         !even(layout & (AV_CH_BACK_LEFT            | AV_CH_BACK_RIGHT))            ||
75         !even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)) ||
76         !even(layout & (AV_CH_TOP_FRONT_LEFT       | AV_CH_TOP_FRONT_RIGHT))       ||
77         !even(layout & (AV_CH_TOP_BACK_LEFT        | AV_CH_TOP_BACK_RIGHT))        ||
78         !even(layout & (AV_CH_STEREO_LEFT          | AV_CH_STEREO_RIGHT))          ||
79         !even(layout & (AV_CH_WIDE_LEFT            | AV_CH_WIDE_RIGHT))            ||
80         !even(layout & (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)))
81         return 0;
82
83     return 1;
84 }
85
86 int avresample_build_matrix(uint64_t in_layout, uint64_t out_layout,
87                             double center_mix_level, double surround_mix_level,
88                             double lfe_mix_level, int normalize,
89                             double *matrix_out, int stride,
90                             enum AVMatrixEncoding matrix_encoding)
91 {
92     int i, j, out_i, out_j;
93     double matrix[64][64] = {{0}};
94     int64_t unaccounted;
95     double maxcoef = 0;
96     int in_channels, out_channels;
97
98     if ((out_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == AV_CH_LAYOUT_STEREO_DOWNMIX) {
99         out_layout = AV_CH_LAYOUT_STEREO;
100     }
101
102     unaccounted = in_layout & ~out_layout;
103
104     in_channels  = av_get_channel_layout_nb_channels( in_layout);
105     out_channels = av_get_channel_layout_nb_channels(out_layout);
106
107     memset(matrix_out, 0, out_channels * stride * sizeof(*matrix_out));
108
109     /* check if layouts are supported */
110     if (!in_layout || in_channels > AVRESAMPLE_MAX_CHANNELS)
111         return AVERROR(EINVAL);
112     if (!out_layout || out_channels > AVRESAMPLE_MAX_CHANNELS)
113         return AVERROR(EINVAL);
114
115     /* check if layouts are unbalanced or abnormal */
116     if (!sane_layout(in_layout) || !sane_layout(out_layout))
117         return AVERROR_PATCHWELCOME;
118
119     /* route matching input/output channels */
120     for (i = 0; i < 64; i++) {
121         if (in_layout & out_layout & (1ULL << i))
122             matrix[i][i] = 1.0;
123     }
124
125     /* mix front center to front left/right */
126     if (unaccounted & AV_CH_FRONT_CENTER) {
127         if ((out_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
128             matrix[FRONT_LEFT ][FRONT_CENTER] += M_SQRT1_2;
129             matrix[FRONT_RIGHT][FRONT_CENTER] += M_SQRT1_2;
130         } else
131             return AVERROR_PATCHWELCOME;
132     }
133     /* mix front left/right to center */
134     if (unaccounted & AV_CH_LAYOUT_STEREO) {
135         if (out_layout & AV_CH_FRONT_CENTER) {
136             matrix[FRONT_CENTER][FRONT_LEFT ] += M_SQRT1_2;
137             matrix[FRONT_CENTER][FRONT_RIGHT] += M_SQRT1_2;
138             /* mix left/right/center to center */
139             if (in_layout & AV_CH_FRONT_CENTER)
140                 matrix[FRONT_CENTER][FRONT_CENTER] = center_mix_level * M_SQRT2;
141         } else
142             return AVERROR_PATCHWELCOME;
143     }
144     /* mix back center to back, side, or front */
145     if (unaccounted & AV_CH_BACK_CENTER) {
146         if (out_layout & AV_CH_BACK_LEFT) {
147             matrix[BACK_LEFT ][BACK_CENTER] += M_SQRT1_2;
148             matrix[BACK_RIGHT][BACK_CENTER] += M_SQRT1_2;
149         } else if (out_layout & AV_CH_SIDE_LEFT) {
150             matrix[SIDE_LEFT ][BACK_CENTER] += M_SQRT1_2;
151             matrix[SIDE_RIGHT][BACK_CENTER] += M_SQRT1_2;
152         } else if (out_layout & AV_CH_FRONT_LEFT) {
153             if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
154                 matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
155                 if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
156                     matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level * M_SQRT1_2;
157                     matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
158                 } else {
159                     matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
160                     matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
161                 }
162             } else {
163                 matrix[FRONT_LEFT ][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
164                 matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
165             }
166         } else if (out_layout & AV_CH_FRONT_CENTER) {
167             matrix[FRONT_CENTER][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
168         } else
169             return AVERROR_PATCHWELCOME;
170     }
171     /* mix back left/right to back center, side, or front */
172     if (unaccounted & AV_CH_BACK_LEFT) {
173         if (out_layout & AV_CH_BACK_CENTER) {
174             matrix[BACK_CENTER][BACK_LEFT ] += M_SQRT1_2;
175             matrix[BACK_CENTER][BACK_RIGHT] += M_SQRT1_2;
176         } else if (out_layout & AV_CH_SIDE_LEFT) {
177             /* if side channels do not exist in the input, just copy back
178                channels to side channels, otherwise mix back into side */
179             if (in_layout & AV_CH_SIDE_LEFT) {
180                 matrix[SIDE_LEFT ][BACK_LEFT ] += M_SQRT1_2;
181                 matrix[SIDE_RIGHT][BACK_RIGHT] += M_SQRT1_2;
182             } else {
183                 matrix[SIDE_LEFT ][BACK_LEFT ] += 1.0;
184                 matrix[SIDE_RIGHT][BACK_RIGHT] += 1.0;
185             }
186         } else if (out_layout & AV_CH_FRONT_LEFT) {
187             if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
188                 matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * M_SQRT1_2;
189                 matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
190                 matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
191                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
192             } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
193                 matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * SQRT3_2;
194                 matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
195                 matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
196                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * SQRT3_2;
197             } else {
198                 matrix[FRONT_LEFT ][BACK_LEFT ] += surround_mix_level;
199                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
200             }
201         } else if (out_layout & AV_CH_FRONT_CENTER) {
202             matrix[FRONT_CENTER][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
203             matrix[FRONT_CENTER][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
204         } else
205             return AVERROR_PATCHWELCOME;
206     }
207     /* mix side left/right into back or front */
208     if (unaccounted & AV_CH_SIDE_LEFT) {
209         if (out_layout & AV_CH_BACK_LEFT) {
210             /* if back channels do not exist in the input, just copy side
211                channels to back channels, otherwise mix side into back */
212             if (in_layout & AV_CH_BACK_LEFT) {
213                 matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
214                 matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
215             } else {
216                 matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
217                 matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
218             }
219         } else if (out_layout & AV_CH_BACK_CENTER) {
220             matrix[BACK_CENTER][SIDE_LEFT ] += M_SQRT1_2;
221             matrix[BACK_CENTER][SIDE_RIGHT] += M_SQRT1_2;
222         } else if (out_layout & AV_CH_FRONT_LEFT) {
223             if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
224                 matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * M_SQRT1_2;
225                 matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
226                 matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
227                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
228             } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
229                 matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * SQRT3_2;
230                 matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
231                 matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
232                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * SQRT3_2;
233             } else {
234                 matrix[FRONT_LEFT ][SIDE_LEFT ] += surround_mix_level;
235                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
236             }
237         } else if (out_layout & AV_CH_FRONT_CENTER) {
238             matrix[FRONT_CENTER][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
239             matrix[FRONT_CENTER][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
240         } else
241             return AVERROR_PATCHWELCOME;
242     }
243     /* mix left-of-center/right-of-center into front left/right or center */
244     if (unaccounted & AV_CH_FRONT_LEFT_OF_CENTER) {
245         if (out_layout & AV_CH_FRONT_LEFT) {
246             matrix[FRONT_LEFT ][FRONT_LEFT_OF_CENTER ] += 1.0;
247             matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER] += 1.0;
248         } else if (out_layout & AV_CH_FRONT_CENTER) {
249             matrix[FRONT_CENTER][FRONT_LEFT_OF_CENTER ] += M_SQRT1_2;
250             matrix[FRONT_CENTER][FRONT_RIGHT_OF_CENTER] += M_SQRT1_2;
251         } else
252             return AVERROR_PATCHWELCOME;
253     }
254     /* mix LFE into front left/right or center */
255     if (unaccounted & AV_CH_LOW_FREQUENCY) {
256         if (out_layout & AV_CH_FRONT_CENTER) {
257             matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
258         } else if (out_layout & AV_CH_FRONT_LEFT) {
259             matrix[FRONT_LEFT ][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
260             matrix[FRONT_RIGHT][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
261         } else
262             return AVERROR_PATCHWELCOME;
263     }
264
265     /* transfer internal matrix to output matrix and calculate maximum
266        per-channel coefficient sum */
267     for (out_i = i = 0; out_i < out_channels && i < 64; i++) {
268         double sum = 0;
269         for (out_j = j = 0; out_j < in_channels && j < 64; j++) {
270             matrix_out[out_i * stride + out_j] = matrix[i][j];
271             sum += fabs(matrix[i][j]);
272             if (in_layout & (1ULL << j))
273                 out_j++;
274         }
275         maxcoef = FFMAX(maxcoef, sum);
276         if (out_layout & (1ULL << i))
277             out_i++;
278     }
279
280     /* normalize */
281     if (normalize && maxcoef > 1.0) {
282         for (i = 0; i < out_channels; i++)
283             for (j = 0; j < in_channels; j++)
284                 matrix_out[i * stride + j] /= maxcoef;
285     }
286
287     return 0;
288 }
289
290 int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix,
291                           int stride)
292 {
293     int in_channels, out_channels, i, o;
294
295     in_channels  = av_get_channel_layout_nb_channels(avr->in_channel_layout);
296     out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
297
298     if ( in_channels <= 0 ||  in_channels > AVRESAMPLE_MAX_CHANNELS ||
299         out_channels <= 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
300         av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
301         return AVERROR(EINVAL);
302     }
303
304     switch (avr->mix_coeff_type) {
305     case AV_MIX_COEFF_TYPE_Q8:
306         if (!avr->am->matrix_q8[0]) {
307             av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
308             return AVERROR(EINVAL);
309         }
310         for (o = 0; o < out_channels; o++)
311             for (i = 0; i < in_channels; i++)
312                 matrix[o * stride + i] = avr->am->matrix_q8[o][i] / 256.0;
313         break;
314     case AV_MIX_COEFF_TYPE_Q15:
315         if (!avr->am->matrix_q15[0]) {
316             av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
317             return AVERROR(EINVAL);
318         }
319         for (o = 0; o < out_channels; o++)
320             for (i = 0; i < in_channels; i++)
321                 matrix[o * stride + i] = avr->am->matrix_q15[o][i] / 32768.0;
322         break;
323     case AV_MIX_COEFF_TYPE_FLT:
324         if (!avr->am->matrix_flt[0]) {
325             av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
326             return AVERROR(EINVAL);
327         }
328         for (o = 0; o < out_channels; o++)
329             for (i = 0; i < in_channels; i++)
330                 matrix[o * stride + i] = avr->am->matrix_flt[o][i];
331         break;
332     default:
333         av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
334         return AVERROR(EINVAL);
335     }
336
337     return 0;
338 }
339
340 int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
341                           int stride)
342 {
343     int in_channels, out_channels, i, o;
344
345     in_channels  = av_get_channel_layout_nb_channels(avr->in_channel_layout);
346     out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
347
348     if ( in_channels <= 0 ||  in_channels > AVRESAMPLE_MAX_CHANNELS ||
349         out_channels <= 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
350         av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
351         return AVERROR(EINVAL);
352     }
353
354     if (avr->am->matrix) {
355         av_free(avr->am->matrix[0]);
356         avr->am->matrix = NULL;
357     }
358
359 #define CONVERT_MATRIX(type, expr)                                          \
360     avr->am->matrix_## type[0] = av_mallocz(out_channels * in_channels *    \
361                                             sizeof(*avr->am->matrix_## type[0])); \
362     if (!avr->am->matrix_## type[0])                                        \
363         return AVERROR(ENOMEM);                                             \
364     for (o = 0; o < out_channels; o++) {                                    \
365         if (o > 0)                                                          \
366             avr->am->matrix_## type[o] = avr->am->matrix_## type[o - 1] +   \
367                                          in_channels;                       \
368         for (i = 0; i < in_channels; i++) {                                 \
369             double v = matrix[o * stride + i];                              \
370             avr->am->matrix_## type[o][i] = expr;                           \
371         }                                                                   \
372     }                                                                       \
373     avr->am->matrix = (void **)avr->am->matrix_## type;
374
375     switch (avr->mix_coeff_type) {
376     case AV_MIX_COEFF_TYPE_Q8:
377         CONVERT_MATRIX(q8, av_clip_int16(lrint(256.0 * v)))
378         break;
379     case AV_MIX_COEFF_TYPE_Q15:
380         CONVERT_MATRIX(q15, av_clipl_int32(llrint(32768.0 * v)))
381         break;
382     case AV_MIX_COEFF_TYPE_FLT:
383         CONVERT_MATRIX(flt, v)
384         break;
385     default:
386         av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
387         return AVERROR(EINVAL);
388     }
389
390     /* TODO: detect situations where we can just swap around pointers
391              instead of doing matrix multiplications with 0.0 and 1.0 */
392
393     /* set AudioMix params */
394     avr->am->in_layout    = avr->in_channel_layout;
395     avr->am->out_layout   = avr->out_channel_layout;
396     avr->am->in_channels  = in_channels;
397     avr->am->out_channels = out_channels;
398
399     return 0;
400 }