pcm.c

   1 /*
   2  * Copyright 2005 Timo Hirvonen
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  17  * 02111-1307, USA.
  18  */
  19
  20 #include <pcm.h>
  21
  22 #include <inttypes.h>
  23
  24 /*
  25  * Functions to convert PCM to 16-bit signed little-endian stereo
  26  *
  27  * Conversion for 8-bit PCM):
  28  *   1. phase
  29  *      unsigned -> signed
  30  *      mono -> stereo
  31  *      8 -> 16
  32  *
  33  * Conversion for 16-bit PCM:
  34  *   1. phase
  35  *      be -> le
  36  *      unsigned -> signed
  37  *
  38  *   2. phase
  39  *      mono -> stereo
  40  *
  41  * There's no reason to split 8-bit conversion to 2 phases because we need to
  42  * use separate buffer for 8->16 conversion anyway.
  43  *
  44  * Conversions for 16-bit stereo can be done in place. 16-bit mono needs to be
  45  * converted to stereo so it's worthwhile to split the conversion to 2 phases.
  46  */
  47
  48 void convert_u8_1ch_to_s16_2ch(char *dst, const char *src, int count)
  49 {
  50         int16_t *d = (int16_t *)dst;
  51         const uint8_t *s = (const uint8_t *)src;
  52         int i, j = 0;
  53
  54         for (i = 0; i < count; i++) {
  55                 int16_t sample = s[i] << 8;
  56                 sample -= 32768;
  57                 d[j++] = sample;
  58                 d[j++] = sample;
  59         }
  60 }
  61
  62 void convert_s8_1ch_to_s16_2ch(char *dst, const char *src, int count)
  63 {
  64         int16_t *d = (int16_t *)dst;
  65         const int8_t *s = (const int8_t *)src;
  66         int i, j = 0;
  67
  68         for (i = 0; i < count; i++) {
  69                 int16_t sample = s[i] << 8;
  70                 d[j++] = sample;
  71                 d[j++] = sample;
  72         }
  73 }
  74
  75 void convert_u8_2ch_to_s16_2ch(char *dst, const char *src, int count)
  76 {
  77         int16_t *d = (int16_t *)dst;
  78         const int8_t *s = (const int8_t *)src;
  79         int i;
  80
  81         for (i = 0; i < count; i++) {
  82                 int16_t sample = s[i] << 8;
  83                 sample -= 32768;
  84                 d[i] = sample;
  85         }
  86 }
  87
  88 void convert_s8_2ch_to_s16_2ch(char *dst, const char *src, int count)
  89 {
  90         int16_t *d = (int16_t *)dst;
  91         const int8_t *s = (const int8_t *)src;
  92         int i;
  93
  94         for (i = 0; i < count; i++) {
  95                 int16_t sample = s[i] << 8;
  96                 d[i] = sample;
  97         }
  98 }
  99
 100 void convert_u16_le_to_s16_le(char *buf, int count)
 101 {
 102         int16_t *b = (int16_t *)buf;
 103         int i;
 104
 105         for (i = 0; i < count; i++) {
 106                 int sample = (uint16_t)b[i];
 107                 sample -= 32768;
 108                 b[i] = sample;
 109         }
 110 }
 111
 112 void convert_u16_be_to_s16_le(char *buf, int count)
 113 {
 114         int16_t *b = (int16_t *)buf;
 115         int i;
 116
 117         for (i = 0; i < count; i++) {
 118                 uint16_t u = b[i];
 119                 int sample;
 120
 121                 u = (u << 8) | (u >> 8);
 122                 sample = (int)u - 32768;
 123                 b[i] = sample;
 124         }
 125 }
 126
 127 void convert_s16_be_to_s16_le(char *buf, int count)
 128 {
 129         int16_t *b = (int16_t *)buf;
 130         int i;
 131
 132         for (i = 0; i < count; i++) {
 133                 uint16_t sample = b[i];
 134                 b[i] = (sample << 8) | (sample >> 8);
 135         }
 136 }
 137
 138 void convert_16_1ch_to_16_2ch(char *dst, const char *src, int count)
 139 {
 140         int16_t *d = (int16_t *)dst;
 141         const int16_t *s = (const int16_t *)src;
 142         int i, j = 0;
 143
 144         for (i = 0; i < count; i++) {
 145                 d[j++] = s[i];
 146                 d[j++] = s[i];
 147         }
 148 }