code.delx.au - pulseaudio/blob - src/pulsecore/sconv.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <assert.h>
  29
  30 #include <liboil/liboilfuncs.h>
  31 #include <liboil/liboil.h>
  32
  33 #include <pulsecore/g711.h>
  34
  35 #include "endianmacros.h"
  36 #include "sconv-s16le.h"
  37 #include "sconv-s16be.h"
  38
  39 #include "sconv.h"
  40
  41 static void u8_to_float32ne(unsigned n, const void *a, float *b) {
  42     const uint8_t *ca = a;
  43     static const double add = -128.0/127.0, factor = 1.0/127.0;
  44
  45     assert(a);
  46     assert(b);
  47
  48     oil_scaleconv_f32_u8(b, ca, n, &add, &factor);
  49 }
  50
  51 static void u8_from_float32ne(unsigned n, const float *a, void *b) {
  52     uint8_t *cb = b;
  53     static const double add = 128.0, factor = 127.0;
  54
  55     assert(a);
  56     assert(b);
  57
  58     oil_scaleconv_u8_f32(cb, a, n, &add, &factor);
  59 }
  60
  61 static void float32ne_to_float32ne(unsigned n, const void *a, float *b) {
  62     assert(a);
  63     assert(b);
  64
  65     oil_memcpy(b, a, sizeof(float) * n);
  66 }
  67
  68 static void float32ne_from_float32ne(unsigned n, const float *a, void *b) {
  69     assert(a);
  70     assert(b);
  71
  72     oil_memcpy(b, a, sizeof(float) * n);
  73 }
  74
  75 static void ulaw_to_float32ne(unsigned n, const void *a, float *b) {
  76     const uint8_t *ca = a;
  77
  78     assert(a);
  79     assert(b);
  80
  81     for (; n > 0; n--)
  82         *(b++) = st_ulaw2linear16(*(ca++)) * 1.0F / 0x7FFF;
  83 }
  84
  85 static void ulaw_from_float32ne(unsigned n, const float *a, void *b) {
  86     uint8_t *cb = b;
  87
  88     assert(a);
  89     assert(b);
  90
  91     for (; n > 0; n--) {
  92         float v = *(a++);
  93
  94         if (v > 1)
  95             v = 1;
  96
  97         if (v < -1)
  98             v = -1;
  99
 100         *(cb++) = st_14linear2ulaw((int16_t) (v * 0x1FFF));
 101     }
 102 }
 103
 104 static void alaw_to_float32ne(unsigned n, const void *a, float *b) {
 105     const uint8_t *ca = a;
 106
 107     assert(a);
 108     assert(b);
 109
 110     for (; n > 0; n--)
 111         *(b++) = st_alaw2linear16(*(ca++)) * 1.0F / 0x7FFF;
 112 }
 113
 114 static void alaw_from_float32ne(unsigned n, const float *a, void *b) {
 115     uint8_t *cb = b;
 116
 117     assert(a);
 118     assert(b);
 119
 120     for (; n > 0; n--) {
 121         float v = *(a++);
 122
 123         if (v > 1)
 124             v = 1;
 125
 126         if (v < -1)
 127             v = -1;
 128
 129         *(cb++) = st_13linear2alaw((int16_t) (v * 0xFFF));
 130     }
 131 }
 132
 133 pa_convert_to_float32ne_func_t pa_get_convert_to_float32ne_function(pa_sample_format_t f) {
 134     switch(f) {
 135         case PA_SAMPLE_U8:
 136             return u8_to_float32ne;
 137         case PA_SAMPLE_S16LE:
 138             return pa_sconv_s16le_to_float32ne;
 139         case PA_SAMPLE_S16BE:
 140             return pa_sconv_s16be_to_float32ne;
 141         case PA_SAMPLE_FLOAT32NE:
 142             return float32ne_to_float32ne;
 143         case PA_SAMPLE_ALAW:
 144             return alaw_to_float32ne;
 145         case PA_SAMPLE_ULAW:
 146             return ulaw_to_float32ne;
 147         default:
 148             return NULL;
 149     }
 150 }
 151
 152 pa_convert_from_float32ne_func_t pa_get_convert_from_float32ne_function(pa_sample_format_t f) {
 153     switch(f) {
 154         case PA_SAMPLE_U8:
 155             return u8_from_float32ne;
 156         case PA_SAMPLE_S16LE:
 157             return pa_sconv_s16le_from_float32ne;
 158         case PA_SAMPLE_S16BE:
 159             return pa_sconv_s16be_from_float32ne;
 160         case PA_SAMPLE_FLOAT32NE:
 161             return float32ne_from_float32ne;
 162         case PA_SAMPLE_ALAW:
 163             return alaw_from_float32ne;
 164         case PA_SAMPLE_ULAW:
 165             return ulaw_from_float32ne;
 166         default:
 167             return NULL;
 168     }
 169 }