audio_utils/channels.c

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <string.h>
  18 #include <audio_utils/channels.h>
  19 #include "private/private.h"
  20
  21 /*
  22  * Clamps a 24-bit value from a 32-bit sample
  23  */
  24 static inline int32_t clamp24(int32_t sample)
  25 {
  26     if ((sample>>23) ^ (sample>>31)) {
  27         sample = 0x007FFFFF ^ (sample>>31);
  28     }
  29     return sample;
  30 }
  31
  32 /*
  33  * Converts a uint8x3_t into an int32_t
  34  */
  35 static inline int32_t uint8x3_to_int32(uint8x3_t val) {
  36 #if HAVE_BIG_ENDIAN
  37     int32_t temp = (val.c[0] << 24 | val.c[1] << 16 | val.c[2] << 8) >> 8;
  38 #else
  39     int32_t temp = (val.c[2] << 24 | val.c[1] << 16 | val.c[0] << 8) >> 8;
  40 #endif
  41     return clamp24(temp);
  42 }
  43
  44 /*
  45  * Converts an int32_t to a uint8x3_t
  46  */
  47 static inline uint8x3_t int32_to_uint8x3(int32_t in) {
  48     uint8x3_t out;
  49 #if HAVE_BIG_ENDIAN
  50     out.c[2] = in;
  51     out.c[1] = in >> 8;
  52     out.c[0] = in >> 16;
  53 #else
  54     out.c[0] = in;
  55     out.c[1] = in >> 8;
  56     out.c[2] = in >> 16;
  57 #endif
  58     return out;
  59 }
  60
  61 /* Channel expands (adds zeroes to audio frame end) from an input buffer to an output buffer.
  62  * See expand_channels() function below for parameter definitions.
  63  *
  64  * Move from back to front so that the conversion can be done in-place
  65  * i.e. in_buff == out_buff
  66  * NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
  67  */
  68 #define EXPAND_CHANNELS(in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes, zero) \
  69 { \
  70     size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
  71     size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
  72     typeof(out_buff) dst_ptr = (out_buff) + num_out_samples - 1; \
  73     size_t src_index; \
  74     typeof(in_buff) src_ptr = (in_buff) + num_in_samples - 1; \
  75     size_t num_zero_chans = (out_buff_chans) - (in_buff_chans); \
  76     for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
  77         size_t dst_offset; \
  78         for (dst_offset = 0; dst_offset < num_zero_chans; dst_offset++) { \
  79             *dst_ptr-- = zero; \
  80         } \
  81         for (; dst_offset < (out_buff_chans); dst_offset++) { \
  82             *dst_ptr-- = *src_ptr--; \
  83         } \
  84     } \
  85     /* return number of *bytes* generated */ \
  86     return num_out_samples * sizeof(*(out_buff)); \
  87 }
  88
  89 /* Channel expands from an input buffer to an output buffer.
  90  * See expand_selected_channels() function below for parameter definitions.
  91  * Selected channels are replaced in the output buffer, with any extra channels
  92  * per frame left alone.
  93  *
  94  * Move from back to front so that the conversion can be done in-place
  95  * i.e. in_buff == out_buff
  96  * NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
  97  */
  98 /* This is written as a C macro because it operates on generic types,
  99  * which in a C++ file could be alternatively achieved by a "template"
 100  * or an "auto" declaration.
 101  * TODO: convert this from a C file to a C++ file.
 102  */
 103 #define EXPAND_SELECTED_CHANNELS( \
 104         in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes) \
 105 { \
 106     size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
 107     size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
 108     typeof(out_buff) dst_ptr = (out_buff) + num_out_samples - 1; \
 109     size_t src_index; \
 110     typeof(in_buff) src_ptr = (in_buff) + num_in_samples - 1; \
 111     size_t num_extra_chans = (out_buff_chans) - (in_buff_chans); \
 112     for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
 113         dst_ptr -= num_extra_chans; \
 114         for (size_t dst_offset = num_extra_chans; dst_offset < (out_buff_chans); dst_offset++) { \
 115             *dst_ptr-- = *src_ptr--; \
 116         } \
 117     } \
 118     /* return number of *bytes* generated */ \
 119     return num_out_samples * sizeof(*(out_buff)); \
 120 }
 121
 122
 123 /* Channel expands from a MONO input buffer to a MULTICHANNEL output buffer by duplicating the
 124  * single input channel to the first 2 output channels and 0-filling the remaining.
 125  * See expand_channels() function below for parameter definitions.
 126  *
 127  * in_buff_chans MUST be 1 and out_buff_chans MUST be >= 2
 128  *
 129  * Move from back to front so that the conversion can be done in-place
 130  * i.e. in_buff == out_buff
 131  * NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
 132  */
 133 #define EXPAND_MONO_TO_MULTI(in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes, zero) \
 134 { \
 135     size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
 136     size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
 137     typeof(out_buff) dst_ptr = (out_buff) + num_out_samples - 1; \
 138     size_t src_index; \
 139     typeof(in_buff) src_ptr = (in_buff) + num_in_samples - 1; \
 140     size_t num_zero_chans = (out_buff_chans) - (in_buff_chans) - 1; \
 141     for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
 142         size_t dst_offset; \
 143         for (dst_offset = 0; dst_offset < num_zero_chans; dst_offset++) { \
 144             *dst_ptr-- = zero; \
 145         } \
 146         for (; dst_offset < (out_buff_chans); dst_offset++) { \
 147             *dst_ptr-- = *src_ptr; \
 148         } \
 149         src_ptr--; \
 150     } \
 151     /* return number of *bytes* generated */ \
 152     return num_out_samples * sizeof(*(out_buff)); \
 153 }
 154
 155 /* Channel contracts (removes from audio frame end) from an input buffer to an output buffer.
 156  * See contract_channels() function below for parameter definitions.
 157  *
 158  * Move from front to back so that the conversion can be done in-place
 159  * i.e. in_buff == out_buff
 160  * NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
 161  */
 162 #define CONTRACT_CHANNELS(in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes) \
 163 { \
 164     size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
 165     size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
 166     size_t num_skip_samples = (in_buff_chans) - (out_buff_chans); \
 167     typeof(out_buff) dst_ptr = out_buff; \
 168     typeof(in_buff) src_ptr = in_buff; \
 169     size_t src_index; \
 170     for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
 171         size_t dst_offset; \
 172         for (dst_offset = 0; dst_offset < (out_buff_chans); dst_offset++) { \
 173             *dst_ptr++ = *src_ptr++; \
 174         } \
 175         src_ptr += num_skip_samples; \
 176     } \
 177     /* return number of *bytes* generated */ \
 178     return num_out_samples * sizeof(*(out_buff)); \
 179 }
 180
 181 /* Channel contracts from a MULTICHANNEL input buffer to a MONO output buffer by mixing the
 182  * first two input channels into the single output channel (and skipping the rest).
 183  * See contract_channels() function below for parameter definitions.
 184  *
 185  * in_buff_chans MUST be >= 2 and out_buff_chans MUST be 1
 186  *
 187  * Move from front to back so that the conversion can be done in-place
 188  * i.e. in_buff == out_buff
 189  * NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
 190  * NOTE: Overload of the summed channels is avoided by averaging the two input channels.
 191  * NOTE: Can not be used for uint8x3_t samples, see CONTRACT_TO_MONO_24() below.
 192  */
 193 #define CONTRACT_TO_MONO(in_buff, out_buff, num_in_bytes) \
 194 { \
 195     size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
 196     size_t num_out_samples = (num_in_samples * out_buff_chans) / in_buff_chans; \
 197     size_t num_skip_samples = in_buff_chans - 2; \
 198     typeof(out_buff) dst_ptr = out_buff; \
 199     typeof(in_buff) src_ptr = in_buff; \
 200     int32_t temp0, temp1; \
 201     size_t src_index; \
 202     for (src_index = 0; src_index < num_in_samples; src_index += in_buff_chans) { \
 203         temp0 = *src_ptr++; \
 204         temp1 = *src_ptr++; \
 205         /* *dst_ptr++ = temp >> 1; */ \
 206         /* This bit of magic adds and normalizes without overflow (or so claims hunga@) */ \
 207         /* Bitwise half adder trick, see http://en.wikipedia.org/wiki/Adder_(electronics) */ \
 208         /* Hacker's delight, p. 19 http://www.hackersdelight.org/basics2.pdf */ \
 209         *dst_ptr++ = (temp0 & temp1) + ((temp0 ^ temp1) >> 1); \
 210         src_ptr += num_skip_samples; \
 211     } \
 212     /* return number of *bytes* generated */ \
 213     return num_out_samples * sizeof(*(out_buff)); \
 214 }
 215
 216 /* Channel contracts from a MULTICHANNEL uint8x3_t input buffer to a MONO uint8x3_t output buffer
 217  * by mixing the first two input channels into the single output channel (and skipping the rest).
 218  * See contract_channels() function below for parameter definitions.
 219  *
 220  * Move from front to back so that the conversion can be done in-place
 221  * i.e. in_buff == out_buff
 222  * NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
 223  * NOTE: Overload of the summed channels is avoided by averaging the two input channels.
 224  * NOTE: Can not be used for normal, scalar samples, see CONTRACT_TO_MONO() above.
 225  */
 226 #define CONTRACT_TO_MONO_24(in_buff, out_buff, num_in_bytes) \
 227 { \
 228     size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
 229     size_t num_out_samples = (num_in_samples * out_buff_chans) / in_buff_chans; \
 230     size_t num_skip_samples = in_buff_chans - 2; \
 231     typeof(out_buff) dst_ptr = out_buff; \
 232     typeof(in_buff) src_ptr = in_buff; \
 233     int32_t temp; \
 234     size_t src_index; \
 235     for (src_index = 0; src_index < num_in_samples; src_index += in_buff_chans) { \
 236         temp = uint8x3_to_int32(*src_ptr++); \
 237         temp += uint8x3_to_int32(*src_ptr++); \
 238         *dst_ptr = int32_to_uint8x3(temp >> 1); \
 239         src_ptr += num_skip_samples; \
 240     } \
 241     /* return number of *bytes* generated */ \
 242     return num_out_samples * sizeof(*(out_buff)); \
 243 }
 244
 245 /*
 246  * Convert a buffer of N-channel, interleaved samples to M-channel
 247  * (where N > M).
 248  *   in_buff points to the buffer of samples
 249  *   in_buff_channels Specifies the number of channels in the input buffer.
 250  *   out_buff points to the buffer to receive converted samples.
 251  *   out_buff_channels Specifies the number of channels in the output buffer.
 252  *   sample_size_in_bytes Specifies the number of bytes per sample.
 253  *   num_in_bytes size of input buffer in BYTES
 254  * returns
 255  *   the number of BYTES of output data.
 256  * NOTE
 257  *   channels > M are thrown away.
 258  *   The out and sums buffers must either be completely separate (non-overlapping), or
 259  *   they must both start at the same address. Partially overlapping buffers are not supported.
 260  */
 261 static size_t contract_channels(const void* in_buff, size_t in_buff_chans,
 262                                 void* out_buff, size_t out_buff_chans,
 263                                 unsigned sample_size_in_bytes, size_t num_in_bytes)
 264 {
 265     switch (sample_size_in_bytes) {
 266     case 1:
 267         if (out_buff_chans == 1) {
 268             /* Special case Multi to Mono */
 269             CONTRACT_TO_MONO((const uint8_t*)in_buff, (uint8_t*)out_buff, num_in_bytes);
 270             // returns in macro
 271         } else {
 272             CONTRACT_CHANNELS((const uint8_t*)in_buff, in_buff_chans,
 273                               (uint8_t*)out_buff, out_buff_chans,
 274                               num_in_bytes);
 275             // returns in macro
 276         }
 277     case 2:
 278         if (out_buff_chans == 1) {
 279             /* Special case Multi to Mono */
 280             CONTRACT_TO_MONO((const int16_t*)in_buff, (int16_t*)out_buff, num_in_bytes);
 281             // returns in macro
 282         } else {
 283             CONTRACT_CHANNELS((const int16_t*)in_buff, in_buff_chans,
 284                               (int16_t*)out_buff, out_buff_chans,
 285                               num_in_bytes);
 286             // returns in macro
 287         }
 288     case 3:
 289         if (out_buff_chans == 1) {
 290             /* Special case Multi to Mono */
 291             CONTRACT_TO_MONO_24((const uint8x3_t*)in_buff,
 292                                        (uint8x3_t*)out_buff, num_in_bytes);
 293             // returns in macro
 294         } else {
 295             CONTRACT_CHANNELS((const uint8x3_t*)in_buff, in_buff_chans,
 296                               (uint8x3_t*)out_buff, out_buff_chans,
 297                               num_in_bytes);
 298             // returns in macro
 299         }
 300     case 4:
 301         if (out_buff_chans == 1) {
 302             /* Special case Multi to Mono */
 303             CONTRACT_TO_MONO((const int32_t*)in_buff, (int32_t*)out_buff, num_in_bytes);
 304             // returns in macro
 305         } else {
 306             CONTRACT_CHANNELS((const int32_t*)in_buff, in_buff_chans,
 307                               (int32_t*)out_buff, out_buff_chans,
 308                               num_in_bytes);
 309             // returns in macro
 310         }
 311     default:
 312         return 0;
 313     }
 314 }
 315
 316 /*
 317  * Convert a buffer of N-channel, interleaved samples to M-channel
 318  * (where N < M).
 319  *   in_buff points to the buffer of samples
 320  *   in_buff_channels Specifies the number of channels in the input buffer.
 321  *   out_buff points to the buffer to receive converted samples.
 322  *   out_buff_channels Specifies the number of channels in the output buffer.
 323  *   sample_size_in_bytes Specifies the number of bytes per sample.
 324  *   num_in_bytes size of input buffer in BYTES
 325  * returns
 326  *   the number of BYTES of output data.
 327  * NOTE
 328  *   channels > N are filled with silence.
 329  *   The out and sums buffers must either be completely separate (non-overlapping), or
 330  *   they must both start at the same address. Partially overlapping buffers are not supported.
 331  */
 332 static size_t expand_channels(const void* in_buff, size_t in_buff_chans,
 333                               void* out_buff, size_t out_buff_chans,
 334                               unsigned sample_size_in_bytes, size_t num_in_bytes)
 335 {
 336     static const uint8x3_t packed24_zero; /* zero 24 bit sample */
 337
 338     switch (sample_size_in_bytes) {
 339     case 1:
 340         if (in_buff_chans == 1) {
 341             /* special case of mono source to multi-channel */
 342             EXPAND_MONO_TO_MULTI((const uint8_t*)in_buff, in_buff_chans,
 343                             (uint8_t*)out_buff, out_buff_chans,
 344                             num_in_bytes, 0);
 345             // returns in macro
 346         } else {
 347             EXPAND_CHANNELS((const uint8_t*)in_buff, in_buff_chans,
 348                             (uint8_t*)out_buff, out_buff_chans,
 349                             num_in_bytes, 0);
 350             // returns in macro
 351         }
 352     case 2:
 353         if (in_buff_chans == 1) {
 354             /* special case of mono source to multi-channel */
 355             EXPAND_MONO_TO_MULTI((const int16_t*)in_buff, in_buff_chans,
 356                             (int16_t*)out_buff, out_buff_chans,
 357                             num_in_bytes, 0);
 358             // returns in macro
 359         } else {
 360             EXPAND_CHANNELS((const int16_t*)in_buff, in_buff_chans,
 361                             (int16_t*)out_buff, out_buff_chans,
 362                             num_in_bytes, 0);
 363             // returns in macro
 364         }
 365     case 3:
 366         if (in_buff_chans == 1) {
 367             /* special case of mono source to multi-channel */
 368             EXPAND_MONO_TO_MULTI((const uint8x3_t*)in_buff, in_buff_chans,
 369                             (uint8x3_t*)out_buff, out_buff_chans,
 370                             num_in_bytes, packed24_zero);
 371             // returns in macro
 372         } else {
 373             EXPAND_CHANNELS((const uint8x3_t*)in_buff, in_buff_chans,
 374                             (uint8x3_t*)out_buff, out_buff_chans,
 375                             num_in_bytes, packed24_zero);
 376             // returns in macro
 377         }
 378     case 4:
 379         if (in_buff_chans == 1) {
 380             /* special case of mono source to multi-channel */
 381             EXPAND_MONO_TO_MULTI((const int32_t*)in_buff, in_buff_chans,
 382                             (int32_t*)out_buff, out_buff_chans,
 383                             num_in_bytes, 0);
 384             // returns in macro
 385         } else {
 386            EXPAND_CHANNELS((const int32_t*)in_buff, in_buff_chans,
 387                             (int32_t*)out_buff, out_buff_chans,
 388                             num_in_bytes, 0);
 389             // returns in macro
 390         }
 391     default:
 392         return 0;
 393     }
 394 }
 395
 396 size_t adjust_channels(const void* in_buff, size_t in_buff_chans,
 397                        void* out_buff, size_t out_buff_chans,
 398                        unsigned sample_size_in_bytes, size_t num_in_bytes)
 399 {
 400     if (out_buff_chans > in_buff_chans) {
 401         return expand_channels(in_buff, in_buff_chans, out_buff,  out_buff_chans,
 402                                sample_size_in_bytes, num_in_bytes);
 403     } else if (out_buff_chans < in_buff_chans) {
 404         return contract_channels(in_buff, in_buff_chans, out_buff,  out_buff_chans,
 405                                  sample_size_in_bytes, num_in_bytes);
 406     } else if (in_buff != out_buff) {
 407         memcpy(out_buff, in_buff, num_in_bytes);
 408     }
 409
 410     return num_in_bytes;
 411 }
 412
 413 /*
 414  * Convert a buffer of N-channel, interleaved samples to M-channel
 415  * (where N < M).
 416  *   in_buff points to the buffer of samples
 417  *   in_buff_channels Specifies the number of channels in the input buffer.
 418  *   out_buff points to the buffer to receive converted samples.
 419  *   out_buff_channels Specifies the number of channels in the output buffer.
 420  *   sample_size_in_bytes Specifies the number of bytes per sample.
 421  *   num_in_bytes size of input buffer in BYTES
 422  * returns
 423  *   the number of BYTES of output data.
 424  * NOTE
 425  *   channels > N are left alone in out_buff.
 426  *   The out and in buffers must either be completely separate (non-overlapping), or
 427  *   they must both start at the same address. Partially overlapping buffers are not supported.
 428  */
 429 static size_t expand_selected_channels(const void* in_buff, size_t in_buff_chans,
 430                               void* out_buff, size_t out_buff_chans,
 431                               unsigned sample_size_in_bytes, size_t num_in_bytes)
 432 {
 433     switch (sample_size_in_bytes) {
 434     case 1:
 435
 436         EXPAND_SELECTED_CHANNELS((const uint8_t*)in_buff, in_buff_chans,
 437                         (uint8_t*)out_buff, out_buff_chans,
 438                         num_in_bytes);
 439         // returns in macro
 440
 441     case 2:
 442
 443         EXPAND_SELECTED_CHANNELS((const int16_t*)in_buff, in_buff_chans,
 444                         (int16_t*)out_buff, out_buff_chans,
 445                         num_in_bytes);
 446         // returns in macro
 447
 448     case 3:
 449
 450         EXPAND_SELECTED_CHANNELS((const uint8x3_t*)in_buff, in_buff_chans,
 451                         (uint8x3_t*)out_buff, out_buff_chans,
 452                         num_in_bytes);
 453         // returns in macro
 454
 455     case 4:
 456
 457         EXPAND_SELECTED_CHANNELS((const int32_t*)in_buff, in_buff_chans,
 458                         (int32_t*)out_buff, out_buff_chans,
 459                         num_in_bytes);
 460         // returns in macro
 461
 462     default:
 463         return 0;
 464     }
 465 }
 466
 467 size_t adjust_selected_channels(const void* in_buff, size_t in_buff_chans,
 468                        void* out_buff, size_t out_buff_chans,
 469                        unsigned sample_size_in_bytes, size_t num_in_bytes)
 470 {
 471     if (out_buff_chans > in_buff_chans) {
 472         return expand_selected_channels(in_buff, in_buff_chans, out_buff, out_buff_chans,
 473                                sample_size_in_bytes, num_in_bytes);
 474     } else if (out_buff_chans < in_buff_chans) {
 475         return contract_channels(in_buff, in_buff_chans, out_buff, out_buff_chans,
 476                                  sample_size_in_bytes, num_in_bytes);
 477     } else if (in_buff != out_buff) {
 478         memcpy(out_buff, in_buff, num_in_bytes);
 479     }
 480
 481     return num_in_bytes;
 482 }
 483