* #36737: switch back to svn repo, remove assert in sip_transaction.c
diff --git a/jni/pjproject-android/.svn/pristine/89/8925931eaeacc33757da4ec2945293bd4aa16d9a.svn-base b/jni/pjproject-android/.svn/pristine/89/8925931eaeacc33757da4ec2945293bd4aa16d9a.svn-base
new file mode 100644
index 0000000..d42d9bb
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/8925931eaeacc33757da4ec2945293bd4aa16d9a.svn-base
@@ -0,0 +1 @@
+#include "../../../portaudio/src/hostapi/coreaudio/pa_mac_core_utilities.h"
diff --git a/jni/pjproject-android/.svn/pristine/89/89593a3791e639ce4a4e7110ad637ceac5e1ff83.svn-base b/jni/pjproject-android/.svn/pristine/89/89593a3791e639ce4a4e7110ad637ceac5e1ff83.svn-base
new file mode 100644
index 0000000..7e2f591
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/89593a3791e639ce4a4e7110ad637ceac5e1ff83.svn-base
@@ -0,0 +1,55 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2010-2011 Teluu Inc. (http://www.teluu.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#import "ipjsystestAppDelegate.h"
+#import "RootViewController.h"
+
+
+@implementation ipjsystestAppDelegate
+
+@synthesize window;
+@synthesize navigationController;
+
+#pragma mark -
+#pragma mark Application lifecycle
+
+- (void)applicationDidFinishLaunching:(UIApplication *)application {
+
+ // Override point for customization after app launch
+ [window addSubview:[navigationController view]];
+ [window makeKeyAndVisible];
+}
+
+
+- (void)applicationWillTerminate:(UIApplication *)application {
+ // Save data if appropriate
+}
+
+
+#pragma mark -
+#pragma mark Memory management
+
+- (void)dealloc {
+ [navigationController release];
+ [window release];
+ [super dealloc];
+}
+
+
+@end
+
diff --git a/jni/pjproject-android/.svn/pristine/89/89964b6515562d1e47626c9e6e223b0d6118e8ef.svn-base b/jni/pjproject-android/.svn/pristine/89/89964b6515562d1e47626c9e6e223b0d6118e8ef.svn-base
new file mode 100644
index 0000000..993ce91
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/89964b6515562d1e47626c9e6e223b0d6118e8ef.svn-base
Binary files differ
diff --git a/jni/pjproject-android/.svn/pristine/89/8999fa93d12299b6e1a546cf3cd40b47c4318eeb.svn-base b/jni/pjproject-android/.svn/pristine/89/8999fa93d12299b6e1a546cf3cd40b47c4318eeb.svn-base
new file mode 100644
index 0000000..a259713
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/8999fa93d12299b6e1a546cf3cd40b47c4318eeb.svn-base
@@ -0,0 +1,91 @@
+/* Copyright (C) 2002 Jean-Marc Valin*/
+/**
+ @file speex_stereo.h
+ @brief Describes the handling for intensity stereo
+*/
+/*
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ - Neither the name of the Xiph.org Foundation nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef STEREO_H
+#define STEREO_H
+/** @defgroup SpeexStereoState SpeexStereoState: Handling Speex stereo files
+ * This describes the Speex intensity stereo encoding/decoding
+ * @{
+ */
+
+#include "speex/speex_types.h"
+#include "speex/speex_bits.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** If you access any of these fields directly, I'll personally come and bite you */
+typedef struct SpeexStereoState {
+ float balance; /**< Left/right balance info */
+ float e_ratio; /**< Ratio of energies: E(left+right)/[E(left)+E(right)] */
+ float smooth_left; /**< Smoothed left channel gain */
+ float smooth_right; /**< Smoothed right channel gain */
+ float reserved1; /**< Reserved for future use */
+ float reserved2; /**< Reserved for future use */
+} SpeexStereoState;
+
+/** Deprecated. Use speex_stereo_state_init() instead. */
+#define SPEEX_STEREO_STATE_INIT {1,.5,1,1,0,0}
+
+/** Initialise/create a stereo stereo state */
+SpeexStereoState *speex_stereo_state_init();
+
+/** Reset/re-initialise an already allocated stereo state */
+void speex_stereo_state_reset(SpeexStereoState *stereo);
+
+/** Destroy a stereo stereo state */
+void speex_stereo_state_destroy(SpeexStereoState *stereo);
+
+/** Transforms a stereo frame into a mono frame and stores intensity stereo info in 'bits' */
+void speex_encode_stereo(float *data, int frame_size, SpeexBits *bits);
+
+/** Transforms a stereo frame into a mono frame and stores intensity stereo info in 'bits' */
+void speex_encode_stereo_int(spx_int16_t *data, int frame_size, SpeexBits *bits);
+
+/** Transforms a mono frame into a stereo frame using intensity stereo info */
+void speex_decode_stereo(float *data, int frame_size, SpeexStereoState *stereo);
+
+/** Transforms a mono frame into a stereo frame using intensity stereo info */
+void speex_decode_stereo_int(spx_int16_t *data, int frame_size, SpeexStereoState *stereo);
+
+/** Callback handler for intensity stereo info */
+int speex_std_stereo_request_handler(SpeexBits *bits, void *state, void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+#endif
diff --git a/jni/pjproject-android/.svn/pristine/89/89cdafbef3fd0370238ce2a6e1d82037330c06ab.svn-base b/jni/pjproject-android/.svn/pristine/89/89cdafbef3fd0370238ce2a6e1d82037330c06ab.svn-base
new file mode 100644
index 0000000..83ba55d
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/89cdafbef3fd0370238ce2a6e1d82037330c06ab.svn-base
@@ -0,0 +1,89 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <pj/config.h>
+#include <pj/log.h>
+#include <pj/ioqueue.h>
+
+static const char *id = "config.c";
+
+#define PJ_MAKE_VERSION3_1(a,b,d) #a "." #b d
+#define PJ_MAKE_VERSION3_2(a,b,d) PJ_MAKE_VERSION3_1(a,b,d)
+
+#define PJ_MAKE_VERSION4_1(a,b,c,d) #a "." #b "." #c d
+#define PJ_MAKE_VERSION4_2(a,b,c,d) PJ_MAKE_VERSION4_1(a,b,c,d)
+
+#if PJ_VERSION_NUM_REV
+PJ_DEF_DATA(const char*) PJ_VERSION = PJ_MAKE_VERSION4_2(PJ_VERSION_NUM_MAJOR,
+ PJ_VERSION_NUM_MINOR,
+ PJ_VERSION_NUM_REV,
+ PJ_VERSION_NUM_EXTRA);
+#else
+PJ_DEF_DATA(const char*) PJ_VERSION = PJ_MAKE_VERSION3_2(PJ_VERSION_NUM_MAJOR,
+ PJ_VERSION_NUM_MINOR,
+ PJ_VERSION_NUM_EXTRA);
+#endif
+
+/*
+ * Get PJLIB version string.
+ */
+PJ_DEF(const char*) pj_get_version(void)
+{
+ return PJ_VERSION;
+}
+
+PJ_DEF(void) pj_dump_config(void)
+{
+ PJ_LOG(3, (id, "PJLIB (c)2008-2009 Teluu Inc."));
+ PJ_LOG(3, (id, "Dumping configurations:"));
+ PJ_LOG(3, (id, " PJ_VERSION : %s", PJ_VERSION));
+ PJ_LOG(3, (id, " PJ_M_NAME : %s", PJ_M_NAME));
+ PJ_LOG(3, (id, " PJ_HAS_PENTIUM : %d", PJ_HAS_PENTIUM));
+ PJ_LOG(3, (id, " PJ_OS_NAME : %s", PJ_OS_NAME));
+ PJ_LOG(3, (id, " PJ_CC_NAME/VER_(1,2,3) : %s-%d.%d.%d", PJ_CC_NAME,
+ PJ_CC_VER_1, PJ_CC_VER_2, PJ_CC_VER_3));
+ PJ_LOG(3, (id, " PJ_IS_(BIG/LITTLE)_ENDIAN : %s",
+ (PJ_IS_BIG_ENDIAN?"big-endian":"little-endian")));
+ PJ_LOG(3, (id, " PJ_HAS_INT64 : %d", PJ_HAS_INT64));
+ PJ_LOG(3, (id, " PJ_HAS_FLOATING_POINT : %d", PJ_HAS_FLOATING_POINT));
+ PJ_LOG(3, (id, " PJ_DEBUG : %d", PJ_DEBUG));
+ PJ_LOG(3, (id, " PJ_FUNCTIONS_ARE_INLINED : %d", PJ_FUNCTIONS_ARE_INLINED));
+ PJ_LOG(3, (id, " PJ_LOG_MAX_LEVEL : %d", PJ_LOG_MAX_LEVEL));
+ PJ_LOG(3, (id, " PJ_LOG_MAX_SIZE : %d", PJ_LOG_MAX_SIZE));
+ PJ_LOG(3, (id, " PJ_LOG_USE_STACK_BUFFER : %d", PJ_LOG_USE_STACK_BUFFER));
+ PJ_LOG(3, (id, " PJ_POOL_DEBUG : %d", PJ_POOL_DEBUG));
+ PJ_LOG(3, (id, " PJ_HAS_POOL_ALT_API : %d", PJ_HAS_POOL_ALT_API));
+ PJ_LOG(3, (id, " PJ_HAS_TCP : %d", PJ_HAS_TCP));
+ PJ_LOG(3, (id, " PJ_MAX_HOSTNAME : %d", PJ_MAX_HOSTNAME));
+ PJ_LOG(3, (id, " ioqueue type : %s", pj_ioqueue_name()));
+ PJ_LOG(3, (id, " PJ_IOQUEUE_MAX_HANDLES : %d", PJ_IOQUEUE_MAX_HANDLES));
+ PJ_LOG(3, (id, " PJ_IOQUEUE_HAS_SAFE_UNREG : %d", PJ_IOQUEUE_HAS_SAFE_UNREG));
+ PJ_LOG(3, (id, " PJ_HAS_THREADS : %d", PJ_HAS_THREADS));
+ PJ_LOG(3, (id, " PJ_LOG_USE_STACK_BUFFER : %d", PJ_LOG_USE_STACK_BUFFER));
+ PJ_LOG(3, (id, " PJ_HAS_SEMAPHORE : %d", PJ_HAS_SEMAPHORE));
+ PJ_LOG(3, (id, " PJ_HAS_EVENT_OBJ : %d", PJ_HAS_EVENT_OBJ));
+ PJ_LOG(3, (id, " PJ_ENABLE_EXTRA_CHECK : %d", PJ_ENABLE_EXTRA_CHECK));
+ PJ_LOG(3, (id, " PJ_HAS_EXCEPTION_NAMES : %d", PJ_HAS_EXCEPTION_NAMES));
+ PJ_LOG(3, (id, " PJ_MAX_EXCEPTION_ID : %d", PJ_MAX_EXCEPTION_ID));
+ PJ_LOG(3, (id, " PJ_EXCEPTION_USE_WIN32_SEH: %d", PJ_EXCEPTION_USE_WIN32_SEH));
+ PJ_LOG(3, (id, " PJ_TIMESTAMP_USE_RDTSC: : %d", PJ_TIMESTAMP_USE_RDTSC));
+ PJ_LOG(3, (id, " PJ_OS_HAS_CHECK_STACK : %d", PJ_OS_HAS_CHECK_STACK));
+ PJ_LOG(3, (id, " PJ_HAS_HIGH_RES_TIMER : %d", PJ_HAS_HIGH_RES_TIMER));
+}
+
diff --git a/jni/pjproject-android/.svn/pristine/89/89e61c475dc85830efd8d853df7fd2ee45ebc244.svn-base b/jni/pjproject-android/.svn/pristine/89/89e61c475dc85830efd8d853df7fd2ee45ebc244.svn-base
new file mode 100644
index 0000000..b16b1ab
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/89e61c475dc85830efd8d853df7fd2ee45ebc244.svn-base
@@ -0,0 +1,424 @@
+/* Copyright (C) 2002-2006 Jean-Marc Valin*/
+/**
+ @file speex.h
+ @brief Describes the different modes of the codec
+*/
+/*
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ - Neither the name of the Xiph.org Foundation nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef SPEEX_H
+#define SPEEX_H
+/** @defgroup Codec Speex encoder and decoder
+ * This is the Speex codec itself.
+ * @{
+ */
+
+#include "speex/speex_bits.h"
+#include "speex/speex_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Values allowed for *ctl() requests */
+
+/** Set enhancement on/off (decoder only) */
+#define SPEEX_SET_ENH 0
+/** Get enhancement state (decoder only) */
+#define SPEEX_GET_ENH 1
+
+/*Would be SPEEX_SET_FRAME_SIZE, but it's (currently) invalid*/
+/** Obtain frame size used by encoder/decoder */
+#define SPEEX_GET_FRAME_SIZE 3
+
+/** Set quality value */
+#define SPEEX_SET_QUALITY 4
+/** Get current quality setting */
+/* #define SPEEX_GET_QUALITY 5 -- Doesn't make much sense, does it? */
+
+/** Set sub-mode to use */
+#define SPEEX_SET_MODE 6
+/** Get current sub-mode in use */
+#define SPEEX_GET_MODE 7
+
+/** Set low-band sub-mode to use (wideband only)*/
+#define SPEEX_SET_LOW_MODE 8
+/** Get current low-band mode in use (wideband only)*/
+#define SPEEX_GET_LOW_MODE 9
+
+/** Set high-band sub-mode to use (wideband only)*/
+#define SPEEX_SET_HIGH_MODE 10
+/** Get current high-band mode in use (wideband only)*/
+#define SPEEX_GET_HIGH_MODE 11
+
+/** Set VBR on (1) or off (0) */
+#define SPEEX_SET_VBR 12
+/** Get VBR status (1 for on, 0 for off) */
+#define SPEEX_GET_VBR 13
+
+/** Set quality value for VBR encoding (0-10) */
+#define SPEEX_SET_VBR_QUALITY 14
+/** Get current quality value for VBR encoding (0-10) */
+#define SPEEX_GET_VBR_QUALITY 15
+
+/** Set complexity of the encoder (0-10) */
+#define SPEEX_SET_COMPLEXITY 16
+/** Get current complexity of the encoder (0-10) */
+#define SPEEX_GET_COMPLEXITY 17
+
+/** Set bit-rate used by the encoder (or lower) */
+#define SPEEX_SET_BITRATE 18
+/** Get current bit-rate used by the encoder or decoder */
+#define SPEEX_GET_BITRATE 19
+
+/** Define a handler function for in-band Speex request*/
+#define SPEEX_SET_HANDLER 20
+
+/** Define a handler function for in-band user-defined request*/
+#define SPEEX_SET_USER_HANDLER 22
+
+/** Set sampling rate used in bit-rate computation */
+#define SPEEX_SET_SAMPLING_RATE 24
+/** Get sampling rate used in bit-rate computation */
+#define SPEEX_GET_SAMPLING_RATE 25
+
+/** Reset the encoder/decoder memories to zero*/
+#define SPEEX_RESET_STATE 26
+
+/** Get VBR info (mostly used internally) */
+#define SPEEX_GET_RELATIVE_QUALITY 29
+
+/** Set VAD status (1 for on, 0 for off) */
+#define SPEEX_SET_VAD 30
+
+/** Get VAD status (1 for on, 0 for off) */
+#define SPEEX_GET_VAD 31
+
+/** Set Average Bit-Rate (ABR) to n bits per seconds */
+#define SPEEX_SET_ABR 32
+/** Get Average Bit-Rate (ABR) setting (in bps) */
+#define SPEEX_GET_ABR 33
+
+/** Set DTX status (1 for on, 0 for off) */
+#define SPEEX_SET_DTX 34
+/** Get DTX status (1 for on, 0 for off) */
+#define SPEEX_GET_DTX 35
+
+/** Set submode encoding in each frame (1 for yes, 0 for no, setting to no breaks the standard) */
+#define SPEEX_SET_SUBMODE_ENCODING 36
+/** Get submode encoding in each frame */
+#define SPEEX_GET_SUBMODE_ENCODING 37
+
+/*#define SPEEX_SET_LOOKAHEAD 38*/
+/** Returns the lookahead used by Speex */
+#define SPEEX_GET_LOOKAHEAD 39
+
+/** Sets tuning for packet-loss concealment (expected loss rate) */
+#define SPEEX_SET_PLC_TUNING 40
+/** Gets tuning for PLC */
+#define SPEEX_GET_PLC_TUNING 41
+
+/** Sets the max bit-rate allowed in VBR mode */
+#define SPEEX_SET_VBR_MAX_BITRATE 42
+/** Gets the max bit-rate allowed in VBR mode */
+#define SPEEX_GET_VBR_MAX_BITRATE 43
+
+/** Turn on/off input/output high-pass filtering */
+#define SPEEX_SET_HIGHPASS 44
+/** Get status of input/output high-pass filtering */
+#define SPEEX_GET_HIGHPASS 45
+
+/** Get "activity level" of the last decoded frame, i.e.
+ how much damage we cause if we remove the frame */
+#define SPEEX_GET_ACTIVITY 47
+
+
+/* Preserving compatibility:*/
+/** Equivalent to SPEEX_SET_ENH */
+#define SPEEX_SET_PF 0
+/** Equivalent to SPEEX_GET_ENH */
+#define SPEEX_GET_PF 1
+
+
+
+
+/* Values allowed for mode queries */
+/** Query the frame size of a mode */
+#define SPEEX_MODE_FRAME_SIZE 0
+
+/** Query the size of an encoded frame for a particular sub-mode */
+#define SPEEX_SUBMODE_BITS_PER_FRAME 1
+
+
+
+/** Get major Speex version */
+#define SPEEX_LIB_GET_MAJOR_VERSION 1
+/** Get minor Speex version */
+#define SPEEX_LIB_GET_MINOR_VERSION 3
+/** Get micro Speex version */
+#define SPEEX_LIB_GET_MICRO_VERSION 5
+/** Get extra Speex version */
+#define SPEEX_LIB_GET_EXTRA_VERSION 7
+/** Get Speex version string */
+#define SPEEX_LIB_GET_VERSION_STRING 9
+
+/*#define SPEEX_LIB_SET_ALLOC_FUNC 10
+#define SPEEX_LIB_GET_ALLOC_FUNC 11
+#define SPEEX_LIB_SET_FREE_FUNC 12
+#define SPEEX_LIB_GET_FREE_FUNC 13
+
+#define SPEEX_LIB_SET_WARNING_FUNC 14
+#define SPEEX_LIB_GET_WARNING_FUNC 15
+#define SPEEX_LIB_SET_ERROR_FUNC 16
+#define SPEEX_LIB_GET_ERROR_FUNC 17
+*/
+
+/** Number of defined modes in Speex */
+#define SPEEX_NB_MODES 3
+
+/** modeID for the defined narrowband mode */
+#define SPEEX_MODEID_NB 0
+
+/** modeID for the defined wideband mode */
+#define SPEEX_MODEID_WB 1
+
+/** modeID for the defined ultra-wideband mode */
+#define SPEEX_MODEID_UWB 2
+
+struct SpeexMode;
+
+
+/* Prototypes for mode function pointers */
+
+/** Encoder state initialization function */
+typedef void *(*encoder_init_func)(const struct SpeexMode *mode);
+
+/** Encoder state destruction function */
+typedef void (*encoder_destroy_func)(void *st);
+
+/** Main encoding function */
+typedef int (*encode_func)(void *state, void *in, SpeexBits *bits);
+
+/** Function for controlling the encoder options */
+typedef int (*encoder_ctl_func)(void *state, int request, void *ptr);
+
+/** Decoder state initialization function */
+typedef void *(*decoder_init_func)(const struct SpeexMode *mode);
+
+/** Decoder state destruction function */
+typedef void (*decoder_destroy_func)(void *st);
+
+/** Main decoding function */
+typedef int (*decode_func)(void *state, SpeexBits *bits, void *out);
+
+/** Function for controlling the decoder options */
+typedef int (*decoder_ctl_func)(void *state, int request, void *ptr);
+
+
+/** Query function for a mode */
+typedef int (*mode_query_func)(const void *mode, int request, void *ptr);
+
+/** Struct defining a Speex mode */
+typedef struct SpeexMode {
+ /** Pointer to the low-level mode data */
+ const void *mode;
+
+ /** Pointer to the mode query function */
+ mode_query_func query;
+
+ /** The name of the mode (you should not rely on this to identify the mode)*/
+ const char *modeName;
+
+ /**ID of the mode*/
+ int modeID;
+
+ /**Version number of the bitstream (incremented every time we break
+ bitstream compatibility*/
+ int bitstream_version;
+
+ /** Pointer to encoder initialization function */
+ encoder_init_func enc_init;
+
+ /** Pointer to encoder destruction function */
+ encoder_destroy_func enc_destroy;
+
+ /** Pointer to frame encoding function */
+ encode_func enc;
+
+ /** Pointer to decoder initialization function */
+ decoder_init_func dec_init;
+
+ /** Pointer to decoder destruction function */
+ decoder_destroy_func dec_destroy;
+
+ /** Pointer to frame decoding function */
+ decode_func dec;
+
+ /** ioctl-like requests for encoder */
+ encoder_ctl_func enc_ctl;
+
+ /** ioctl-like requests for decoder */
+ decoder_ctl_func dec_ctl;
+
+} SpeexMode;
+
+/**
+ * Returns a handle to a newly created Speex encoder state structure. For now,
+ * the "mode" argument can be &nb_mode or &wb_mode . In the future, more modes
+ * may be added. Note that for now if you have more than one channels to
+ * encode, you need one state per channel.
+ *
+ * @param mode The mode to use (either speex_nb_mode or speex_wb.mode)
+ * @return A newly created encoder state or NULL if state allocation fails
+ */
+void *speex_encoder_init(const SpeexMode *mode);
+
+/** Frees all resources associated to an existing Speex encoder state.
+ * @param state Encoder state to be destroyed */
+void speex_encoder_destroy(void *state);
+
+/** Uses an existing encoder state to encode one frame of speech pointed to by
+ "in". The encoded bit-stream is saved in "bits".
+ @param state Encoder state
+ @param in Frame that will be encoded with a +-2^15 range. This data MAY be
+ overwritten by the encoder and should be considered uninitialised
+ after the call.
+ @param bits Bit-stream where the data will be written
+ @return 0 if frame needs not be transmitted (DTX only), 1 otherwise
+ */
+int speex_encode(void *state, float *in, SpeexBits *bits);
+
+/** Uses an existing encoder state to encode one frame of speech pointed to by
+ "in". The encoded bit-stream is saved in "bits".
+ @param state Encoder state
+ @param in Frame that will be encoded with a +-2^15 range
+ @param bits Bit-stream where the data will be written
+ @return 0 if frame needs not be transmitted (DTX only), 1 otherwise
+ */
+int speex_encode_int(void *state, spx_int16_t *in, SpeexBits *bits);
+
+/** Used like the ioctl function to control the encoder parameters
+ *
+ * @param state Encoder state
+ * @param request ioctl-type request (one of the SPEEX_* macros)
+ * @param ptr Data exchanged to-from function
+ * @return 0 if no error, -1 if request in unknown, -2 for invalid parameter
+ */
+int speex_encoder_ctl(void *state, int request, void *ptr);
+
+
+/** Returns a handle to a newly created decoder state structure. For now,
+ * the mode argument can be &nb_mode or &wb_mode . In the future, more modes
+ * may be added. Note that for now if you have more than one channels to
+ * decode, you need one state per channel.
+ *
+ * @param mode Speex mode (one of speex_nb_mode or speex_wb_mode)
+ * @return A newly created decoder state or NULL if state allocation fails
+ */
+void *speex_decoder_init(const SpeexMode *mode);
+
+/** Frees all resources associated to an existing decoder state.
+ *
+ * @param state State to be destroyed
+ */
+void speex_decoder_destroy(void *state);
+
+/** Uses an existing decoder state to decode one frame of speech from
+ * bit-stream bits. The output speech is saved written to out.
+ *
+ * @param state Decoder state
+ * @param bits Bit-stream from which to decode the frame (NULL if the packet was lost)
+ * @param out Where to write the decoded frame
+ * @return return status (0 for no error, -1 for end of stream, -2 corrupt stream)
+ */
+int speex_decode(void *state, SpeexBits *bits, float *out);
+
+/** Uses an existing decoder state to decode one frame of speech from
+ * bit-stream bits. The output speech is saved written to out.
+ *
+ * @param state Decoder state
+ * @param bits Bit-stream from which to decode the frame (NULL if the packet was lost)
+ * @param out Where to write the decoded frame
+ * @return return status (0 for no error, -1 for end of stream, -2 corrupt stream)
+ */
+int speex_decode_int(void *state, SpeexBits *bits, spx_int16_t *out);
+
+/** Used like the ioctl function to control the encoder parameters
+ *
+ * @param state Decoder state
+ * @param request ioctl-type request (one of the SPEEX_* macros)
+ * @param ptr Data exchanged to-from function
+ * @return 0 if no error, -1 if request in unknown, -2 for invalid parameter
+ */
+int speex_decoder_ctl(void *state, int request, void *ptr);
+
+
+/** Query function for mode information
+ *
+ * @param mode Speex mode
+ * @param request ioctl-type request (one of the SPEEX_* macros)
+ * @param ptr Data exchanged to-from function
+ * @return 0 if no error, -1 if request in unknown, -2 for invalid parameter
+ */
+int speex_mode_query(const SpeexMode *mode, int request, void *ptr);
+
+/** Functions for controlling the behavior of libspeex
+ * @param request ioctl-type request (one of the SPEEX_LIB_* macros)
+ * @param ptr Data exchanged to-from function
+ * @return 0 if no error, -1 if request in unknown, -2 for invalid parameter
+ */
+int speex_lib_ctl(int request, void *ptr);
+
+/** Default narrowband mode */
+extern const SpeexMode speex_nb_mode;
+
+/** Default wideband mode */
+extern const SpeexMode speex_wb_mode;
+
+/** Default "ultra-wideband" mode */
+extern const SpeexMode speex_uwb_mode;
+
+/** List of all modes available */
+extern const SpeexMode * const speex_mode_list[SPEEX_NB_MODES];
+
+/** Obtain one of the modes available */
+const SpeexMode * speex_lib_get_mode (int mode);
+
+#if (!defined(WIN32) && !defined(WIN64))
+/* We actually override the function in the narrowband case so that we can avoid linking in the wideband stuff */
+#define speex_lib_get_mode(mode) ((mode)==SPEEX_MODEID_NB ? &speex_nb_mode : speex_lib_get_mode (mode))
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @}*/
+#endif
diff --git a/jni/pjproject-android/.svn/pristine/89/89ee39e5bfddf4ac8346bbbd5aeae6bf5c750db7.svn-base b/jni/pjproject-android/.svn/pristine/89/89ee39e5bfddf4ac8346bbbd5aeae6bf5c750db7.svn-base
new file mode 100644
index 0000000..36ef4f6
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/89/89ee39e5bfddf4ac8346bbbd5aeae6bf5c750db7.svn-base
@@ -0,0 +1,821 @@
+/* Copyright (C) 2002-2006 Jean-Marc Valin
+ File: filters.c
+ Various analysis/synthesis filters
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ - Neither the name of the Xiph.org Foundation nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "filters.h"
+#include "stack_alloc.h"
+#include "arch.h"
+#include "math_approx.h"
+#include "ltp.h"
+#include <math.h>
+
+#ifdef _USE_SSE
+#include "filters_sse.h"
+#elif defined (ARM4_ASM) || defined(ARM5E_ASM)
+#include "filters_arm4.h"
+#elif defined (BFIN_ASM)
+#include "filters_bfin.h"
+#endif
+
+
+
+void bw_lpc(spx_word16_t gamma, const spx_coef_t *lpc_in, spx_coef_t *lpc_out, int order)
+{
+ int i;
+ spx_word16_t tmp=gamma;
+ for (i=0;i<order;i++)
+ {
+ lpc_out[i] = MULT16_16_P15(tmp,lpc_in[i]);
+ tmp = MULT16_16_P15(tmp, gamma);
+ }
+}
+
+void sanitize_values32(spx_word32_t *vec, spx_word32_t min_val, spx_word32_t max_val, int len)
+{
+ int i;
+ for (i=0;i<len;i++)
+ {
+ /* It's important we do the test that way so we can catch NaNs, which are neither greater nor smaller */
+ if (!(vec[i]>=min_val && vec[i] <= max_val))
+ {
+ if (vec[i] < min_val)
+ vec[i] = min_val;
+ else if (vec[i] > max_val)
+ vec[i] = max_val;
+ else /* Has to be NaN */
+ vec[i] = 0;
+ }
+ }
+}
+
+void highpass(const spx_word16_t *x, spx_word16_t *y, int len, int filtID, spx_mem_t *mem)
+{
+ int i;
+#ifdef FIXED_POINT
+ const spx_word16_t Pcoef[5][3] = {{16384, -31313, 14991}, {16384, -31569, 15249}, {16384, -31677, 15328}, {16384, -32313, 15947}, {16384, -22446, 6537}};
+ const spx_word16_t Zcoef[5][3] = {{15672, -31344, 15672}, {15802, -31601, 15802}, {15847, -31694, 15847}, {16162, -32322, 16162}, {14418, -28836, 14418}};
+#else
+ const spx_word16_t Pcoef[5][3] = {{1.00000f, -1.91120f, 0.91498f}, {1.00000f, -1.92683f, 0.93071f}, {1.00000f, -1.93338f, 0.93553f}, {1.00000f, -1.97226f, 0.97332f}, {1.00000f, -1.37000f, 0.39900f}};
+ const spx_word16_t Zcoef[5][3] = {{0.95654f, -1.91309f, 0.95654f}, {0.96446f, -1.92879f, 0.96446f}, {0.96723f, -1.93445f, 0.96723f}, {0.98645f, -1.97277f, 0.98645f}, {0.88000f, -1.76000f, 0.88000f}};
+#endif
+ const spx_word16_t *den, *num;
+ if (filtID>4)
+ filtID=4;
+
+ den = Pcoef[filtID]; num = Zcoef[filtID];
+ /*return;*/
+ for (i=0;i<len;i++)
+ {
+ spx_word16_t yi;
+ spx_word32_t vout = ADD32(MULT16_16(num[0], x[i]),mem[0]);
+ yi = EXTRACT16(SATURATE(PSHR32(vout,14),32767));
+ mem[0] = ADD32(MAC16_16(mem[1], num[1],x[i]), SHL32(MULT16_32_Q15(-den[1],vout),1));
+ mem[1] = ADD32(MULT16_16(num[2],x[i]), SHL32(MULT16_32_Q15(-den[2],vout),1));
+ y[i] = yi;
+ }
+}
+
+#ifdef FIXED_POINT
+
+/* FIXME: These functions are ugly and probably introduce too much error */
+void signal_mul(const spx_sig_t *x, spx_sig_t *y, spx_word32_t scale, int len)
+{
+ int i;
+ for (i=0;i<len;i++)
+ {
+ y[i] = SHL32(MULT16_32_Q14(EXTRACT16(SHR32(x[i],7)),scale),7);
+ }
+}
+
+void signal_div(const spx_word16_t *x, spx_word16_t *y, spx_word32_t scale, int len)
+{
+ int i;
+ if (scale > SHL32(EXTEND32(SIG_SCALING), 8))
+ {
+ spx_word16_t scale_1;
+ scale = PSHR32(scale, SIG_SHIFT);
+ scale_1 = EXTRACT16(PDIV32_16(SHL32(EXTEND32(SIG_SCALING),7),scale));
+ for (i=0;i<len;i++)
+ {
+ y[i] = MULT16_16_P15(scale_1, x[i]);
+ }
+ } else if (scale > SHR32(EXTEND32(SIG_SCALING), 2)) {
+ spx_word16_t scale_1;
+ scale = PSHR32(scale, SIG_SHIFT-5);
+ scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),3),scale);
+ for (i=0;i<len;i++)
+ {
+ y[i] = PSHR32(MULT16_16(scale_1, SHL16(x[i],2)),8);
+ }
+ } else {
+ spx_word16_t scale_1;
+ scale = PSHR32(scale, SIG_SHIFT-7);
+ if (scale < 5)
+ scale = 5;
+ scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),3),scale);
+ for (i=0;i<len;i++)
+ {
+ y[i] = PSHR32(MULT16_16(scale_1, SHL16(x[i],2)),6);
+ }
+ }
+}
+
+#else
+
+void signal_mul(const spx_sig_t *x, spx_sig_t *y, spx_word32_t scale, int len)
+{
+ int i;
+ for (i=0;i<len;i++)
+ y[i] = scale*x[i];
+}
+
+void signal_div(const spx_sig_t *x, spx_sig_t *y, spx_word32_t scale, int len)
+{
+ int i;
+ float scale_1 = 1/scale;
+ for (i=0;i<len;i++)
+ y[i] = scale_1*x[i];
+}
+#endif
+
+
+
+#ifdef FIXED_POINT
+
+
+
+spx_word16_t compute_rms(const spx_sig_t *x, int len)
+{
+ int i;
+ spx_word32_t sum=0;
+ spx_sig_t max_val=1;
+ int sig_shift;
+
+ for (i=0;i<len;i++)
+ {
+ spx_sig_t tmp = x[i];
+ if (tmp<0)
+ tmp = -tmp;
+ if (tmp > max_val)
+ max_val = tmp;
+ }
+
+ sig_shift=0;
+ while (max_val>16383)
+ {
+ sig_shift++;
+ max_val >>= 1;
+ }
+
+ for (i=0;i<len;i+=4)
+ {
+ spx_word32_t sum2=0;
+ spx_word16_t tmp;
+ tmp = EXTRACT16(SHR32(x[i],sig_shift));
+ sum2 = MAC16_16(sum2,tmp,tmp);
+ tmp = EXTRACT16(SHR32(x[i+1],sig_shift));
+ sum2 = MAC16_16(sum2,tmp,tmp);
+ tmp = EXTRACT16(SHR32(x[i+2],sig_shift));
+ sum2 = MAC16_16(sum2,tmp,tmp);
+ tmp = EXTRACT16(SHR32(x[i+3],sig_shift));
+ sum2 = MAC16_16(sum2,tmp,tmp);
+ sum = ADD32(sum,SHR32(sum2,6));
+ }
+
+ return EXTRACT16(PSHR32(SHL32(EXTEND32(spx_sqrt(DIV32(sum,len))),(sig_shift+3)),SIG_SHIFT));
+}
+
+spx_word16_t compute_rms16(const spx_word16_t *x, int len)
+{
+ int i;
+ spx_word16_t max_val=10;
+
+ for (i=0;i<len;i++)
+ {
+ spx_sig_t tmp = x[i];
+ if (tmp<0)
+ tmp = -tmp;
+ if (tmp > max_val)
+ max_val = tmp;
+ }
+ if (max_val>16383)
+ {
+ spx_word32_t sum=0;
+ for (i=0;i<len;i+=4)
+ {
+ spx_word32_t sum2=0;
+ sum2 = MAC16_16(sum2,SHR16(x[i],1),SHR16(x[i],1));
+ sum2 = MAC16_16(sum2,SHR16(x[i+1],1),SHR16(x[i+1],1));
+ sum2 = MAC16_16(sum2,SHR16(x[i+2],1),SHR16(x[i+2],1));
+ sum2 = MAC16_16(sum2,SHR16(x[i+3],1),SHR16(x[i+3],1));
+ sum = ADD32(sum,SHR32(sum2,6));
+ }
+ return SHL16(spx_sqrt(DIV32(sum,len)),4);
+ } else {
+ spx_word32_t sum=0;
+ int sig_shift=0;
+ if (max_val < 8192)
+ sig_shift=1;
+ if (max_val < 4096)
+ sig_shift=2;
+ if (max_val < 2048)
+ sig_shift=3;
+ for (i=0;i<len;i+=4)
+ {
+ spx_word32_t sum2=0;
+ sum2 = MAC16_16(sum2,SHL16(x[i],sig_shift),SHL16(x[i],sig_shift));
+ sum2 = MAC16_16(sum2,SHL16(x[i+1],sig_shift),SHL16(x[i+1],sig_shift));
+ sum2 = MAC16_16(sum2,SHL16(x[i+2],sig_shift),SHL16(x[i+2],sig_shift));
+ sum2 = MAC16_16(sum2,SHL16(x[i+3],sig_shift),SHL16(x[i+3],sig_shift));
+ sum = ADD32(sum,SHR32(sum2,6));
+ }
+ return SHL16(spx_sqrt(DIV32(sum,len)),3-sig_shift);
+ }
+}
+
+#ifndef OVERRIDE_NORMALIZE16
+int normalize16(const spx_sig_t *x, spx_word16_t *y, spx_sig_t max_scale, int len)
+{
+ int i;
+ spx_sig_t max_val=1;
+ int sig_shift;
+
+ for (i=0;i<len;i++)
+ {
+ spx_sig_t tmp = x[i];
+ if (tmp<0)
+ tmp = NEG32(tmp);
+ if (tmp >= max_val)
+ max_val = tmp;
+ }
+
+ sig_shift=0;
+ while (max_val>max_scale)
+ {
+ sig_shift++;
+ max_val >>= 1;
+ }
+
+ for (i=0;i<len;i++)
+ y[i] = EXTRACT16(SHR32(x[i], sig_shift));
+
+ return sig_shift;
+}
+#endif
+
+#else
+
+spx_word16_t compute_rms(const spx_sig_t *x, int len)
+{
+ int i;
+ float sum=0;
+ for (i=0;i<len;i++)
+ {
+ sum += x[i]*x[i];
+ }
+ return sqrt(.1+sum/len);
+}
+spx_word16_t compute_rms16(const spx_word16_t *x, int len)
+{
+ return compute_rms(x, len);
+}
+#endif
+
+
+
+#ifndef OVERRIDE_FILTER_MEM16
+void filter_mem16(const spx_word16_t *x, const spx_coef_t *num, const spx_coef_t *den, spx_word16_t *y, int N, int ord, spx_mem_t *mem, char *stack)
+{
+ int i,j;
+ spx_word16_t xi,yi,nyi;
+ for (i=0;i<N;i++)
+ {
+ xi= x[i];
+ yi = EXTRACT16(SATURATE(ADD32(EXTEND32(x[i]),PSHR32(mem[0],LPC_SHIFT)),32767));
+ nyi = NEG16(yi);
+ for (j=0;j<ord-1;j++)
+ {
+ mem[j] = MAC16_16(MAC16_16(mem[j+1], num[j],xi), den[j],nyi);
+ }
+ mem[ord-1] = ADD32(MULT16_16(num[ord-1],xi), MULT16_16(den[ord-1],nyi));
+ y[i] = yi;
+ }
+}
+#endif
+
+#ifndef OVERRIDE_IIR_MEM16
+void iir_mem16(const spx_word16_t *x, const spx_coef_t *den, spx_word16_t *y, int N, int ord, spx_mem_t *mem, char *stack)
+{
+ int i,j;
+ spx_word16_t yi,nyi;
+
+ for (i=0;i<N;i++)
+ {
+ yi = EXTRACT16(SATURATE(ADD32(EXTEND32(x[i]),PSHR32(mem[0],LPC_SHIFT)),32767));
+ nyi = NEG16(yi);
+ for (j=0;j<ord-1;j++)
+ {
+ mem[j] = MAC16_16(mem[j+1],den[j],nyi);
+ }
+ mem[ord-1] = MULT16_16(den[ord-1],nyi);
+ y[i] = yi;
+ }
+}
+#endif
+
+#ifndef OVERRIDE_FIR_MEM16
+void fir_mem16(const spx_word16_t *x, const spx_coef_t *num, spx_word16_t *y, int N, int ord, spx_mem_t *mem, char *stack)
+{
+ int i,j;
+ spx_word16_t xi,yi;
+
+ for (i=0;i<N;i++)
+ {
+ xi=x[i];
+ yi = EXTRACT16(SATURATE(ADD32(EXTEND32(x[i]),PSHR32(mem[0],LPC_SHIFT)),32767));
+ for (j=0;j<ord-1;j++)
+ {
+ mem[j] = MAC16_16(mem[j+1], num[j],xi);
+ }
+ mem[ord-1] = MULT16_16(num[ord-1],xi);
+ y[i] = yi;
+ }
+}
+#endif
+
+
+void syn_percep_zero16(const spx_word16_t *xx, const spx_coef_t *ak, const spx_coef_t *awk1, const spx_coef_t *awk2, spx_word16_t *y, int N, int ord, char *stack)
+{
+ int i;
+ VARDECL(spx_mem_t *mem);
+ ALLOC(mem, ord, spx_mem_t);
+ for (i=0;i<ord;i++)
+ mem[i]=0;
+ iir_mem16(xx, ak, y, N, ord, mem, stack);
+ for (i=0;i<ord;i++)
+ mem[i]=0;
+ filter_mem16(y, awk1, awk2, y, N, ord, mem, stack);
+}
+void residue_percep_zero16(const spx_word16_t *xx, const spx_coef_t *ak, const spx_coef_t *awk1, const spx_coef_t *awk2, spx_word16_t *y, int N, int ord, char *stack)
+{
+ int i;
+ VARDECL(spx_mem_t *mem);
+ ALLOC(mem, ord, spx_mem_t);
+ for (i=0;i<ord;i++)
+ mem[i]=0;
+ filter_mem16(xx, ak, awk1, y, N, ord, mem, stack);
+ for (i=0;i<ord;i++)
+ mem[i]=0;
+ fir_mem16(y, awk2, y, N, ord, mem, stack);
+}
+
+
+#ifndef OVERRIDE_COMPUTE_IMPULSE_RESPONSE
+void compute_impulse_response(const spx_coef_t *ak, const spx_coef_t *awk1, const spx_coef_t *awk2, spx_word16_t *y, int N, int ord, char *stack)
+{
+ int i,j;
+ spx_word16_t y1, ny1i, ny2i;
+ VARDECL(spx_mem_t *mem1);
+ VARDECL(spx_mem_t *mem2);
+ ALLOC(mem1, ord, spx_mem_t);
+ ALLOC(mem2, ord, spx_mem_t);
+
+ y[0] = LPC_SCALING;
+ for (i=0;i<ord;i++)
+ y[i+1] = awk1[i];
+ i++;
+ for (;i<N;i++)
+ y[i] = VERY_SMALL;
+ for (i=0;i<ord;i++)
+ mem1[i] = mem2[i] = 0;
+ for (i=0;i<N;i++)
+ {
+ y1 = ADD16(y[i], EXTRACT16(PSHR32(mem1[0],LPC_SHIFT)));
+ ny1i = NEG16(y1);
+ y[i] = PSHR32(ADD32(SHL32(EXTEND32(y1),LPC_SHIFT+1),mem2[0]),LPC_SHIFT);
+ ny2i = NEG16(y[i]);
+ for (j=0;j<ord-1;j++)
+ {
+ mem1[j] = MAC16_16(mem1[j+1], awk2[j],ny1i);
+ mem2[j] = MAC16_16(mem2[j+1], ak[j],ny2i);
+ }
+ mem1[ord-1] = MULT16_16(awk2[ord-1],ny1i);
+ mem2[ord-1] = MULT16_16(ak[ord-1],ny2i);
+ }
+}
+#endif
+
+/* Decomposes a signal into low-band and high-band using a QMF */
+void qmf_decomp(const spx_word16_t *xx, const spx_word16_t *aa, spx_word16_t *y1, spx_word16_t *y2, int N, int M, spx_word16_t *mem, char *stack)
+{
+ int i,j,k,M2;
+ VARDECL(spx_word16_t *a);
+ VARDECL(spx_word16_t *x);
+ spx_word16_t *x2;
+
+ ALLOC(a, M, spx_word16_t);
+ ALLOC(x, N+M-1, spx_word16_t);
+ x2=x+M-1;
+ M2=M>>1;
+ for (i=0;i<M;i++)
+ a[M-i-1]= aa[i];
+ for (i=0;i<M-1;i++)
+ x[i]=mem[M-i-2];
+ for (i=0;i<N;i++)
+ x[i+M-1]=SHR16(xx[i],1);
+ for (i=0;i<M-1;i++)
+ mem[i]=SHR16(xx[N-i-1],1);
+ for (i=0,k=0;i<N;i+=2,k++)
+ {
+ spx_word32_t y1k=0, y2k=0;
+ for (j=0;j<M2;j++)
+ {
+ y1k=ADD32(y1k,MULT16_16(a[j],ADD16(x[i+j],x2[i-j])));
+ y2k=SUB32(y2k,MULT16_16(a[j],SUB16(x[i+j],x2[i-j])));
+ j++;
+ y1k=ADD32(y1k,MULT16_16(a[j],ADD16(x[i+j],x2[i-j])));
+ y2k=ADD32(y2k,MULT16_16(a[j],SUB16(x[i+j],x2[i-j])));
+ }
+ y1[k] = EXTRACT16(SATURATE(PSHR32(y1k,15),32767));
+ y2[k] = EXTRACT16(SATURATE(PSHR32(y2k,15),32767));
+ }
+}
+
+/* Re-synthesised a signal from the QMF low-band and high-band signals */
+void qmf_synth(const spx_word16_t *x1, const spx_word16_t *x2, const spx_word16_t *a, spx_word16_t *y, int N, int M, spx_word16_t *mem1, spx_word16_t *mem2, char *stack)
+ /* assumptions:
+ all odd x[i] are zero -- well, actually they are left out of the array now
+ N and M are multiples of 4 */
+{
+ int i, j;
+ int M2, N2;
+ VARDECL(spx_word16_t *xx1);
+ VARDECL(spx_word16_t *xx2);
+
+ M2 = M>>1;
+ N2 = N>>1;
+ ALLOC(xx1, M2+N2, spx_word16_t);
+ ALLOC(xx2, M2+N2, spx_word16_t);
+
+ for (i = 0; i < N2; i++)
+ xx1[i] = x1[N2-1-i];
+ for (i = 0; i < M2; i++)
+ xx1[N2+i] = mem1[2*i+1];
+ for (i = 0; i < N2; i++)
+ xx2[i] = x2[N2-1-i];
+ for (i = 0; i < M2; i++)
+ xx2[N2+i] = mem2[2*i+1];
+
+ for (i = 0; i < N2; i += 2) {
+ spx_sig_t y0, y1, y2, y3;
+ spx_word16_t x10, x20;
+
+ y0 = y1 = y2 = y3 = 0;
+ x10 = xx1[N2-2-i];
+ x20 = xx2[N2-2-i];
+
+ for (j = 0; j < M2; j += 2) {
+ spx_word16_t x11, x21;
+ spx_word16_t a0, a1;
+
+ a0 = a[2*j];
+ a1 = a[2*j+1];
+ x11 = xx1[N2-1+j-i];
+ x21 = xx2[N2-1+j-i];
+
+#ifdef FIXED_POINT
+ /* We multiply twice by the same coef to avoid overflows */
+ y0 = MAC16_16(MAC16_16(y0, a0, x11), NEG16(a0), x21);
+ y1 = MAC16_16(MAC16_16(y1, a1, x11), a1, x21);
+ y2 = MAC16_16(MAC16_16(y2, a0, x10), NEG16(a0), x20);
+ y3 = MAC16_16(MAC16_16(y3, a1, x10), a1, x20);
+#else
+ y0 = ADD32(y0,MULT16_16(a0, x11-x21));
+ y1 = ADD32(y1,MULT16_16(a1, x11+x21));
+ y2 = ADD32(y2,MULT16_16(a0, x10-x20));
+ y3 = ADD32(y3,MULT16_16(a1, x10+x20));
+#endif
+ a0 = a[2*j+2];
+ a1 = a[2*j+3];
+ x10 = xx1[N2+j-i];
+ x20 = xx2[N2+j-i];
+
+#ifdef FIXED_POINT
+ /* We multiply twice by the same coef to avoid overflows */
+ y0 = MAC16_16(MAC16_16(y0, a0, x10), NEG16(a0), x20);
+ y1 = MAC16_16(MAC16_16(y1, a1, x10), a1, x20);
+ y2 = MAC16_16(MAC16_16(y2, a0, x11), NEG16(a0), x21);
+ y3 = MAC16_16(MAC16_16(y3, a1, x11), a1, x21);
+#else
+ y0 = ADD32(y0,MULT16_16(a0, x10-x20));
+ y1 = ADD32(y1,MULT16_16(a1, x10+x20));
+ y2 = ADD32(y2,MULT16_16(a0, x11-x21));
+ y3 = ADD32(y3,MULT16_16(a1, x11+x21));
+#endif
+ }
+#ifdef FIXED_POINT
+ y[2*i] = EXTRACT16(SATURATE32(PSHR32(y0,15),32767));
+ y[2*i+1] = EXTRACT16(SATURATE32(PSHR32(y1,15),32767));
+ y[2*i+2] = EXTRACT16(SATURATE32(PSHR32(y2,15),32767));
+ y[2*i+3] = EXTRACT16(SATURATE32(PSHR32(y3,15),32767));
+#else
+ /* Normalize up explicitly if we're in float */
+ y[2*i] = 2.f*y0;
+ y[2*i+1] = 2.f*y1;
+ y[2*i+2] = 2.f*y2;
+ y[2*i+3] = 2.f*y3;
+#endif
+ }
+
+ for (i = 0; i < M2; i++)
+ mem1[2*i+1] = xx1[i];
+ for (i = 0; i < M2; i++)
+ mem2[2*i+1] = xx2[i];
+}
+
+#ifdef FIXED_POINT
+#if 0
+const spx_word16_t shift_filt[3][7] = {{-33, 1043, -4551, 19959, 19959, -4551, 1043},
+ {-98, 1133, -4425, 29179, 8895, -2328, 444},
+ {444, -2328, 8895, 29179, -4425, 1133, -98}};
+#else
+const spx_word16_t shift_filt[3][7] = {{-390, 1540, -4993, 20123, 20123, -4993, 1540},
+ {-1064, 2817, -6694, 31589, 6837, -990, -209},
+ {-209, -990, 6837, 31589, -6694, 2817, -1064}};
+#endif
+#else
+#if 0
+const float shift_filt[3][7] = {{-9.9369e-04, 3.1831e-02, -1.3889e-01, 6.0910e-01, 6.0910e-01, -1.3889e-01, 3.1831e-02},
+ {-0.0029937, 0.0345613, -0.1350474, 0.8904793, 0.2714479, -0.0710304, 0.0135403},
+ {0.0135403, -0.0710304, 0.2714479, 0.8904793, -0.1350474, 0.0345613, -0.0029937}};
+#else
+const float shift_filt[3][7] = {{-0.011915f, 0.046995f, -0.152373f, 0.614108f, 0.614108f, -0.152373f, 0.046995f},
+ {-0.0324855f, 0.0859768f, -0.2042986f, 0.9640297f, 0.2086420f, -0.0302054f, -0.0063646f},
+ {-0.0063646f, -0.0302054f, 0.2086420f, 0.9640297f, -0.2042986f, 0.0859768f, -0.0324855f}};
+#endif
+#endif
+
+int interp_pitch(
+spx_word16_t *exc, /*decoded excitation*/
+spx_word16_t *interp, /*decoded excitation*/
+int pitch, /*pitch period*/
+int len
+)
+{
+ int i,j,k;
+ spx_word32_t corr[4][7];
+ spx_word32_t maxcorr;
+ int maxi, maxj;
+ for (i=0;i<7;i++)
+ {
+ corr[0][i] = inner_prod(exc, exc-pitch-3+i, len);
+ }
+ for (i=0;i<3;i++)
+ {
+ for (j=0;j<7;j++)
+ {
+ int i1, i2;
+ spx_word32_t tmp=0;
+ i1 = 3-j;
+ if (i1<0)
+ i1 = 0;
+ i2 = 10-j;
+ if (i2>7)
+ i2 = 7;
+ for (k=i1;k<i2;k++)
+ tmp += MULT16_32_Q15(shift_filt[i][k],corr[0][j+k-3]);
+ corr[i+1][j] = tmp;
+ }
+ }
+ maxi=maxj=0;
+ maxcorr = corr[0][0];
+ for (i=0;i<4;i++)
+ {
+ for (j=0;j<7;j++)
+ {
+ if (corr[i][j] > maxcorr)
+ {
+ maxcorr = corr[i][j];
+ maxi=i;
+ maxj=j;
+ }
+ }
+ }
+ for (i=0;i<len;i++)
+ {
+ spx_word32_t tmp = 0;
+ if (maxi>0)
+ {
+ for (k=0;k<7;k++)
+ {
+ tmp += MULT16_16(exc[i-(pitch-maxj+3)+k-3],shift_filt[maxi-1][k]);
+ }
+ } else {
+ tmp = SHL32(exc[i-(pitch-maxj+3)],15);
+ }
+ interp[i] = PSHR32(tmp,15);
+ }
+ return pitch-maxj+3;
+}
+
+void multicomb(
+spx_word16_t *exc, /*decoded excitation*/
+spx_word16_t *new_exc, /*enhanced excitation*/
+spx_coef_t *ak, /*LPC filter coefs*/
+int p, /*LPC order*/
+int nsf, /*sub-frame size*/
+int pitch, /*pitch period*/
+int max_pitch,
+spx_word16_t comb_gain, /*gain of comb filter*/
+char *stack
+)
+{
+ int i;
+ VARDECL(spx_word16_t *iexc);
+ spx_word16_t old_ener, new_ener;
+ int corr_pitch;
+
+ spx_word16_t iexc0_mag, iexc1_mag, exc_mag;
+ spx_word32_t corr0, corr1;
+ spx_word16_t gain0, gain1;
+ spx_word16_t pgain1, pgain2;
+ spx_word16_t c1, c2;
+ spx_word16_t g1, g2;
+ spx_word16_t ngain;
+ spx_word16_t gg1, gg2;
+#ifdef FIXED_POINT
+ int scaledown=0;
+#endif
+#if 0 /* Set to 1 to enable full pitch search */
+ int nol_pitch[6];
+ spx_word16_t nol_pitch_coef[6];
+ spx_word16_t ol_pitch_coef;
+ open_loop_nbest_pitch(exc, 20, 120, nsf,
+ nol_pitch, nol_pitch_coef, 6, stack);
+ corr_pitch=nol_pitch[0];
+ ol_pitch_coef = nol_pitch_coef[0];
+ /*Try to remove pitch multiples*/
+ for (i=1;i<6;i++)
+ {
+#ifdef FIXED_POINT
+ if ((nol_pitch_coef[i]>MULT16_16_Q15(nol_pitch_coef[0],19661)) &&
+#else
+ if ((nol_pitch_coef[i]>.6*nol_pitch_coef[0]) &&
+#endif
+ (ABS(2*nol_pitch[i]-corr_pitch)<=2 || ABS(3*nol_pitch[i]-corr_pitch)<=3 ||
+ ABS(4*nol_pitch[i]-corr_pitch)<=4 || ABS(5*nol_pitch[i]-corr_pitch)<=5))
+ {
+ corr_pitch = nol_pitch[i];
+ }
+ }
+#else
+ corr_pitch = pitch;
+#endif
+
+ ALLOC(iexc, 2*nsf, spx_word16_t);
+
+ interp_pitch(exc, iexc, corr_pitch, 80);
+ if (corr_pitch>max_pitch)
+ interp_pitch(exc, iexc+nsf, 2*corr_pitch, 80);
+ else
+ interp_pitch(exc, iexc+nsf, -corr_pitch, 80);
+
+#ifdef FIXED_POINT
+ for (i=0;i<nsf;i++)
+ {
+ if (ABS16(exc[i])>16383)
+ {
+ scaledown = 1;
+ break;
+ }
+ }
+ if (scaledown)
+ {
+ for (i=0;i<nsf;i++)
+ exc[i] = SHR16(exc[i],1);
+ for (i=0;i<2*nsf;i++)
+ iexc[i] = SHR16(iexc[i],1);
+ }
+#endif
+ /*interp_pitch(exc, iexc+2*nsf, 2*corr_pitch, 80);*/
+
+ /*printf ("%d %d %f\n", pitch, corr_pitch, max_corr*ener_1);*/
+ iexc0_mag = spx_sqrt(1000+inner_prod(iexc,iexc,nsf));
+ iexc1_mag = spx_sqrt(1000+inner_prod(iexc+nsf,iexc+nsf,nsf));
+ exc_mag = spx_sqrt(1+inner_prod(exc,exc,nsf));
+ corr0 = inner_prod(iexc,exc,nsf);
+ if (corr0<0)
+ corr0=0;
+ corr1 = inner_prod(iexc+nsf,exc,nsf);
+ if (corr1<0)
+ corr1=0;
+#ifdef FIXED_POINT
+ /* Doesn't cost much to limit the ratio and it makes the rest easier */
+ if (SHL32(EXTEND32(iexc0_mag),6) < EXTEND32(exc_mag))
+ iexc0_mag = ADD16(1,PSHR16(exc_mag,6));
+ if (SHL32(EXTEND32(iexc1_mag),6) < EXTEND32(exc_mag))
+ iexc1_mag = ADD16(1,PSHR16(exc_mag,6));
+#endif
+ if (corr0 > MULT16_16(iexc0_mag,exc_mag))
+ pgain1 = QCONST16(1., 14);
+ else
+ pgain1 = PDIV32_16(SHL32(PDIV32(corr0, exc_mag),14),iexc0_mag);
+ if (corr1 > MULT16_16(iexc1_mag,exc_mag))
+ pgain2 = QCONST16(1., 14);
+ else
+ pgain2 = PDIV32_16(SHL32(PDIV32(corr1, exc_mag),14),iexc1_mag);
+ gg1 = PDIV32_16(SHL32(EXTEND32(exc_mag),8), iexc0_mag);
+ gg2 = PDIV32_16(SHL32(EXTEND32(exc_mag),8), iexc1_mag);
+ if (comb_gain>0)
+ {
+#ifdef FIXED_POINT
+ c1 = (MULT16_16_Q15(QCONST16(.4,15),comb_gain)+QCONST16(.07,15));
+ c2 = QCONST16(.5,15)+MULT16_16_Q14(QCONST16(1.72,14),(c1-QCONST16(.07,15)));
+#else
+ c1 = .4*comb_gain+.07;
+ c2 = .5+1.72*(c1-.07);
+#endif
+ } else
+ {
+ c1=c2=0;
+ }
+#ifdef FIXED_POINT
+ g1 = 32767 - MULT16_16_Q13(MULT16_16_Q15(c2, pgain1),pgain1);
+ g2 = 32767 - MULT16_16_Q13(MULT16_16_Q15(c2, pgain2),pgain2);
+#else
+ g1 = 1-c2*pgain1*pgain1;
+ g2 = 1-c2*pgain2*pgain2;
+#endif
+ if (g1<c1)
+ g1 = c1;
+ if (g2<c1)
+ g2 = c1;
+ g1 = (spx_word16_t)PDIV32_16(SHL32(EXTEND32(c1),14),(spx_word16_t)g1);
+ g2 = (spx_word16_t)PDIV32_16(SHL32(EXTEND32(c1),14),(spx_word16_t)g2);
+ if (corr_pitch>max_pitch)
+ {
+ gain0 = MULT16_16_Q15(QCONST16(.7,15),MULT16_16_Q14(g1,gg1));
+ gain1 = MULT16_16_Q15(QCONST16(.3,15),MULT16_16_Q14(g2,gg2));
+ } else {
+ gain0 = MULT16_16_Q15(QCONST16(.6,15),MULT16_16_Q14(g1,gg1));
+ gain1 = MULT16_16_Q15(QCONST16(.6,15),MULT16_16_Q14(g2,gg2));
+ }
+ for (i=0;i<nsf;i++)
+ new_exc[i] = ADD16(exc[i], EXTRACT16(PSHR32(ADD32(MULT16_16(gain0,iexc[i]), MULT16_16(gain1,iexc[i+nsf])),8)));
+ /* FIXME: compute_rms16 is currently not quite accurate enough (but close) */
+ new_ener = compute_rms16(new_exc, nsf);
+ old_ener = compute_rms16(exc, nsf);
+
+ if (old_ener < 1)
+ old_ener = 1;
+ if (new_ener < 1)
+ new_ener = 1;
+ if (old_ener > new_ener)
+ old_ener = new_ener;
+ ngain = PDIV32_16(SHL32(EXTEND32(old_ener),14),new_ener);
+
+ for (i=0;i<nsf;i++)
+ new_exc[i] = MULT16_16_Q14(ngain, new_exc[i]);
+#ifdef FIXED_POINT
+ if (scaledown)
+ {
+ for (i=0;i<nsf;i++)
+ exc[i] = SHL16(exc[i],1);
+ for (i=0;i<nsf;i++)
+ new_exc[i] = SHL16(SATURATE16(new_exc[i],16383),1);
+ }
+#endif
+}
+