* #27232: jni: added pjproject checkout as regular git content
We will remove it once the next release of pjsip (with Android support)
comes out and is merged into SFLphone.
diff --git a/jni/pjproject-android/.svn/pristine/94/945c28f16d7e46fe91415f8935b2c22d22bed69a.svn-base b/jni/pjproject-android/.svn/pristine/94/945c28f16d7e46fe91415f8935b2c22d22bed69a.svn-base
new file mode 100644
index 0000000..23f2f25
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/94/945c28f16d7e46fe91415f8935b2c22d22bed69a.svn-base
@@ -0,0 +1,377 @@
+/* $Id$ */
+/*
+ * Digital Audio Resampling Home Page located at
+ * http://www-ccrma.stanford.edu/~jos/resample/.
+ *
+ * SOFTWARE FOR SAMPLING-RATE CONVERSION AND FIR DIGITAL FILTER DESIGN
+ *
+ * Snippet from the resample.1 man page:
+ *
+ * HISTORY
+ *
+ * The first version of this software was written by Julius O. Smith III
+ * <jos@ccrma.stanford.edu> at CCRMA <http://www-ccrma.stanford.edu> in
+ * 1981. It was called SRCONV and was written in SAIL for PDP-10
+ * compatible machines. The algorithm was first published in
+ *
+ * Smith, Julius O. and Phil Gossett. ``A Flexible Sampling-Rate
+ * Conversion Method,'' Proceedings (2): 19.4.1-19.4.4, IEEE Conference
+ * on Acoustics, Speech, and Signal Processing, San Diego, March 1984.
+ *
+ * An expanded tutorial based on this paper is available at the Digital
+ * Audio Resampling Home Page given above.
+ *
+ * Circa 1988, the SRCONV program was translated from SAIL to C by
+ * Christopher Lee Fraley working with Roger Dannenberg at CMU.
+ *
+ * Since then, the C version has been maintained by jos.
+ *
+ * Sndlib support was added 6/99 by John Gibson <jgg9c@virginia.edu>.
+ *
+ * The resample program is free software distributed in accordance
+ * with the Lesser GNU Public License (LGPL). There is NO warranty; not
+ * even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/* PJMEDIA modification:
+ * - remove resample(), just use SrcUp, SrcUD, and SrcLinear directly.
+ * - move FilterUp() and FilterUD() from filterkit.c
+ * - move stddefs.h and resample.h to this file.
+ * - const correctness.
+ */
+
+#include <resamplesubs.h>
+#include "config.h"
+#include "stddefs.h"
+#include "resample.h"
+
+
+#ifdef _MSC_VER
+# pragma warning(push, 3)
+//# pragma warning(disable: 4245) // Conversion from uint to ushort
+# pragma warning(disable: 4244) // Conversion from double to uint
+# pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned
+# pragma warning(disable: 4761) // integral size mismatch in argument; conversion supplied
+#endif
+
+#if defined(RESAMPLE_HAS_SMALL_FILTER) && RESAMPLE_HAS_SMALL_FILTER!=0
+# include "smallfilter.h"
+#else
+# define SMALL_FILTER_NMULT 0
+# define SMALL_FILTER_SCALE 0
+# define SMALL_FILTER_NWING 0
+# define SMALL_FILTER_IMP NULL
+# define SMALL_FILTER_IMPD NULL
+#endif
+
+#if defined(RESAMPLE_HAS_LARGE_FILTER) && RESAMPLE_HAS_LARGE_FILTER!=0
+# include "largefilter.h"
+#else
+# define LARGE_FILTER_NMULT 0
+# define LARGE_FILTER_SCALE 0
+# define LARGE_FILTER_NWING 0
+# define LARGE_FILTER_IMP NULL
+# define LARGE_FILTER_IMPD NULL
+#endif
+
+
+#undef INLINE
+#define INLINE
+#define HAVE_FILTER 0
+
+#ifndef NULL
+# define NULL 0
+#endif
+
+
+static INLINE RES_HWORD WordToHword(RES_WORD v, int scl)
+{
+ RES_HWORD out;
+ RES_WORD llsb = (1<<(scl-1));
+ v += llsb; /* round */
+ v >>= scl;
+ if (v>MAX_HWORD) {
+ v = MAX_HWORD;
+ } else if (v < MIN_HWORD) {
+ v = MIN_HWORD;
+ }
+ out = (RES_HWORD) v;
+ return out;
+}
+
+/* Sampling rate conversion using linear interpolation for maximum speed.
+ */
+static int
+ SrcLinear(const RES_HWORD X[], RES_HWORD Y[], double pFactor, RES_UHWORD nx)
+{
+ RES_HWORD iconst;
+ RES_UWORD time = 0;
+ const RES_HWORD *xp;
+ RES_HWORD *Ystart, *Yend;
+ RES_WORD v,x1,x2;
+
+ double dt; /* Step through input signal */
+ RES_UWORD dtb; /* Fixed-point version of Dt */
+ RES_UWORD endTime; /* When time reaches EndTime, return to user */
+
+ dt = 1.0/pFactor; /* Output sampling period */
+ dtb = dt*(1<<Np) + 0.5; /* Fixed-point representation */
+
+ Ystart = Y;
+ Yend = Ystart + (unsigned)(nx * pFactor + 0.5);
+ endTime = time + (1<<Np)*(RES_WORD)nx;
+
+ // Integer round down in dtb calculation may cause (endTime % dtb > 0),
+ // so it may cause resample write pass the output buffer (Y >= Yend).
+ // while (time < endTime)
+ while (Y < Yend)
+ {
+ iconst = (time) & Pmask;
+ xp = &X[(time)>>Np]; /* Ptr to current input sample */
+ x1 = *xp++;
+ x2 = *xp;
+ x1 *= ((1<<Np)-iconst);
+ x2 *= iconst;
+ v = x1 + x2;
+ *Y++ = WordToHword(v,Np); /* Deposit output */
+ time += dtb; /* Move to next sample by time increment */
+ }
+ return (Y - Ystart); /* Return number of output samples */
+}
+
+static RES_WORD FilterUp(const RES_HWORD Imp[], const RES_HWORD ImpD[],
+ RES_UHWORD Nwing, RES_BOOL Interp,
+ const RES_HWORD *Xp, RES_HWORD Ph, RES_HWORD Inc)
+{
+ const RES_HWORD *Hp;
+ const RES_HWORD *Hdp = NULL;
+ const RES_HWORD *End;
+ RES_HWORD a = 0;
+ RES_WORD v, t;
+
+ v=0;
+ Hp = &Imp[Ph>>Na];
+ End = &Imp[Nwing];
+ if (Interp) {
+ Hdp = &ImpD[Ph>>Na];
+ a = Ph & Amask;
+ }
+ if (Inc == 1) /* If doing right wing... */
+ { /* ...drop extra coeff, so when Ph is */
+ End--; /* 0.5, we don't do too many mult's */
+ if (Ph == 0) /* If the phase is zero... */
+ { /* ...then we've already skipped the */
+ Hp += Npc; /* first sample, so we must also */
+ Hdp += Npc; /* skip ahead in Imp[] and ImpD[] */
+ }
+ }
+ if (Interp)
+ while (Hp < End) {
+ t = *Hp; /* Get filter coeff */
+ t += (((RES_WORD)*Hdp)*a)>>Na; /* t is now interp'd filter coeff */
+ Hdp += Npc; /* Filter coeff differences step */
+ t *= *Xp; /* Mult coeff by input sample */
+ if (t & (1<<(Nhxn-1))) /* Round, if needed */
+ t += (1<<(Nhxn-1));
+ t >>= Nhxn; /* Leave some guard bits, but come back some */
+ v += t; /* The filter output */
+ Hp += Npc; /* Filter coeff step */
+
+ Xp += Inc; /* Input signal step. NO CHECK ON BOUNDS */
+ }
+ else
+ while (Hp < End) {
+ t = *Hp; /* Get filter coeff */
+ t *= *Xp; /* Mult coeff by input sample */
+ if (t & (1<<(Nhxn-1))) /* Round, if needed */
+ t += (1<<(Nhxn-1));
+ t >>= Nhxn; /* Leave some guard bits, but come back some */
+ v += t; /* The filter output */
+ Hp += Npc; /* Filter coeff step */
+ Xp += Inc; /* Input signal step. NO CHECK ON BOUNDS */
+ }
+ return(v);
+}
+
+
+static RES_WORD FilterUD(const RES_HWORD Imp[], const RES_HWORD ImpD[],
+ RES_UHWORD Nwing, RES_BOOL Interp,
+ const RES_HWORD *Xp, RES_HWORD Ph, RES_HWORD Inc, RES_UHWORD dhb)
+{
+ RES_HWORD a;
+ const RES_HWORD *Hp, *Hdp, *End;
+ RES_WORD v, t;
+ RES_UWORD Ho;
+
+ v=0;
+ Ho = (Ph*(RES_UWORD)dhb)>>Np;
+ End = &Imp[Nwing];
+ if (Inc == 1) /* If doing right wing... */
+ { /* ...drop extra coeff, so when Ph is */
+ End--; /* 0.5, we don't do too many mult's */
+ if (Ph == 0) /* If the phase is zero... */
+ Ho += dhb; /* ...then we've already skipped the */
+ } /* first sample, so we must also */
+ /* skip ahead in Imp[] and ImpD[] */
+ if (Interp)
+ while ((Hp = &Imp[Ho>>Na]) < End) {
+ t = *Hp; /* Get IR sample */
+ Hdp = &ImpD[Ho>>Na]; /* get interp (lower Na) bits from diff table*/
+ a = Ho & Amask; /* a is logically between 0 and 1 */
+ t += (((RES_WORD)*Hdp)*a)>>Na; /* t is now interp'd filter coeff */
+ t *= *Xp; /* Mult coeff by input sample */
+ if (t & 1<<(Nhxn-1)) /* Round, if needed */
+ t += 1<<(Nhxn-1);
+ t >>= Nhxn; /* Leave some guard bits, but come back some */
+ v += t; /* The filter output */
+ Ho += dhb; /* IR step */
+ Xp += Inc; /* Input signal step. NO CHECK ON BOUNDS */
+ }
+ else
+ while ((Hp = &Imp[Ho>>Na]) < End) {
+ t = *Hp; /* Get IR sample */
+ t *= *Xp; /* Mult coeff by input sample */
+ if (t & 1<<(Nhxn-1)) /* Round, if needed */
+ t += 1<<(Nhxn-1);
+ t >>= Nhxn; /* Leave some guard bits, but come back some */
+ v += t; /* The filter output */
+ Ho += dhb; /* IR step */
+ Xp += Inc; /* Input signal step. NO CHECK ON BOUNDS */
+ }
+ return(v);
+}
+
+/* Sampling rate up-conversion only subroutine;
+ * Slightly faster than down-conversion;
+ */
+static int SrcUp(const RES_HWORD X[], RES_HWORD Y[], double pFactor,
+ RES_UHWORD nx, RES_UHWORD pNwing, RES_UHWORD pLpScl,
+ const RES_HWORD pImp[], const RES_HWORD pImpD[], RES_BOOL Interp)
+{
+ const RES_HWORD *xp;
+ RES_HWORD *Ystart, *Yend;
+ RES_WORD v;
+
+ double dt; /* Step through input signal */
+ RES_UWORD dtb; /* Fixed-point version of Dt */
+ RES_UWORD time = 0;
+ RES_UWORD endTime; /* When time reaches EndTime, return to user */
+
+ dt = 1.0/pFactor; /* Output sampling period */
+ dtb = dt*(1<<Np) + 0.5; /* Fixed-point representation */
+
+ Ystart = Y;
+ Yend = Ystart + (unsigned)(nx * pFactor + 0.5);
+ endTime = time + (1<<Np)*(RES_WORD)nx;
+
+ // Integer round down in dtb calculation may cause (endTime % dtb > 0),
+ // so it may cause resample write pass the output buffer (Y >= Yend).
+ // while (time < endTime)
+ while (Y < Yend)
+ {
+ xp = &X[time>>Np]; /* Ptr to current input sample */
+ /* Perform left-wing inner product */
+ v = 0;
+ v = FilterUp(pImp, pImpD, pNwing, Interp, xp, (RES_HWORD)(time&Pmask),-1);
+
+ /* Perform right-wing inner product */
+ v += FilterUp(pImp, pImpD, pNwing, Interp, xp+1, (RES_HWORD)((-time)&Pmask),1);
+
+ v >>= Nhg; /* Make guard bits */
+ v *= pLpScl; /* Normalize for unity filter gain */
+ *Y++ = WordToHword(v,NLpScl); /* strip guard bits, deposit output */
+ time += dtb; /* Move to next sample by time increment */
+ }
+ return (Y - Ystart); /* Return the number of output samples */
+}
+
+
+/* Sampling rate conversion subroutine */
+
+static int SrcUD(const RES_HWORD X[], RES_HWORD Y[], double pFactor,
+ RES_UHWORD nx, RES_UHWORD pNwing, RES_UHWORD pLpScl,
+ const RES_HWORD pImp[], const RES_HWORD pImpD[], RES_BOOL Interp)
+{
+ const RES_HWORD *xp;
+ RES_HWORD *Ystart, *Yend;
+ RES_WORD v;
+
+ double dh; /* Step through filter impulse response */
+ double dt; /* Step through input signal */
+ RES_UWORD time = 0;
+ RES_UWORD endTime; /* When time reaches EndTime, return to user */
+ RES_UWORD dhb, dtb; /* Fixed-point versions of Dh,Dt */
+
+ dt = 1.0/pFactor; /* Output sampling period */
+ dtb = dt*(1<<Np) + 0.5; /* Fixed-point representation */
+
+ dh = MIN(Npc, pFactor*Npc); /* Filter sampling period */
+ dhb = dh*(1<<Na) + 0.5; /* Fixed-point representation */
+
+ Ystart = Y;
+ Yend = Ystart + (unsigned)(nx * pFactor + 0.5);
+ endTime = time + (1<<Np)*(RES_WORD)nx;
+
+ // Integer round down in dtb calculation may cause (endTime % dtb > 0),
+ // so it may cause resample write pass the output buffer (Y >= Yend).
+ // while (time < endTime)
+ while (Y < Yend)
+ {
+ xp = &X[time>>Np]; /* Ptr to current input sample */
+ v = FilterUD(pImp, pImpD, pNwing, Interp, xp, (RES_HWORD)(time&Pmask),
+ -1, dhb); /* Perform left-wing inner product */
+ v += FilterUD(pImp, pImpD, pNwing, Interp, xp+1, (RES_HWORD)((-time)&Pmask),
+ 1, dhb); /* Perform right-wing inner product */
+ v >>= Nhg; /* Make guard bits */
+ v *= pLpScl; /* Normalize for unity filter gain */
+ *Y++ = WordToHword(v,NLpScl); /* strip guard bits, deposit output */
+ time += dtb; /* Move to next sample by time increment */
+ }
+ return (Y - Ystart); /* Return the number of output samples */
+}
+
+
+DECL(int) res_SrcLinear(const RES_HWORD X[], RES_HWORD Y[],
+ double pFactor, RES_UHWORD nx)
+{
+ return SrcLinear(X, Y, pFactor, nx);
+}
+
+DECL(int) res_Resample(const RES_HWORD X[], RES_HWORD Y[], double pFactor,
+ RES_UHWORD nx, RES_BOOL LargeF, RES_BOOL Interp)
+{
+ if (pFactor >= 1) {
+
+ if (LargeF)
+ return SrcUp(X, Y, pFactor, nx,
+ LARGE_FILTER_NWING, LARGE_FILTER_SCALE,
+ LARGE_FILTER_IMP, LARGE_FILTER_IMPD, Interp);
+ else
+ return SrcUp(X, Y, pFactor, nx,
+ SMALL_FILTER_NWING, SMALL_FILTER_SCALE,
+ SMALL_FILTER_IMP, SMALL_FILTER_IMPD, Interp);
+
+ } else {
+
+ if (LargeF)
+ return SrcUD(X, Y, pFactor, nx,
+ LARGE_FILTER_NWING, LARGE_FILTER_SCALE * pFactor + 0.5,
+ LARGE_FILTER_IMP, LARGE_FILTER_IMPD, Interp);
+ else
+ return SrcUD(X, Y, pFactor, nx,
+ SMALL_FILTER_NWING, SMALL_FILTER_SCALE * pFactor + 0.5,
+ SMALL_FILTER_IMP, SMALL_FILTER_IMPD, Interp);
+
+ }
+}
+
+DECL(int) res_GetXOFF(double pFactor, RES_BOOL LargeF)
+{
+ if (LargeF)
+ return (LARGE_FILTER_NMULT + 1) / 2.0 *
+ MAX(1.0, 1.0/pFactor);
+ else
+ return (SMALL_FILTER_NMULT + 1) / 2.0 *
+ MAX(1.0, 1.0/pFactor);
+}
+