git.sesse.net Git - ffmpeg/blob - 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 }