h264: print error on unsupported seperate color planes
[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/libm.h"
25 #include "libavutil/samplefmt.h"
26 #include "avresample.h"
27 #include "internal.h"
28 #include "audio_data.h"
29 #include "audio_mix.h"
30
31 /* channel positions */
32 #define FRONT_LEFT              0
33 #define FRONT_RIGHT             1
34 #define FRONT_CENTER            2
35 #define LOW_FREQUENCY           3
36 #define BACK_LEFT               4
37 #define BACK_RIGHT              5
38 #define FRONT_LEFT_OF_CENTER    6
39 #define FRONT_RIGHT_OF_CENTER   7
40 #define BACK_CENTER             8
41 #define SIDE_LEFT               9
42 #define SIDE_RIGHT             10
43 #define TOP_CENTER             11
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
52 #define WIDE_LEFT              31
53 #define WIDE_RIGHT             32
54 #define SURROUND_DIRECT_LEFT   33
55 #define SURROUND_DIRECT_RIGHT  34
56
57 #define SQRT3_2      1.22474487139158904909  /* sqrt(3/2) */
58
59 static av_always_inline int even(uint64_t layout)
60 {
61     return (!layout || (layout & (layout - 1)));
62 }
63
64 static int sane_layout(uint64_t layout)
65 {
66     /* check that there is at least 1 front speaker */
67     if (!(layout & AV_CH_LAYOUT_SURROUND))
68         return 0;
69
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)))
80         return 0;
81
82     return 1;
83 }
84
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)
90 {
91     int i, j, out_i, out_j;
92     double matrix[64][64] = {{0}};
93     int64_t unaccounted;
94     double maxcoef = 0;
95     int in_channels, out_channels;
96
97     if ((out_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == AV_CH_LAYOUT_STEREO_DOWNMIX) {
98         out_layout = AV_CH_LAYOUT_STEREO;
99     }
100
101     unaccounted = in_layout & ~out_layout;
102
103     in_channels  = av_get_channel_layout_nb_channels( in_layout);
104     out_channels = av_get_channel_layout_nb_channels(out_layout);
105
106     memset(matrix_out, 0, out_channels * stride * sizeof(*matrix_out));
107
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);
113
114     /* check if layouts are unbalanced or abnormal */
115     if (!sane_layout(in_layout) || !sane_layout(out_layout))
116         return AVERROR_PATCHWELCOME;
117
118     /* route matching input/output channels */
119     for (i = 0; i < 64; i++) {
120         if (in_layout & out_layout & (1ULL << i))
121             matrix[i][i] = 1.0;
122     }
123
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;
129         } else
130             return AVERROR_PATCHWELCOME;
131     }
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;
140         } else
141             return AVERROR_PATCHWELCOME;
142     }
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;
157                 } else {
158                     matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
159                     matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
160                 }
161             } else {
162                 matrix[FRONT_LEFT ][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
163                 matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
164             }
165         } else if (out_layout & AV_CH_FRONT_CENTER) {
166             matrix[FRONT_CENTER][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
167         } else
168             return AVERROR_PATCHWELCOME;
169     }
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;
181             } else {
182                 matrix[SIDE_LEFT ][BACK_LEFT ] += 1.0;
183                 matrix[SIDE_RIGHT][BACK_RIGHT] += 1.0;
184             }
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;
196             } else {
197                 matrix[FRONT_LEFT ][BACK_LEFT ] += surround_mix_level;
198                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
199             }
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;
203         } else
204             return AVERROR_PATCHWELCOME;
205     }
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;
214             } else {
215                 matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
216                 matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
217             }
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;
232             } else {
233                 matrix[FRONT_LEFT ][SIDE_LEFT ] += surround_mix_level;
234                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
235             }
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;
239         } else
240             return AVERROR_PATCHWELCOME;
241     }
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;
250         } else
251             return AVERROR_PATCHWELCOME;
252     }
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;
260         } else
261             return AVERROR_PATCHWELCOME;
262     }
263
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++) {
267         double sum = 0;
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))
272                 out_j++;
273         }
274         maxcoef = FFMAX(maxcoef, sum);
275         if (out_layout & (1ULL << i))
276             out_i++;
277     }
278
279     /* normalize */
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;
284     }
285
286     return 0;
287 }
288
289 int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix,
290                           int stride)
291 {
292     int in_channels, out_channels, i, o;
293
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);
296
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);
301     }
302
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);
308         }
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;
312         break;
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);
317         }
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;
321         break;
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);
326         }
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];
330         break;
331     default:
332         av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
333         return AVERROR(EINVAL);
334     }
335     return 0;
336 }
337
338 int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
339                           int stride)
340 {
341     int in_channels, out_channels, i, o;
342
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);
345
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);
350     }
351
352     if (avr->am->matrix)
353         av_freep(avr->am->matrix);
354
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++) {                                    \
361         if (o > 0)                                                          \
362             avr->am->matrix_## type[o] = avr->am->matrix_## type[o - 1] +   \
363                                          in_channels;                       \
364         for (i = 0; i < in_channels; i++) {                                 \
365             double v = matrix[o * stride + i];                              \
366             avr->am->matrix_## type[o][i] = expr;                           \
367         }                                                                   \
368     }                                                                       \
369     avr->am->matrix = (void **)avr->am->matrix_## type;
370
371     switch (avr->mix_coeff_type) {
372     case AV_MIX_COEFF_TYPE_Q8:
373         CONVERT_MATRIX(q8, av_clip_int16(lrint(256.0 * v)))
374         break;
375     case AV_MIX_COEFF_TYPE_Q15:
376         CONVERT_MATRIX(q15, av_clipl_int32(llrint(32768.0 * v)))
377         break;
378     case AV_MIX_COEFF_TYPE_FLT:
379         CONVERT_MATRIX(flt, v)
380         break;
381     default:
382         av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
383         return AVERROR(EINVAL);
384     }
385
386     /* TODO: detect situations where we can just swap around pointers
387              instead of doing matrix multiplications with 0.0 and 1.0 */
388
389     return 0;
390 }