← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/third_party/speex/libspeex/speex.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.1.0/third_party/speex/libspeex/speex.c
 
1
/* Copyright (C) 2002 Jean-Marc Valin 
 
2
   File: speex.c
 
3
 
 
4
   Basic Speex functions
 
5
 
 
6
   Redistribution and use in source and binary forms, with or without
 
7
   modification, are permitted provided that the following conditions
 
8
   are met:
 
9
   
 
10
   - Redistributions of source code must retain the above copyright
 
11
   notice, this list of conditions and the following disclaimer.
 
12
   
 
13
   - Redistributions in binary form must reproduce the above copyright
 
14
   notice, this list of conditions and the following disclaimer in the
 
15
   documentation and/or other materials provided with the distribution.
 
16
   
 
17
   - Neither the name of the Xiph.org Foundation nor the names of its
 
18
   contributors may be used to endorse or promote products derived from
 
19
   this software without specific prior written permission.
 
20
   
 
21
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
22
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
23
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
24
   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
 
25
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
26
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
27
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
28
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 
29
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 
30
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
31
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
32
 
 
33
*/
 
34
 
 
35
#ifdef HAVE_CONFIG_H
 
36
#include "config.h"
 
37
#endif
 
38
 
 
39
#include "modes.h"
 
40
#include <math.h>
 
41
#include "os_support.h"
 
42
 
 
43
#ifndef NULL
 
44
#define NULL 0
 
45
#endif
 
46
 
 
47
#define MAX_IN_SAMPLES 640
 
48
 
 
49
 
 
50
 
 
51
EXPORT void *speex_encoder_init(const SpeexMode *mode)
 
52
{
 
53
   return mode->enc_init(mode);
 
54
}
 
55
 
 
56
EXPORT void *speex_decoder_init(const SpeexMode *mode)
 
57
{
 
58
   return mode->dec_init(mode);
 
59
}
 
60
 
 
61
EXPORT void speex_encoder_destroy(void *state)
 
62
{
 
63
   (*((SpeexMode**)state))->enc_destroy(state);
 
64
}
 
65
 
 
66
EXPORT void speex_decoder_destroy(void *state)
 
67
{
 
68
   (*((SpeexMode**)state))->dec_destroy(state);
 
69
}
 
70
 
 
71
 
 
72
 
 
73
int speex_encode_native(void *state, spx_word16_t *in, SpeexBits *bits)
 
74
{
 
75
   return (*((SpeexMode**)state))->enc(state, in, bits);
 
76
}
 
77
 
 
78
int speex_decode_native(void *state, SpeexBits *bits, spx_word16_t *out)
 
79
{
 
80
   return (*((SpeexMode**)state))->dec(state, bits, out);
 
81
}
 
82
 
 
83
 
 
84
 
 
85
#ifdef FIXED_POINT
 
86
 
 
87
#ifndef DISABLE_FLOAT_API
 
88
EXPORT int speex_encode(void *state, float *in, SpeexBits *bits)
 
89
{
 
90
   int i;
 
91
   spx_int32_t N;
 
92
   spx_int16_t short_in[MAX_IN_SAMPLES];
 
93
   speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &N);
 
94
   for (i=0;i<N;i++)
 
95
   {
 
96
      if (in[i]>32767.f)
 
97
         short_in[i] = 32767;
 
98
      else if (in[i]<-32768.f)
 
99
         short_in[i] = -32768;
 
100
      else
 
101
         short_in[i] = (spx_int16_t)floor(.5+in[i]);
 
102
   }
 
103
   return (*((SpeexMode**)state))->enc(state, short_in, bits);
 
104
}
 
105
#endif /* #ifndef DISABLE_FLOAT_API */
 
106
 
 
107
EXPORT int speex_encode_int(void *state, spx_int16_t *in, SpeexBits *bits)
 
108
{
 
109
   SpeexMode *mode;
 
110
   mode = *(SpeexMode**)state;
 
111
   return (mode)->enc(state, in, bits);
 
112
}
 
113
 
 
114
#ifndef DISABLE_FLOAT_API
 
115
EXPORT int speex_decode(void *state, SpeexBits *bits, float *out)
 
116
{
 
117
   int i, ret;
 
118
   spx_int32_t N;
 
119
   spx_int16_t short_out[MAX_IN_SAMPLES];
 
120
   speex_decoder_ctl(state, SPEEX_GET_FRAME_SIZE, &N);
 
121
   ret = (*((SpeexMode**)state))->dec(state, bits, short_out);
 
122
   for (i=0;i<N;i++)
 
123
      out[i] = short_out[i];
 
124
   return ret;
 
125
}
 
126
#endif /* #ifndef DISABLE_FLOAT_API */
 
127
 
 
128
EXPORT int speex_decode_int(void *state, SpeexBits *bits, spx_int16_t *out)
 
129
{
 
130
   SpeexMode *mode = *(SpeexMode**)state;
 
131
   return (mode)->dec(state, bits, out);
 
132
}
 
133
 
 
134
#else
 
135
 
 
136
EXPORT int speex_encode(void *state, float *in, SpeexBits *bits)
 
137
{
 
138
   return (*((SpeexMode**)state))->enc(state, in, bits);
 
139
}
 
140
 
 
141
EXPORT int speex_encode_int(void *state, spx_int16_t *in, SpeexBits *bits)
 
142
{
 
143
   int i;
 
144
   spx_int32_t N;
 
145
   float float_in[MAX_IN_SAMPLES];
 
146
   speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &N);
 
147
   for (i=0;i<N;i++)
 
148
      float_in[i] = in[i];
 
149
   return (*((SpeexMode**)state))->enc(state, float_in, bits);
 
150
}
 
151
 
 
152
EXPORT int speex_decode(void *state, SpeexBits *bits, float *out)
 
153
{
 
154
   return (*((SpeexMode**)state))->dec(state, bits, out);
 
155
}
 
156
 
 
157
EXPORT int speex_decode_int(void *state, SpeexBits *bits, spx_int16_t *out)
 
158
{
 
159
   int i;
 
160
   spx_int32_t N;
 
161
   float float_out[MAX_IN_SAMPLES];
 
162
   int ret;
 
163
   speex_decoder_ctl(state, SPEEX_GET_FRAME_SIZE, &N);
 
164
   ret = (*((SpeexMode**)state))->dec(state, bits, float_out);
 
165
   for (i=0;i<N;i++)
 
166
   {
 
167
      if (float_out[i]>32767.f)
 
168
         out[i] = 32767;
 
169
      else if (float_out[i]<-32768.f)
 
170
         out[i] = -32768;
 
171
      else
 
172
         out[i] = (spx_int16_t)floor(.5+float_out[i]);
 
173
   }
 
174
   return ret;
 
175
}
 
176
#endif
 
177
 
 
178
 
 
179
 
 
180
EXPORT int speex_encoder_ctl(void *state, int request, void *ptr)
 
181
{
 
182
   return (*((SpeexMode**)state))->enc_ctl(state, request, ptr);
 
183
}
 
184
 
 
185
EXPORT int speex_decoder_ctl(void *state, int request, void *ptr)
 
186
{
 
187
   return (*((SpeexMode**)state))->dec_ctl(state, request, ptr);
 
188
}
 
189
 
 
190
 
 
191
 
 
192
int nb_mode_query(const void *mode, int request, void *ptr)
 
193
{
 
194
   const SpeexNBMode *m = (const SpeexNBMode*)mode;
 
195
   
 
196
   switch (request)
 
197
   {
 
198
   case SPEEX_MODE_FRAME_SIZE:
 
199
      *((int*)ptr)=m->frameSize;
 
200
      break;
 
201
   case SPEEX_SUBMODE_BITS_PER_FRAME:
 
202
      if (*((int*)ptr)==0)
 
203
         *((int*)ptr) = NB_SUBMODE_BITS+1;
 
204
      else if (m->submodes[*((int*)ptr)]==NULL)
 
205
         *((int*)ptr) = -1;
 
206
      else
 
207
         *((int*)ptr) = m->submodes[*((int*)ptr)]->bits_per_frame;
 
208
      break;
 
209
   default:
 
210
      speex_warning_int("Unknown nb_mode_query request: ", request);
 
211
      return -1;
 
212
   }
 
213
   return 0;
 
214
}
 
215
 
 
216
 
 
217
 
 
218
EXPORT int speex_lib_ctl(int request, void *ptr)
 
219
{
 
220
   switch (request)
 
221
   {
 
222
      case SPEEX_LIB_GET_MAJOR_VERSION:
 
223
         *((int*)ptr) = SPEEX_MAJOR_VERSION;
 
224
         break;
 
225
      case SPEEX_LIB_GET_MINOR_VERSION:
 
226
         *((int*)ptr) = SPEEX_MINOR_VERSION;
 
227
         break;
 
228
      case SPEEX_LIB_GET_MICRO_VERSION:
 
229
         *((int*)ptr) = SPEEX_MICRO_VERSION;
 
230
         break;
 
231
      case SPEEX_LIB_GET_EXTRA_VERSION:
 
232
         *((const char**)ptr) = SPEEX_EXTRA_VERSION;
 
233
         break;
 
234
      case SPEEX_LIB_GET_VERSION_STRING:
 
235
         *((const char**)ptr) = SPEEX_VERSION;
 
236
         break;
 
237
      /*case SPEEX_LIB_SET_ALLOC_FUNC:
 
238
         break;
 
239
      case SPEEX_LIB_GET_ALLOC_FUNC:
 
240
         break;
 
241
      case SPEEX_LIB_SET_FREE_FUNC:
 
242
         break;
 
243
      case SPEEX_LIB_GET_FREE_FUNC:
 
244
         break;*/
 
245
      default:
 
246
         speex_warning_int("Unknown wb_mode_query request: ", request);
 
247
         return -1;
 
248
   }
 
249
   return 0;
 
250
}