[deb_ffmpeg.git] / ffmpeg / libavresample / audio_mix_matrix.c

/*
 * Copyright (C) 2011 Michael Niedermayer (michaelni@gmx.at)
 * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdint.h>

#include "libavutil/common.h"
#include "libavutil/libm.h"
#include "libavutil/samplefmt.h"
#include "avresample.h"
#include "internal.h"
#include "audio_data.h"
#include "audio_mix.h"

/* channel positions */
#define FRONT_LEFT              0
#define FRONT_RIGHT             1
#define FRONT_CENTER            2
#define LOW_FREQUENCY           3
#define BACK_LEFT               4
#define BACK_RIGHT              5
#define FRONT_LEFT_OF_CENTER    6
#define FRONT_RIGHT_OF_CENTER   7
#define BACK_CENTER             8
#define SIDE_LEFT               9
#define SIDE_RIGHT             10
#define TOP_CENTER             11
#define TOP_FRONT_LEFT         12
#define TOP_FRONT_CENTER       13
#define TOP_FRONT_RIGHT        14
#define TOP_BACK_LEFT          15
#define TOP_BACK_CENTER        16
#define TOP_BACK_RIGHT         17
#define STEREO_LEFT            29
#define STEREO_RIGHT           30
#define WIDE_LEFT              31
#define WIDE_RIGHT             32
#define SURROUND_DIRECT_LEFT   33
#define SURROUND_DIRECT_RIGHT  34
#define LOW_FREQUENCY_2        35

#define SQRT3_2      1.22474487139158904909  /* sqrt(3/2) */

static av_always_inline int even(uint64_t layout)
{
    return (!layout || !!(layout & (layout - 1)));
}

static int sane_layout(uint64_t layout)
{
    /* check that there is at least 1 front speaker */
    if (!(layout & AV_CH_LAYOUT_SURROUND))
        return 0;

    /* check for left/right symmetry */
    if (!even(layout & (AV_CH_FRONT_LEFT           | AV_CH_FRONT_RIGHT))           ||
        !even(layout & (AV_CH_SIDE_LEFT            | AV_CH_SIDE_RIGHT))            ||
        !even(layout & (AV_CH_BACK_LEFT            | AV_CH_BACK_RIGHT))            ||
        !even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)) ||
        !even(layout & (AV_CH_TOP_FRONT_LEFT       | AV_CH_TOP_FRONT_RIGHT))       ||
        !even(layout & (AV_CH_TOP_BACK_LEFT        | AV_CH_TOP_BACK_RIGHT))        ||
        !even(layout & (AV_CH_STEREO_LEFT          | AV_CH_STEREO_RIGHT))          ||
        !even(layout & (AV_CH_WIDE_LEFT            | AV_CH_WIDE_RIGHT))            ||
        !even(layout & (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)))
        return 0;

    return 1;
}

int avresample_build_matrix(uint64_t in_layout, uint64_t out_layout,
                            double center_mix_level, double surround_mix_level,
                            double lfe_mix_level, int normalize,
                            double *matrix_out, int stride,
                            enum AVMatrixEncoding matrix_encoding)
{
    int i, j, out_i, out_j;
    double matrix[64][64] = {{0}};
    int64_t unaccounted;
    double maxcoef = 0;
    int in_channels, out_channels;

    if ((out_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == AV_CH_LAYOUT_STEREO_DOWNMIX) {
        out_layout = AV_CH_LAYOUT_STEREO;
    }

    unaccounted = in_layout & ~out_layout;

    in_channels  = av_get_channel_layout_nb_channels( in_layout);
    out_channels = av_get_channel_layout_nb_channels(out_layout);

    memset(matrix_out, 0, out_channels * stride * sizeof(*matrix_out));

    /* check if layouts are supported */
    if (!in_layout || in_channels > AVRESAMPLE_MAX_CHANNELS)
        return AVERROR(EINVAL);
    if (!out_layout || out_channels > AVRESAMPLE_MAX_CHANNELS)
        return AVERROR(EINVAL);

    /* check if layouts are unbalanced or abnormal */
    if (!sane_layout(in_layout) || !sane_layout(out_layout))
        return AVERROR_PATCHWELCOME;

    /* route matching input/output channels */
    for (i = 0; i < 64; i++) {
        if (in_layout & out_layout & (1ULL << i))
            matrix[i][i] = 1.0;
    }

    /* mix front center to front left/right */
    if (unaccounted & AV_CH_FRONT_CENTER) {
        if ((out_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
            if ((in_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
                matrix[FRONT_LEFT ][FRONT_CENTER] += center_mix_level;
                matrix[FRONT_RIGHT][FRONT_CENTER] += center_mix_level;
            } else {
                matrix[FRONT_LEFT ][FRONT_CENTER] += M_SQRT1_2;
                matrix[FRONT_RIGHT][FRONT_CENTER] += M_SQRT1_2;
            }
        } else
            return AVERROR_PATCHWELCOME;
    }
    /* mix front left/right to center */
    if (unaccounted & AV_CH_LAYOUT_STEREO) {
        if (out_layout & AV_CH_FRONT_CENTER) {
            matrix[FRONT_CENTER][FRONT_LEFT ] += M_SQRT1_2;
            matrix[FRONT_CENTER][FRONT_RIGHT] += M_SQRT1_2;
            /* mix left/right/center to center */
            if (in_layout & AV_CH_FRONT_CENTER)
                matrix[FRONT_CENTER][FRONT_CENTER] = center_mix_level * M_SQRT2;
        } else
            return AVERROR_PATCHWELCOME;
    }
    /* mix back center to back, side, or front */
    if (unaccounted & AV_CH_BACK_CENTER) {
        if (out_layout & AV_CH_BACK_LEFT) {
            matrix[BACK_LEFT ][BACK_CENTER] += M_SQRT1_2;
            matrix[BACK_RIGHT][BACK_CENTER] += M_SQRT1_2;
        } else if (out_layout & AV_CH_SIDE_LEFT) {
            matrix[SIDE_LEFT ][BACK_CENTER] += M_SQRT1_2;
            matrix[SIDE_RIGHT][BACK_CENTER] += M_SQRT1_2;
        } else if (out_layout & AV_CH_FRONT_LEFT) {
            if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
                matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
                if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
                    matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level * M_SQRT1_2;
                    matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
                } else {
                    matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
                    matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
                }
            } else {
                matrix[FRONT_LEFT ][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
            }
        } else if (out_layout & AV_CH_FRONT_CENTER) {
            matrix[FRONT_CENTER][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
        } else
            return AVERROR_PATCHWELCOME;
    }
    /* mix back left/right to back center, side, or front */
    if (unaccounted & AV_CH_BACK_LEFT) {
        if (out_layout & AV_CH_BACK_CENTER) {
            matrix[BACK_CENTER][BACK_LEFT ] += M_SQRT1_2;
            matrix[BACK_CENTER][BACK_RIGHT] += M_SQRT1_2;
        } else if (out_layout & AV_CH_SIDE_LEFT) {
            /* if side channels do not exist in the input, just copy back
               channels to side channels, otherwise mix back into side */
            if (in_layout & AV_CH_SIDE_LEFT) {
                matrix[SIDE_LEFT ][BACK_LEFT ] += M_SQRT1_2;
                matrix[SIDE_RIGHT][BACK_RIGHT] += M_SQRT1_2;
            } else {
                matrix[SIDE_LEFT ][BACK_LEFT ] += 1.0;
                matrix[SIDE_RIGHT][BACK_RIGHT] += 1.0;
            }
        } else if (out_layout & AV_CH_FRONT_LEFT) {
            if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
                matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * M_SQRT1_2;
                matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
            } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
                matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * SQRT3_2;
                matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * SQRT3_2;
            } else {
                matrix[FRONT_LEFT ][BACK_LEFT ] += surround_mix_level;
                matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
            }
        } else if (out_layout & AV_CH_FRONT_CENTER) {
            matrix[FRONT_CENTER][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
            matrix[FRONT_CENTER][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
        } else
            return AVERROR_PATCHWELCOME;
    }
    /* mix side left/right into back or front */
    if (unaccounted & AV_CH_SIDE_LEFT) {
        if (out_layout & AV_CH_BACK_LEFT) {
            /* if back channels do not exist in the input, just copy side
               channels to back channels, otherwise mix side into back */
            if (in_layout & AV_CH_BACK_LEFT) {
                matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
                matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
            } else {
                matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
                matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
            }
        } else if (out_layout & AV_CH_BACK_CENTER) {
            matrix[BACK_CENTER][SIDE_LEFT ] += M_SQRT1_2;
            matrix[BACK_CENTER][SIDE_RIGHT] += M_SQRT1_2;
        } else if (out_layout & AV_CH_FRONT_LEFT) {
            if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
                matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * M_SQRT1_2;
                matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
            } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
                matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * SQRT3_2;
                matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
                matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * SQRT3_2;
            } else {
                matrix[FRONT_LEFT ][SIDE_LEFT ] += surround_mix_level;
                matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
            }
        } else if (out_layout & AV_CH_FRONT_CENTER) {
            matrix[FRONT_CENTER][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
            matrix[FRONT_CENTER][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
        } else
            return AVERROR_PATCHWELCOME;
    }
    /* mix left-of-center/right-of-center into front left/right or center */
    if (unaccounted & AV_CH_FRONT_LEFT_OF_CENTER) {
        if (out_layout & AV_CH_FRONT_LEFT) {
            matrix[FRONT_LEFT ][FRONT_LEFT_OF_CENTER ] += 1.0;
            matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER] += 1.0;
        } else if (out_layout & AV_CH_FRONT_CENTER) {
            matrix[FRONT_CENTER][FRONT_LEFT_OF_CENTER ] += M_SQRT1_2;
            matrix[FRONT_CENTER][FRONT_RIGHT_OF_CENTER] += M_SQRT1_2;
        } else
            return AVERROR_PATCHWELCOME;
    }
    /* mix LFE into front left/right or center */
    if (unaccounted & AV_CH_LOW_FREQUENCY) {
        if (out_layout & AV_CH_FRONT_CENTER) {
            matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
        } else if (out_layout & AV_CH_FRONT_LEFT) {
            matrix[FRONT_LEFT ][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
            matrix[FRONT_RIGHT][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
        } else
            return AVERROR_PATCHWELCOME;
    }

    /* transfer internal matrix to output matrix and calculate maximum
       per-channel coefficient sum */
    for (out_i = i = 0; out_i < out_channels && i < 64; i++) {
        double sum = 0;
        for (out_j = j = 0; out_j < in_channels && j < 64; j++) {
            matrix_out[out_i * stride + out_j] = matrix[i][j];
            sum += fabs(matrix[i][j]);
            if (in_layout & (1ULL << j))
                out_j++;
        }
        maxcoef = FFMAX(maxcoef, sum);
        if (out_layout & (1ULL << i))
            out_i++;
    }

    /* normalize */
    if (normalize && maxcoef > 1.0) {
        for (i = 0; i < out_channels; i++)
            for (j = 0; j < in_channels; j++)
                matrix_out[i * stride + j] /= maxcoef;
    }

    return 0;
}
Commit	Line	Data
2ba45a60 DM	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 FFmpeg.
	6	*
	7	* FFmpeg 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	* FFmpeg 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 FFmpeg; 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	#define LOW_FREQUENCY_2 35
	58
	59	#define SQRT3_2 1.22474487139158904909 /* sqrt(3/2) */
	60
	61	static av_always_inline int even(uint64_t layout)
	62	{
f6fa7814	63	return (!layout \|\| !!(layout & (layout - 1)));
2ba45a60 DM	64	}
	65
	66	static int sane_layout(uint64_t layout)
	67	{
	68	/* check that there is at least 1 front speaker */
	69	if (!(layout & AV_CH_LAYOUT_SURROUND))
	70	return 0;
	71
	72	/* check for left/right symmetry */
	73	if (!even(layout & (AV_CH_FRONT_LEFT \| AV_CH_FRONT_RIGHT)) \|\|
	74	!even(layout & (AV_CH_SIDE_LEFT \| AV_CH_SIDE_RIGHT)) \|\|
	75	!even(layout & (AV_CH_BACK_LEFT \| AV_CH_BACK_RIGHT)) \|\|
	76	!even(layout & (AV_CH_FRONT_LEFT_OF_CENTER \| AV_CH_FRONT_RIGHT_OF_CENTER)) \|\|
	77	!even(layout & (AV_CH_TOP_FRONT_LEFT \| AV_CH_TOP_FRONT_RIGHT)) \|\|
	78	!even(layout & (AV_CH_TOP_BACK_LEFT \| AV_CH_TOP_BACK_RIGHT)) \|\|
	79	!even(layout & (AV_CH_STEREO_LEFT \| AV_CH_STEREO_RIGHT)) \|\|
	80	!even(layout & (AV_CH_WIDE_LEFT \| AV_CH_WIDE_RIGHT)) \|\|
	81	!even(layout & (AV_CH_SURROUND_DIRECT_LEFT \| AV_CH_SURROUND_DIRECT_RIGHT)))
	82	return 0;
	83
	84	return 1;
	85	}
	86
	87	int avresample_build_matrix(uint64_t in_layout, uint64_t out_layout,
	88	double center_mix_level, double surround_mix_level,
	89	double lfe_mix_level, int normalize,
	90	double *matrix_out, int stride,
	91	enum AVMatrixEncoding matrix_encoding)
	92	{
	93	int i, j, out_i, out_j;
	94	double matrix[64][64] = {{0}};
	95	int64_t unaccounted;
	96	double maxcoef = 0;
	97	int in_channels, out_channels;
	98
	99	if ((out_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == AV_CH_LAYOUT_STEREO_DOWNMIX) {
	100	out_layout = AV_CH_LAYOUT_STEREO;
	101	}
	102
	103	unaccounted = in_layout & ~out_layout;
	104
	105	in_channels = av_get_channel_layout_nb_channels( in_layout);
	106	out_channels = av_get_channel_layout_nb_channels(out_layout);
	107
	108	memset(matrix_out, 0, out_channels * stride * sizeof(*matrix_out));
	109
	110	/* check if layouts are supported */
	111	if (!in_layout \|\| in_channels > AVRESAMPLE_MAX_CHANNELS)
	112	return AVERROR(EINVAL);
	113	if (!out_layout \|\| out_channels > AVRESAMPLE_MAX_CHANNELS)
	114	return AVERROR(EINVAL);
	115
	116	/* check if layouts are unbalanced or abnormal */
	117	if (!sane_layout(in_layout) \|\| !sane_layout(out_layout))
	118	return AVERROR_PATCHWELCOME;
	119
	120	/* route matching input/output channels */
	121	for (i = 0; i < 64; i++) {
	122	if (in_layout & out_layout & (1ULL << i))
	123	matrix[i][i] = 1.0;
	124	}
	125
	126	/* mix front center to front left/right */
	127	if (unaccounted & AV_CH_FRONT_CENTER) {
128	if ((out_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
129	if ((in_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
130	matrix[FRONT_LEFT ][FRONT_CENTER] += center_mix_level;
131	matrix[FRONT_RIGHT][FRONT_CENTER] += center_mix_level;
132	} else {
133	matrix[FRONT_LEFT ][FRONT_CENTER] += M_SQRT1_2;
134	matrix[FRONT_RIGHT][FRONT_CENTER] += M_SQRT1_2;
135	}
136	} else
137	return AVERROR_PATCHWELCOME;
138	}
139	/* mix front left/right to center */
140	if (unaccounted & AV_CH_LAYOUT_STEREO) {
141	if (out_layout & AV_CH_FRONT_CENTER) {
142	matrix[FRONT_CENTER][FRONT_LEFT ] += M_SQRT1_2;
143	matrix[FRONT_CENTER][FRONT_RIGHT] += M_SQRT1_2;
144	/* mix left/right/center to center */
145	if (in_layout & AV_CH_FRONT_CENTER)
146	matrix[FRONT_CENTER][FRONT_CENTER] = center_mix_level * M_SQRT2;
147	} else
148	return AVERROR_PATCHWELCOME;
149	}
150	/* mix back center to back, side, or front */
151	if (unaccounted & AV_CH_BACK_CENTER) {
152	if (out_layout & AV_CH_BACK_LEFT) {
153	matrix[BACK_LEFT ][BACK_CENTER] += M_SQRT1_2;
154	matrix[BACK_RIGHT][BACK_CENTER] += M_SQRT1_2;
155	} else if (out_layout & AV_CH_SIDE_LEFT) {
156	matrix[SIDE_LEFT ][BACK_CENTER] += M_SQRT1_2;
157	matrix[SIDE_RIGHT][BACK_CENTER] += M_SQRT1_2;
158	} else if (out_layout & AV_CH_FRONT_LEFT) {
159	if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY \|\|
160	matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
161	if (unaccounted & (AV_CH_BACK_LEFT \| AV_CH_SIDE_LEFT)) {
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	} else {
165	matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
166	matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
167	}
168	} else {
169	matrix[FRONT_LEFT ][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
170	matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
171	}
172	} else if (out_layout & AV_CH_FRONT_CENTER) {
173	matrix[FRONT_CENTER][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
174	} else
175	return AVERROR_PATCHWELCOME;
176	}
177	/* mix back left/right to back center, side, or front */
178	if (unaccounted & AV_CH_BACK_LEFT) {
179	if (out_layout & AV_CH_BACK_CENTER) {
180	matrix[BACK_CENTER][BACK_LEFT ] += M_SQRT1_2;
181	matrix[BACK_CENTER][BACK_RIGHT] += M_SQRT1_2;
182	} else if (out_layout & AV_CH_SIDE_LEFT) {
183	/* if side channels do not exist in the input, just copy back
184	channels to side channels, otherwise mix back into side */
185	if (in_layout & AV_CH_SIDE_LEFT) {
186	matrix[SIDE_LEFT ][BACK_LEFT ] += M_SQRT1_2;
187	matrix[SIDE_RIGHT][BACK_RIGHT] += M_SQRT1_2;
188	} else {
189	matrix[SIDE_LEFT ][BACK_LEFT ] += 1.0;
190	matrix[SIDE_RIGHT][BACK_RIGHT] += 1.0;
191	}
192	} else if (out_layout & AV_CH_FRONT_LEFT) {
193	if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
194	matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * M_SQRT1_2;
195	matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
196	matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
197	matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
198	} else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
199	matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * SQRT3_2;
200	matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
201	matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
202	matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * SQRT3_2;
203	} else {
204	matrix[FRONT_LEFT ][BACK_LEFT ] += surround_mix_level;
205	matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
206	}
207	} else if (out_layout & AV_CH_FRONT_CENTER) {
208	matrix[FRONT_CENTER][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
209	matrix[FRONT_CENTER][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
210	} else
211	return AVERROR_PATCHWELCOME;
212	}
213	/* mix side left/right into back or front */
214	if (unaccounted & AV_CH_SIDE_LEFT) {
215	if (out_layout & AV_CH_BACK_LEFT) {
216	/* if back channels do not exist in the input, just copy side
217	channels to back channels, otherwise mix side into back */
218	if (in_layout & AV_CH_BACK_LEFT) {
219	matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
220	matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
221	} else {
222	matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
223	matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
224	}
225	} else if (out_layout & AV_CH_BACK_CENTER) {
226	matrix[BACK_CENTER][SIDE_LEFT ] += M_SQRT1_2;
227	matrix[BACK_CENTER][SIDE_RIGHT] += M_SQRT1_2;
228	} else if (out_layout & AV_CH_FRONT_LEFT) {
229	if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
230	matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * M_SQRT1_2;
231	matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
232	matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
233	matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
234	} else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
235	matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * SQRT3_2;
236	matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
237	matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
238	matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * SQRT3_2;
239	} else {
240	matrix[FRONT_LEFT ][SIDE_LEFT ] += surround_mix_level;
241	matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
242	}
243	} else if (out_layout & AV_CH_FRONT_CENTER) {
244	matrix[FRONT_CENTER][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
245	matrix[FRONT_CENTER][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
246	} else
247	return AVERROR_PATCHWELCOME;
248	}
249	/* mix left-of-center/right-of-center into front left/right or center */
250	if (unaccounted & AV_CH_FRONT_LEFT_OF_CENTER) {
251	if (out_layout & AV_CH_FRONT_LEFT) {
252	matrix[FRONT_LEFT ][FRONT_LEFT_OF_CENTER ] += 1.0;
253	matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER] += 1.0;
254	} else if (out_layout & AV_CH_FRONT_CENTER) {
255	matrix[FRONT_CENTER][FRONT_LEFT_OF_CENTER ] += M_SQRT1_2;
256	matrix[FRONT_CENTER][FRONT_RIGHT_OF_CENTER] += M_SQRT1_2;
257	} else
258	return AVERROR_PATCHWELCOME;
259	}
260	/* mix LFE into front left/right or center */
261	if (unaccounted & AV_CH_LOW_FREQUENCY) {
262	if (out_layout & AV_CH_FRONT_CENTER) {
263	matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
264	} else if (out_layout & AV_CH_FRONT_LEFT) {
265	matrix[FRONT_LEFT ][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
266	matrix[FRONT_RIGHT][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
267	} else
268	return AVERROR_PATCHWELCOME;
269	}
270
271	/* transfer internal matrix to output matrix and calculate maximum
272	per-channel coefficient sum */
273	for (out_i = i = 0; out_i < out_channels && i < 64; i++) {
274	double sum = 0;
275	for (out_j = j = 0; out_j < in_channels && j < 64; j++) {
276	matrix_out[out_i * stride + out_j] = matrix[i][j];
277	sum += fabs(matrix[i][j]);
278	if (in_layout & (1ULL << j))
279	out_j++;
280	}
281	maxcoef = FFMAX(maxcoef, sum);
282	if (out_layout & (1ULL << i))
283	out_i++;
284	}
285
286	/* normalize */
287	if (normalize && maxcoef > 1.0) {
288	for (i = 0; i < out_channels; i++)
289	for (j = 0; j < in_channels; j++)
290	matrix_out[i * stride + j] /= maxcoef;
291	}
292
293	return 0;
294	}