← Back to branch summary

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

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/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.0.1/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
 
}