swr: Update version & APIChanges for swr_build_matrix()
[ffmpeg.git] / libswresample / rematrix.c
1 /*
2  * Copyright (C) 2011-2012 Michael Niedermayer (michaelni@gmx.at)
3  *
4  * This file is part of libswresample
5  *
6  * libswresample 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  * libswresample 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 libswresample; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "swresample_internal.h"
22 #include "libavutil/avassert.h"
23 #include "libavutil/channel_layout.h"
24
25 #define TEMPLATE_REMATRIX_FLT
26 #include "rematrix_template.c"
27 #undef TEMPLATE_REMATRIX_FLT
28
29 #define TEMPLATE_REMATRIX_DBL
30 #include "rematrix_template.c"
31 #undef TEMPLATE_REMATRIX_DBL
32
33 #define TEMPLATE_REMATRIX_S16
34 #include "rematrix_template.c"
35 #define TEMPLATE_CLIP
36 #include "rematrix_template.c"
37 #undef TEMPLATE_CLIP
38 #undef TEMPLATE_REMATRIX_S16
39
40 #define TEMPLATE_REMATRIX_S32
41 #include "rematrix_template.c"
42 #undef TEMPLATE_REMATRIX_S32
43
44 #define FRONT_LEFT             0
45 #define FRONT_RIGHT            1
46 #define FRONT_CENTER           2
47 #define LOW_FREQUENCY          3
48 #define BACK_LEFT              4
49 #define BACK_RIGHT             5
50 #define FRONT_LEFT_OF_CENTER   6
51 #define FRONT_RIGHT_OF_CENTER  7
52 #define BACK_CENTER            8
53 #define SIDE_LEFT              9
54 #define SIDE_RIGHT             10
55 #define TOP_CENTER             11
56 #define TOP_FRONT_LEFT         12
57 #define TOP_FRONT_CENTER       13
58 #define TOP_FRONT_RIGHT        14
59 #define TOP_BACK_LEFT          15
60 #define TOP_BACK_CENTER        16
61 #define TOP_BACK_RIGHT         17
62 #define NUM_NAMED_CHANNELS     18
63
64 int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
65 {
66     int nb_in, nb_out, in, out;
67
68     if (!s || s->in_convert) // s needs to be allocated but not initialized
69         return AVERROR(EINVAL);
70     memset(s->matrix, 0, sizeof(s->matrix));
71     nb_in  = av_get_channel_layout_nb_channels(s->user_in_ch_layout);
72     nb_out = av_get_channel_layout_nb_channels(s->user_out_ch_layout);
73     for (out = 0; out < nb_out; out++) {
74         for (in = 0; in < nb_in; in++)
75             s->matrix[out][in] = matrix[in];
76         if (s->int_sample_fmt == AV_SAMPLE_FMT_FLTP)
77             for (in = 0; in < nb_in; in++)
78                 s->matrix_flt[out][in] = matrix[in];
79         matrix += stride;
80     }
81     s->rematrix_custom = 1;
82     return 0;
83 }
84
85 static int even(int64_t layout){
86     if(!layout) return 1;
87     if(layout&(layout-1)) return 1;
88     return 0;
89 }
90
91 static int clean_layout(void *s, int64_t layout){
92     if(layout && layout != AV_CH_FRONT_CENTER && !(layout&(layout-1))) {
93         char buf[128];
94         av_get_channel_layout_string(buf, sizeof(buf), -1, layout);
95         av_log(s, AV_LOG_VERBOSE, "Treating %s as mono\n", buf);
96         return AV_CH_FRONT_CENTER;
97     }
98
99     return layout;
100 }
101
102 static int sane_layout(int64_t layout){
103     if(!(layout & AV_CH_LAYOUT_SURROUND)) // at least 1 front speaker
104         return 0;
105     if(!even(layout & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT))) // no asymetric front
106         return 0;
107     if(!even(layout & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)))   // no asymetric side
108         return 0;
109     if(!even(layout & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)))
110         return 0;
111     if(!even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)))
112         return 0;
113     if(av_get_channel_layout_nb_channels(layout) >= SWR_CH_MAX)
114         return 0;
115
116     return 1;
117 }
118
119 av_cold int swr_build_matrix(uint64_t in_ch_layout_param, uint64_t out_ch_layout_param,
120                              double center_mix_level, double surround_mix_level,
121                              double lfe_mix_level, double maxval,
122                              double rematrix_volume, double *matrix_param,
123                              int stride, enum AVMatrixEncoding matrix_encoding, void *log_context)
124 {
125     int i, j, out_i;
126     double matrix[NUM_NAMED_CHANNELS][NUM_NAMED_CHANNELS]={{0}};
127     int64_t unaccounted, in_ch_layout, out_ch_layout;
128     double maxcoef=0;
129     char buf[128];
130
131      in_ch_layout = clean_layout(log_context,  in_ch_layout_param);
132     out_ch_layout = clean_layout(log_context, out_ch_layout_param);
133
134     if(   out_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
135        && (in_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
136     )
137         out_ch_layout = AV_CH_LAYOUT_STEREO;
138
139     if(    in_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
140        && (out_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
141     )
142         in_ch_layout = AV_CH_LAYOUT_STEREO;
143
144     if(!sane_layout(in_ch_layout)){
145         av_get_channel_layout_string(buf, sizeof(buf), -1, in_ch_layout_param);
146         av_log(log_context, AV_LOG_ERROR, "Input channel layout '%s' is not supported\n", buf);
147         return AVERROR(EINVAL);
148     }
149
150     if(!sane_layout(out_ch_layout)){
151         av_get_channel_layout_string(buf, sizeof(buf), -1, out_ch_layout_param);
152         av_log(log_context, AV_LOG_ERROR, "Output channel layout '%s' is not supported\n", buf);
153         return AVERROR(EINVAL);
154     }
155
156     for(i=0; i<FF_ARRAY_ELEMS(matrix); i++){
157         if(in_ch_layout & out_ch_layout & (1ULL<<i))
158             matrix[i][i]= 1.0;
159     }
160
161     unaccounted= in_ch_layout & ~out_ch_layout;
162
163 //FIXME implement dolby surround
164 //FIXME implement full ac3
165
166
167     if(unaccounted & AV_CH_FRONT_CENTER){
168         if((out_ch_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO){
169             if(in_ch_layout & AV_CH_LAYOUT_STEREO) {
170                 matrix[ FRONT_LEFT][FRONT_CENTER]+= center_mix_level;
171                 matrix[FRONT_RIGHT][FRONT_CENTER]+= center_mix_level;
172             } else {
173                 matrix[ FRONT_LEFT][FRONT_CENTER]+= M_SQRT1_2;
174                 matrix[FRONT_RIGHT][FRONT_CENTER]+= M_SQRT1_2;
175             }
176         }else
177             av_assert0(0);
178     }
179     if(unaccounted & AV_CH_LAYOUT_STEREO){
180         if(out_ch_layout & AV_CH_FRONT_CENTER){
181             matrix[FRONT_CENTER][ FRONT_LEFT]+= M_SQRT1_2;
182             matrix[FRONT_CENTER][FRONT_RIGHT]+= M_SQRT1_2;
183             if(in_ch_layout & AV_CH_FRONT_CENTER)
184                 matrix[FRONT_CENTER][ FRONT_CENTER] = center_mix_level*sqrt(2);
185         }else
186             av_assert0(0);
187     }
188
189     if(unaccounted & AV_CH_BACK_CENTER){
190         if(out_ch_layout & AV_CH_BACK_LEFT){
191             matrix[ BACK_LEFT][BACK_CENTER]+= M_SQRT1_2;
192             matrix[BACK_RIGHT][BACK_CENTER]+= M_SQRT1_2;
193         }else if(out_ch_layout & AV_CH_SIDE_LEFT){
194             matrix[ SIDE_LEFT][BACK_CENTER]+= M_SQRT1_2;
195             matrix[SIDE_RIGHT][BACK_CENTER]+= M_SQRT1_2;
196         }else if(out_ch_layout & AV_CH_FRONT_LEFT){
197             if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
198                 matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
199                 if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
200                     matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level * M_SQRT1_2;
201                     matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
202                 } else {
203                     matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
204                     matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
205                 }
206             } else {
207                 matrix[ FRONT_LEFT][BACK_CENTER]+= surround_mix_level * M_SQRT1_2;
208                 matrix[FRONT_RIGHT][BACK_CENTER]+= surround_mix_level * M_SQRT1_2;
209             }
210         }else if(out_ch_layout & AV_CH_FRONT_CENTER){
211             matrix[ FRONT_CENTER][BACK_CENTER]+= surround_mix_level * M_SQRT1_2;
212         }else
213             av_assert0(0);
214     }
215     if(unaccounted & AV_CH_BACK_LEFT){
216         if(out_ch_layout & AV_CH_BACK_CENTER){
217             matrix[BACK_CENTER][ BACK_LEFT]+= M_SQRT1_2;
218             matrix[BACK_CENTER][BACK_RIGHT]+= M_SQRT1_2;
219         }else if(out_ch_layout & AV_CH_SIDE_LEFT){
220             if(in_ch_layout & AV_CH_SIDE_LEFT){
221                 matrix[ SIDE_LEFT][ BACK_LEFT]+= M_SQRT1_2;
222                 matrix[SIDE_RIGHT][BACK_RIGHT]+= M_SQRT1_2;
223             }else{
224             matrix[ SIDE_LEFT][ BACK_LEFT]+= 1.0;
225             matrix[SIDE_RIGHT][BACK_RIGHT]+= 1.0;
226             }
227         }else if(out_ch_layout & AV_CH_FRONT_LEFT){
228             if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
229                 matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * M_SQRT1_2;
230                 matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
231                 matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
232                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
233             } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
234                 matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * SQRT3_2;
235                 matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
236                 matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
237                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * SQRT3_2;
238             } else {
239                 matrix[ FRONT_LEFT][ BACK_LEFT] += surround_mix_level;
240                 matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
241             }
242         }else if(out_ch_layout & AV_CH_FRONT_CENTER){
243             matrix[ FRONT_CENTER][BACK_LEFT ]+= surround_mix_level*M_SQRT1_2;
244             matrix[ FRONT_CENTER][BACK_RIGHT]+= surround_mix_level*M_SQRT1_2;
245         }else
246             av_assert0(0);
247     }
248
249     if(unaccounted & AV_CH_SIDE_LEFT){
250         if(out_ch_layout & AV_CH_BACK_LEFT){
251             /* if back channels do not exist in the input, just copy side
252                channels to back channels, otherwise mix side into back */
253             if (in_ch_layout & AV_CH_BACK_LEFT) {
254                 matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
255                 matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
256             } else {
257                 matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
258                 matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
259             }
260         }else if(out_ch_layout & AV_CH_BACK_CENTER){
261             matrix[BACK_CENTER][ SIDE_LEFT]+= M_SQRT1_2;
262             matrix[BACK_CENTER][SIDE_RIGHT]+= M_SQRT1_2;
263         }else if(out_ch_layout & AV_CH_FRONT_LEFT){
264             if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
265                 matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * M_SQRT1_2;
266                 matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
267                 matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
268                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
269             } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
270                 matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * SQRT3_2;
271                 matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
272                 matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
273                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * SQRT3_2;
274             } else {
275                 matrix[ FRONT_LEFT][ SIDE_LEFT] += surround_mix_level;
276                 matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
277             }
278         }else if(out_ch_layout & AV_CH_FRONT_CENTER){
279             matrix[ FRONT_CENTER][SIDE_LEFT ]+= surround_mix_level * M_SQRT1_2;
280             matrix[ FRONT_CENTER][SIDE_RIGHT]+= surround_mix_level * M_SQRT1_2;
281         }else
282             av_assert0(0);
283     }
284
285     if(unaccounted & AV_CH_FRONT_LEFT_OF_CENTER){
286         if(out_ch_layout & AV_CH_FRONT_LEFT){
287             matrix[ FRONT_LEFT][ FRONT_LEFT_OF_CENTER]+= 1.0;
288             matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER]+= 1.0;
289         }else if(out_ch_layout & AV_CH_FRONT_CENTER){
290             matrix[ FRONT_CENTER][ FRONT_LEFT_OF_CENTER]+= M_SQRT1_2;
291             matrix[ FRONT_CENTER][FRONT_RIGHT_OF_CENTER]+= M_SQRT1_2;
292         }else
293             av_assert0(0);
294     }
295     /* mix LFE into front left/right or center */
296     if (unaccounted & AV_CH_LOW_FREQUENCY) {
297         if (out_ch_layout & AV_CH_FRONT_CENTER) {
298             matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
299         } else if (out_ch_layout & AV_CH_FRONT_LEFT) {
300             matrix[FRONT_LEFT ][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
301             matrix[FRONT_RIGHT][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
302         } else
303             av_assert0(0);
304     }
305
306     for(out_i=i=0; i<64; i++){
307         double sum=0;
308         int in_i=0;
309         if((out_ch_layout & (1ULL<<i)) == 0)
310             continue;
311         for(j=0; j<64; j++){
312             if((in_ch_layout & (1ULL<<j)) == 0)
313                continue;
314             if (i < FF_ARRAY_ELEMS(matrix) && j < FF_ARRAY_ELEMS(matrix[0]))
315                 matrix_param[stride*out_i + in_i] = matrix[i][j];
316             else
317                 matrix_param[stride*out_i + in_i] = i == j && (in_ch_layout & out_ch_layout & (1ULL<<i));
318             sum += fabs(matrix_param[stride*out_i + in_i]);
319             in_i++;
320         }
321         maxcoef= FFMAX(maxcoef, sum);
322         out_i++;
323     }
324     if(rematrix_volume  < 0)
325         maxcoef = -rematrix_volume;
326
327     if(maxcoef > maxval || rematrix_volume  < 0){
328         maxcoef /= maxval;
329         for(i=0; i<SWR_CH_MAX; i++)
330             for(j=0; j<SWR_CH_MAX; j++){
331                 matrix_param[stride*i + j] /= maxcoef;
332             }
333     }
334
335     if(rematrix_volume > 0){
336         for(i=0; i<SWR_CH_MAX; i++)
337             for(j=0; j<SWR_CH_MAX; j++){
338                 matrix_param[stride*i + j] *= rematrix_volume;
339             }
340     }
341
342     av_log(log_context, AV_LOG_DEBUG, "Matrix coefficients:\n");
343     for(i=0; i<av_get_channel_layout_nb_channels(out_ch_layout); i++){
344         const char *c =
345             av_get_channel_name(av_channel_layout_extract_channel(out_ch_layout, i));
346         av_log(log_context, AV_LOG_DEBUG, "%s: ", c ? c : "?");
347         for(j=0; j<av_get_channel_layout_nb_channels(in_ch_layout); j++){
348             c = av_get_channel_name(av_channel_layout_extract_channel(in_ch_layout, j));
349             av_log(log_context, AV_LOG_DEBUG, "%s:%f ", c ? c : "?", matrix_param[stride*i + j]);
350         }
351         av_log(log_context, AV_LOG_DEBUG, "\n");
352     }
353     return 0;
354 }
355
356 av_cold static int auto_matrix(SwrContext *s)
357 {
358     double maxval;
359     int ret;
360
361     if (s->rematrix_maxval > 0) {
362         maxval = s->rematrix_maxval;
363     } else if (   av_get_packed_sample_fmt(s->out_sample_fmt) < AV_SAMPLE_FMT_FLT
364                || av_get_packed_sample_fmt(s->int_sample_fmt) < AV_SAMPLE_FMT_FLT) {
365         maxval = 1.0;
366     } else
367         maxval = INT_MAX;
368
369     memset(s->matrix, 0, sizeof(s->matrix));
370     ret = swr_build_matrix(s->in_ch_layout, s->out_ch_layout,
371                            s->clev, s->slev, s->lfe_mix_level,
372                            maxval, s->rematrix_volume, (double*)s->matrix,
373                            s->matrix[1] - s->matrix[0], s->matrix_encoding, s);
374
375     if (ret >= 0 && s->int_sample_fmt == AV_SAMPLE_FMT_FLTP) {
376         int i;
377         for (i = 0; i < FF_ARRAY_ELEMS(s->matrix[0])*FF_ARRAY_ELEMS(s->matrix[0]); i++)
378             s->matrix_flt[0][i] = s->matrix[0][i];
379     }
380
381     return ret;
382 }
383
384 av_cold int swri_rematrix_init(SwrContext *s){
385     int i, j;
386     int nb_in  = av_get_channel_layout_nb_channels(s->in_ch_layout);
387     int nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);
388
389     s->mix_any_f = NULL;
390
391     if (!s->rematrix_custom) {
392         int r = auto_matrix(s);
393         if (r)
394             return r;
395     }
396     if (s->midbuf.fmt == AV_SAMPLE_FMT_S16P){
397         int maxsum = 0;
398         s->native_matrix = av_calloc(nb_in * nb_out, sizeof(int));
399         s->native_one    = av_mallocz(sizeof(int));
400         if (!s->native_matrix || !s->native_one)
401             return AVERROR(ENOMEM);
402         for (i = 0; i < nb_out; i++) {
403             double rem = 0;
404             int sum = 0;
405
406             for (j = 0; j < nb_in; j++) {
407                 double target = s->matrix[i][j] * 32768 + rem;
408                 ((int*)s->native_matrix)[i * nb_in + j] = lrintf(target);
409                 rem += target - ((int*)s->native_matrix)[i * nb_in + j];
410                 sum += FFABS(((int*)s->native_matrix)[i * nb_in + j]);
411             }
412             maxsum = FFMAX(maxsum, sum);
413         }
414         *((int*)s->native_one) = 32768;
415         if (maxsum <= 32768) {
416             s->mix_1_1_f = (mix_1_1_func_type*)copy_s16;
417             s->mix_2_1_f = (mix_2_1_func_type*)sum2_s16;
418             s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s16(s);
419         } else {
420             s->mix_1_1_f = (mix_1_1_func_type*)copy_clip_s16;
421             s->mix_2_1_f = (mix_2_1_func_type*)sum2_clip_s16;
422             s->mix_any_f = (mix_any_func_type*)get_mix_any_func_clip_s16(s);
423         }
424     }else if(s->midbuf.fmt == AV_SAMPLE_FMT_FLTP){
425         s->native_matrix = av_calloc(nb_in * nb_out, sizeof(float));
426         s->native_one    = av_mallocz(sizeof(float));
427         if (!s->native_matrix || !s->native_one)
428             return AVERROR(ENOMEM);
429         for (i = 0; i < nb_out; i++)
430             for (j = 0; j < nb_in; j++)
431                 ((float*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
432         *((float*)s->native_one) = 1.0;
433         s->mix_1_1_f = (mix_1_1_func_type*)copy_float;
434         s->mix_2_1_f = (mix_2_1_func_type*)sum2_float;
435         s->mix_any_f = (mix_any_func_type*)get_mix_any_func_float(s);
436     }else if(s->midbuf.fmt == AV_SAMPLE_FMT_DBLP){
437         s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
438         s->native_one    = av_mallocz(sizeof(double));
439         if (!s->native_matrix || !s->native_one)
440             return AVERROR(ENOMEM);
441         for (i = 0; i < nb_out; i++)
442             for (j = 0; j < nb_in; j++)
443                 ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
444         *((double*)s->native_one) = 1.0;
445         s->mix_1_1_f = (mix_1_1_func_type*)copy_double;
446         s->mix_2_1_f = (mix_2_1_func_type*)sum2_double;
447         s->mix_any_f = (mix_any_func_type*)get_mix_any_func_double(s);
448     }else if(s->midbuf.fmt == AV_SAMPLE_FMT_S32P){
449         // Only for dithering currently
450 //         s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
451         s->native_one    = av_mallocz(sizeof(int));
452         if (!s->native_one)
453             return AVERROR(ENOMEM);
454 //         for (i = 0; i < nb_out; i++)
455 //             for (j = 0; j < nb_in; j++)
456 //                 ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
457         *((int*)s->native_one) = 32768;
458         s->mix_1_1_f = (mix_1_1_func_type*)copy_s32;
459         s->mix_2_1_f = (mix_2_1_func_type*)sum2_s32;
460         s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s32(s);
461     }else
462         av_assert0(0);
463     //FIXME quantize for integeres
464     for (i = 0; i < SWR_CH_MAX; i++) {
465         int ch_in=0;
466         for (j = 0; j < SWR_CH_MAX; j++) {
467             s->matrix32[i][j]= lrintf(s->matrix[i][j] * 32768);
468             if(s->matrix[i][j])
469                 s->matrix_ch[i][++ch_in]= j;
470         }
471         s->matrix_ch[i][0]= ch_in;
472     }
473
474     if(HAVE_YASM && HAVE_MMX)
475         return swri_rematrix_init_x86(s);
476
477     return 0;
478 }
479
480 av_cold void swri_rematrix_free(SwrContext *s){
481     av_freep(&s->native_matrix);
482     av_freep(&s->native_one);
483     av_freep(&s->native_simd_matrix);
484     av_freep(&s->native_simd_one);
485 }
486
487 int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy){
488     int out_i, in_i, i, j;
489     int len1 = 0;
490     int off = 0;
491
492     if(s->mix_any_f) {
493         s->mix_any_f(out->ch, (const uint8_t **)in->ch, s->native_matrix, len);
494         return 0;
495     }
496
497     if(s->mix_2_1_simd || s->mix_1_1_simd){
498         len1= len&~15;
499         off = len1 * out->bps;
500     }
501
502     av_assert0(!s->out_ch_layout || out->ch_count == av_get_channel_layout_nb_channels(s->out_ch_layout));
503     av_assert0(!s-> in_ch_layout || in ->ch_count == av_get_channel_layout_nb_channels(s-> in_ch_layout));
504
505     for(out_i=0; out_i<out->ch_count; out_i++){
506         switch(s->matrix_ch[out_i][0]){
507         case 0:
508             if(mustcopy)
509                 memset(out->ch[out_i], 0, len * av_get_bytes_per_sample(s->int_sample_fmt));
510             break;
511         case 1:
512             in_i= s->matrix_ch[out_i][1];
513             if(s->matrix[out_i][in_i]!=1.0){
514                 if(s->mix_1_1_simd && len1)
515                     s->mix_1_1_simd(out->ch[out_i]    , in->ch[in_i]    , s->native_simd_matrix, in->ch_count*out_i + in_i, len1);
516                 if(len != len1)
517                     s->mix_1_1_f   (out->ch[out_i]+off, in->ch[in_i]+off, s->native_matrix, in->ch_count*out_i + in_i, len-len1);
518             }else if(mustcopy){
519                 memcpy(out->ch[out_i], in->ch[in_i], len*out->bps);
520             }else{
521                 out->ch[out_i]= in->ch[in_i];
522             }
523             break;
524         case 2: {
525             int in_i1 = s->matrix_ch[out_i][1];
526             int in_i2 = s->matrix_ch[out_i][2];
527             if(s->mix_2_1_simd && len1)
528                 s->mix_2_1_simd(out->ch[out_i]    , in->ch[in_i1]    , in->ch[in_i2]    , s->native_simd_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len1);
529             else
530                 s->mix_2_1_f   (out->ch[out_i]    , in->ch[in_i1]    , in->ch[in_i2]    , s->native_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len1);
531             if(len != len1)
532                 s->mix_2_1_f   (out->ch[out_i]+off, in->ch[in_i1]+off, in->ch[in_i2]+off, s->native_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len-len1);
533             break;}
534         default:
535             if(s->int_sample_fmt == AV_SAMPLE_FMT_FLTP){
536                 for(i=0; i<len; i++){
537                     float v=0;
538                     for(j=0; j<s->matrix_ch[out_i][0]; j++){
539                         in_i= s->matrix_ch[out_i][1+j];
540                         v+= ((float*)in->ch[in_i])[i] * s->matrix_flt[out_i][in_i];
541                     }
542                     ((float*)out->ch[out_i])[i]= v;
543                 }
544             }else if(s->int_sample_fmt == AV_SAMPLE_FMT_DBLP){
545                 for(i=0; i<len; i++){
546                     double v=0;
547                     for(j=0; j<s->matrix_ch[out_i][0]; j++){
548                         in_i= s->matrix_ch[out_i][1+j];
549                         v+= ((double*)in->ch[in_i])[i] * s->matrix[out_i][in_i];
550                     }
551                     ((double*)out->ch[out_i])[i]= v;
552                 }
553             }else{
554                 for(i=0; i<len; i++){
555                     int v=0;
556                     for(j=0; j<s->matrix_ch[out_i][0]; j++){
557                         in_i= s->matrix_ch[out_i][1+j];
558                         v+= ((int16_t*)in->ch[in_i])[i] * s->matrix32[out_i][in_i];
559                     }
560                     ((int16_t*)out->ch[out_i])[i]= (v + 16384)>>15;
561                 }
562             }
563         }
564     }
565     return 0;
566 }