Staging: Lindent the echo driver (4460a860) · Commits · 戴 / test

drivers/staging/echo/bit_operations.h

+90 −97

Original line number	Diff line number	Diff line
		@@ -42,7 +42,8 @@ static __inline__ int top_bit(unsigned int bits)
		" decl %[res];\n"
		" bsrl %[bits],%[res]\n"
		:[res] "=&r" (res)
		: [bits] "rm" (bits));
		:[bits] "rm"(bits)
		);
		return res;
		}

		@@ -57,7 +58,8 @@ static __inline__ int bottom_bit(unsigned int bits)
		" decl %[res];\n"
		" bsfl %[bits],%[res]\n"
		:[res] "=&r" (res)
		: [bits] "rm" (bits));
		:[bits] "rm"(bits)
		);
		return res;
		}
		#else
		@@ -68,28 +70,23 @@ static __inline__ int top_bit(unsigned int bits)
		if (bits == 0)
		return -1;
		i = 0;
		if (bits & 0xFFFF0000)
		{
		if (bits & 0xFFFF0000) {
		bits &= 0xFFFF0000;
		i += 16;
		}
		if (bits & 0xFF00FF00)
		{
		if (bits & 0xFF00FF00) {
		bits &= 0xFF00FF00;
		i += 8;
		}
		if (bits & 0xF0F0F0F0)
		{
		if (bits & 0xF0F0F0F0) {
		bits &= 0xF0F0F0F0;
		i += 4;
		}
		if (bits & 0xCCCCCCCC)
		{
		if (bits & 0xCCCCCCCC) {
		bits &= 0xCCCCCCCC;
		i += 2;
		}
		if (bits & 0xAAAAAAAA)
		{
		if (bits & 0xAAAAAAAA) {
		bits &= 0xAAAAAAAA;
		i += 1;
		}
		@@ -103,28 +100,23 @@ static __inline__ int bottom_bit(unsigned int bits)
		if (bits == 0)
		return -1;
		i = 32;
		if (bits & 0x0000FFFF)
		{
		if (bits & 0x0000FFFF) {
		bits &= 0x0000FFFF;
		i -= 16;
		}
		if (bits & 0x00FF00FF)
		{
		if (bits & 0x00FF00FF) {
		bits &= 0x00FF00FF;
		i -= 8;
		}
		if (bits & 0x0F0F0F0F)
		{
		if (bits & 0x0F0F0F0F) {
		bits &= 0x0F0F0F0F;
		i -= 4;
		}
		if (bits & 0x33333333)
		{
		if (bits & 0x33333333) {
		bits &= 0x33333333;
		i -= 2;
		}
		if (bits & 0x55555555)
		{
		if (bits & 0x55555555) {
		bits &= 0x55555555;
		i -= 1;
		}
		@@ -139,7 +131,8 @@ static __inline__ uint8_t bit_reverse8(uint8_t x)
		{
		#if defined(__i386__) \|\| defined(__x86_64__)
		/* If multiply is fast */
		return ((x0x0802U & 0x22110U) \| (x0x8020U & 0x88440U))*0x10101U >> 16;
		return ((x * 0x0802U & 0x22110U) \| (x * 0x8020U & 0x88440U)) *
		0x10101U >> 16;
		#else
		/* If multiply is slow, but we have a barrel shifter */
		x = (x >> 4) \| (x << 4);

drivers/staging/echo/echo.c

+404 −399

Original line number	Diff line number	Diff line
		@@ -74,7 +74,6 @@

		Steve also has some nice notes on echo cancellers in echo.h


		References:

		[1] Ochiai, Areseki, and Ogihara, "Echo Canceller with Two Echo
		@@ -124,9 +123,9 @@

		/* adapting coeffs using the traditional stochastic descent (N)LMS algorithm */


		#ifdef __bfin__
		static void __inline__ lms_adapt_bg(struct oslec_state *ec, int clean, int shift)
		static void __inline__ lms_adapt_bg(struct oslec_state *ec, int clean,
		int shift)
		{
		int i, j;
		int offset1;
		@@ -151,8 +150,7 @@ static void __inline__ lms_adapt_bg(struct oslec_state *ec, int clean, int shift

		//asm("st:");
		n = ec->taps;
		for (i = 0, j = offset2; i < n; i++, j++)
		{
		for (i = 0, j = offset2; i < n; i++, j++) {
		exp = phist++ factor;
		ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
		}
		@@ -198,7 +196,8 @@ static void __inline__ lms_adapt_bg(struct oslec_state *ec, int clean, int shift
		*/

		#else
		static __inline__ void lms_adapt_bg(struct oslec_state *ec, int clean, int shift)
		static __inline__ void lms_adapt_bg(struct oslec_state *ec, int clean,
		int shift)
		{
		int i;

		@@ -217,20 +216,17 @@ static __inline__ void lms_adapt_bg(struct oslec_state *ec, int clean, int shift
		offset2 = ec->curr_pos;
		offset1 = ec->taps - offset2;

		for (i = ec->taps - 1; i >= offset1; i--)
		{
		for (i = ec->taps - 1; i >= offset1; i--) {
		exp = (ec->fir_state_bg.history[i - offset1] * factor);
		ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
		}
		for ( ; i >= 0; i--)
		{
		for (; i >= 0; i--) {
		exp = (ec->fir_state_bg.history[i + offset2] * factor);
		ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
		}
		}
		#endif


		struct oslec_state *oslec_create(int len, int adaption_mode)
		{
		struct oslec_state *ec;
		@@ -245,17 +241,14 @@ struct oslec_state *oslec_create(int len, int adaption_mode)
		ec->curr_pos = ec->taps - 1;

		for (i = 0; i < 2; i++) {
		ec->fir_taps16[i] = kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL);
		ec->fir_taps16[i] =
		kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL);
		if (!ec->fir_taps16[i])
		goto error_oom;
		}

		fir16_create(&ec->fir_state,
		ec->fir_taps16[0],
		ec->taps);
		fir16_create(&ec->fir_state_bg,
		ec->fir_taps16[1],
		ec->taps);
		fir16_create(&ec->fir_state, ec->fir_taps16[0], ec->taps);
		fir16_create(&ec->fir_state_bg, ec->fir_taps16[1], ec->taps);

		for (i = 0; i < 5; i++) {
		ec->xvtx[i] = ec->yvtx[i] = ec->xvrx[i] = ec->yvrx[i] = 0;
		@@ -286,6 +279,7 @@ error_oom:
		kfree(ec);
		return NULL;
		}

		EXPORT_SYMBOL_GPL(oslec_create);

		void oslec_free(struct oslec_state *ec)
		@@ -299,12 +293,14 @@ void oslec_free(struct oslec_state *ec)
		kfree(ec->snapshot);
		kfree(ec);
		}

		EXPORT_SYMBOL_GPL(oslec_free);

		void oslec_adaption_mode(struct oslec_state *ec, int adaption_mode)
		{
		ec->adaption_mode = adaption_mode;
		}

		EXPORT_SYMBOL_GPL(oslec_adaption_mode);

		void oslec_flush(struct oslec_state *ec)
		@@ -331,11 +327,14 @@ void oslec_flush(struct oslec_state *ec)
		ec->curr_pos = ec->taps - 1;
		ec->Pstates = 0;
		}

		EXPORT_SYMBOL_GPL(oslec_flush);

		void oslec_snapshot(struct oslec_state *ec) {
		void oslec_snapshot(struct oslec_state *ec)
		{
		memcpy(ec->snapshot, ec->fir_taps16[0], ec->taps * sizeof(int16_t));
		}

		EXPORT_SYMBOL_GPL(oslec_snapshot);

		/* Dual Path Echo Canceller ------------------------------------------------*/
		@@ -350,7 +349,8 @@ int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)
		starts clipping. Another possible way to handle this would be the
		filter coefficent scaling. */

		ec->tx = tx; ec->rx = rx;
		ec->tx = tx;
		ec->rx = rx;
		tx >>= 1;
		rx >>= 1;

		@@ -383,8 +383,10 @@ int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)
		/* hard limit filter to prevent clipping. Note that at this stage
		rx should be limited to +/- 16383 due to right shift above */
		tmp1 = ec->rx_1 >> 15;
		if (tmp1 > 16383) tmp1 = 16383;
		if (tmp1 < -16383) tmp1 = -16383;
		if (tmp1 > 16383)
		tmp1 = 16383;
		if (tmp1 < -16383)
		tmp1 = -16383;
		rx = tmp1;
		ec->rx_2 = tmp;
		}
		@@ -401,8 +403,10 @@ int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)
		new = (int)tx *(int)tx;
		old = (int)ec->fir_state.history[ec->fir_state.curr_pos] *
		(int)ec->fir_state.history[ec->fir_state.curr_pos];
		ec->Pstates += ((new - old) + (1<<ec->log2taps)) >> ec->log2taps;
		if (ec->Pstates < 0) ec->Pstates = 0;
		ec->Pstates +=
		((new - old) + (1 << ec->log2taps)) >> ec->log2taps;
		if (ec->Pstates < 0)
		ec->Pstates = 0;
		}

		/* Calculate short term average levels using simple single pole IIRs */
		@@ -495,34 +499,31 @@ int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)

		if ((ec->adaption_mode & ECHO_CAN_USE_ADAPTION) &&
		(ec->nonupdate_dwell == 0) &&
		(8ec->Lclean_bg < 7ec->Lclean) /* (ec->Lclean_bg < 0.875ec->Lclean) / &&
		(8ec->Lclean_bg < ec->Ltx) / (ec->Lclean_bg < 0.125ec->Ltx) / )
		{
		(8 * ec->Lclean_bg <
		7 * ec->Lclean) /* (ec->Lclean_bg < 0.875ec->Lclean) / &&
		(8 * ec->Lclean_bg <
		ec->Ltx) /* (ec->Lclean_bg < 0.125ec->Ltx) / ) {
		if (ec->cond_met == 6) {
		/* BG filter has had better results for 6 consecutive samples */
		ec->adapt = 1;
		memcpy(ec->fir_taps16[0], ec->fir_taps16[1], ec->taps*sizeof(int16_t));
		}
		else
		memcpy(ec->fir_taps16[0], ec->fir_taps16[1],
		ec->taps * sizeof(int16_t));
		} else
		ec->cond_met++;
		}
		else
		} else
		ec->cond_met = 0;

		/* Non-Linear Processing --------------------------------------------------- */

		ec->clean_nlp = ec->clean;
		if (ec->adaption_mode & ECHO_CAN_USE_NLP)
		{
		if (ec->adaption_mode & ECHO_CAN_USE_NLP) {
		/* Non-linear processor - a fancy way to say "zap small signals, to avoid
		residual echo due to (uLaw/ALaw) non-linearity in the channel.". */

		if ((16*ec->Lclean < ec->Ltx))
		{
		if ((16 * ec->Lclean < ec->Ltx)) {
		/* Our e/c has improved echo by at least 24 dB (each factor of 2 is 6dB,
		so 2222=16 is the same as 6+6+6+6=24dB) /
		if (ec->adaption_mode & ECHO_CAN_USE_CNG)
		{
		if (ec->adaption_mode & ECHO_CAN_USE_CNG) {
		ec->cng_level = ec->Lbgn;

		/* Very elementary comfort noise generation. Just random
		@@ -533,27 +534,26 @@ int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)
		high level or look at spectrum.
		*/

		ec->cng_rndnum = 1664525U*ec->cng_rndnum + 1013904223U;
		ec->cng_filter = ((ec->cng_rndnum & 0xFFFF) - 32768 + 5*ec->cng_filter) >> 3;
		ec->clean_nlp = (ec->cng_filterec->cng_level8) >> 14;
		ec->cng_rndnum =
		1664525U * ec->cng_rndnum + 1013904223U;
		ec->cng_filter =
		((ec->cng_rndnum & 0xFFFF) - 32768 +
		5 * ec->cng_filter) >> 3;
		ec->clean_nlp =
		(ec->cng_filter * ec->cng_level * 8) >> 14;

		}
		else if (ec->adaption_mode & ECHO_CAN_USE_CLIP)
		{
		} else if (ec->adaption_mode & ECHO_CAN_USE_CLIP) {
		/* This sounds much better than CNG */
		if (ec->clean_nlp > ec->Lbgn)
		ec->clean_nlp = ec->Lbgn;
		if (ec->clean_nlp < -ec->Lbgn)
		ec->clean_nlp = -ec->Lbgn;
		}
		else
		{
		} else {
		/* just mute the residual, doesn't sound very good, used mainly
		in G168 tests */
		ec->clean_nlp = 0;
		}
		}
		else {
		} else {
		/* Background noise estimator. I tried a few algorithms
		here without much luck. This very simple one seems to
		work best, we just average the level using a slow (1 sec
		@@ -581,6 +581,7 @@ int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)

		return (int16_t) ec->clean_nlp << 1;
		}

		EXPORT_SYMBOL_GPL(oslec_update);

		/* This function is seperated from the echo canceller is it is usually called
		@@ -604,7 +605,8 @@ EXPORT_SYMBOL_GPL(oslec_update);
		precision, which noise shapes things, giving very clean DC removal.
		*/

		int16_t oslec_hpf_tx(struct oslec_state *ec, int16_t tx) {
		int16_t oslec_hpf_tx(struct oslec_state * ec, int16_t tx)
		{
		int tmp, tmp1;

		if (ec->adaption_mode & ECHO_CAN_USE_TX_HPF) {
		@@ -618,14 +620,17 @@ int16_t oslec_hpf_tx(struct oslec_state *ec, int16_t tx) {
		#endif
		ec->tx_1 += -(ec->tx_1 >> DC_LOG2BETA) + tmp - ec->tx_2;
		tmp1 = ec->tx_1 >> 15;
		if (tmp1 > 32767) tmp1 = 32767;
		if (tmp1 < -32767) tmp1 = -32767;
		if (tmp1 > 32767)
		tmp1 = 32767;
		if (tmp1 < -32767)
		tmp1 = -32767;
		tx = tmp1;
		ec->tx_2 = tmp;
		}

		return tx;
		}

		EXPORT_SYMBOL_GPL(oslec_hpf_tx);

		MODULE_LICENSE("GPL");

drivers/staging/echo/echo.h

+3 −4

Original line number	Diff line number	Diff line
		@@ -124,8 +124,7 @@ a minor burden.
		G.168 echo canceller descriptor. This defines the working state for a line
		echo canceller.
		*/
		struct oslec_state
		{
		struct oslec_state {
		int16_t tx, rx;
		int16_t clean;
		int16_t clean_nlp;

drivers/staging/echo/fir.h

+145 −153

Original line number	Diff line number	Diff line
		@@ -72,8 +72,7 @@
		16 bit integer FIR descriptor. This defines the working state for a single
		instance of an FIR filter using 16 bit integer coefficients.
		*/
		typedef struct
		{
		typedef struct {
		int taps;
		int curr_pos;
		const int16_t *coeffs;
		@@ -85,8 +84,7 @@ typedef struct
		instance of an FIR filter using 32 bit integer coefficients, and filtering
		16 bit integer data.
		*/
		typedef struct
		{
		typedef struct {
		int taps;
		int curr_pos;
		const int32_t *coeffs;
		@@ -97,8 +95,7 @@ typedef struct
		Floating point FIR descriptor. This defines the working state for a single
		instance of an FIR filter using floating point coefficients and data.
		*/
		typedef struct
		{
		typedef struct {
		int taps;
		int curr_pos;
		const float *coeffs;
		@@ -106,8 +103,7 @@ typedef struct
		} fir_float_state_t;

		static __inline__ const int16_t fir16_create(fir16_state_t fir,
		const int16_t *coeffs,
		int taps)
		const int16_t * coeffs, int taps)
		{
		fir->taps = taps;
		fir->curr_pos = taps - 1;
		@@ -141,9 +137,7 @@ static inline int32_t dot_asm(short x, short y, int len)

		len--;

		__asm__
		(
		"I0 = %1;\n\t"
		__asm__("I0 = %1;\n\t"
		"I1 = %2;\n\t"
		"A0 = 0;\n\t"
		"R0.L = W[I0++] \|\| R1.L = W[I1++];\n\t"
		@@ -179,8 +173,7 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
		i = fir->taps;
		pxor_r2r(mm4, mm4);
		/* 8 samples per iteration, so the filter must be a multiple of 8 long. */
		while (i > 0)
		{
		while (i > 0) {
		movq_m2r(mmx_coeffs[0], mm0);
		movq_m2r(mmx_coeffs[1], mm2);
		movq_m2r(mmx_hist[0], mm1);
		@@ -211,8 +204,7 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
		i = fir->taps;
		pxor_r2r(xmm4, xmm4);
		/* 16 samples per iteration, so the filter must be a multiple of 16 long. */
		while (i > 0)
		{
		while (i > 0) {
		movdqu_m2r(xmm_coeffs[0], xmm0);
		movdqu_m2r(xmm_coeffs[1], xmm2);
		movdqu_m2r(xmm_hist[0], xmm1);
		@@ -235,7 +227,8 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
		#elif defined(__bfin__)
		fir->history[fir->curr_pos] = sample;
		fir->history[fir->curr_pos + fir->taps] = sample;
		y = dot_asm((int16_t*)fir->coeffs, &fir->history[fir->curr_pos], fir->taps);
		y = dot_asm((int16_t *) fir->coeffs, &fir->history[fir->curr_pos],
		fir->taps);
		#else
		int i;
		int offset1;
		@@ -258,8 +251,7 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
		}

		static __inline__ const int16_t fir32_create(fir32_state_t fir,
		const int32_t *coeffs,
		int taps)
		const int32_t * coeffs, int taps)
		{
		fir->taps = taps;
		fir->curr_pos = taps - 1;

drivers/staging/echo/mmx.h

+11 −18

Original line number	Diff line number	Diff line
		@@ -44,7 +44,6 @@ typedef union {
		char b[16];
		} xmm_t;


		#define mmx_i2r(op,imm,reg) \
		__asm__ __volatile__ (#op " %0, %%" #reg \
		: /* nothing */ \
		@@ -63,7 +62,6 @@ typedef union {
		#define mmx_r2r(op,regs,regd) \
		__asm__ __volatile__ (#op " %" #regs ", %" #regd)


		#define emms() __asm__ __volatile__ ("emms")

		#define movd_m2r(var,reg) mmx_m2r (movd, var, reg)
		@@ -192,16 +190,13 @@ typedef union {
		#define pxor_m2r(var,reg) mmx_m2r (pxor, var, reg)
		#define pxor_r2r(regs,regd) mmx_r2r (pxor, regs, regd)


		/* 3DNOW extensions */

		#define pavgusb_m2r(var,reg) mmx_m2r (pavgusb, var, reg)
		#define pavgusb_r2r(regs,regd) mmx_r2r (pavgusb, regs, regd)


		/* AMD MMX extensions - also available in intel SSE */


		#define mmx_m2ri(op,mem,reg,imm) \
		__asm__ __volatile__ (#op " %1, %0, %%" #reg \
		: /* nothing */ \
		@@ -216,7 +211,6 @@ typedef union {
		: /* nothing */ \
		: "m" (mem))


		#define maskmovq(regs,maskreg) mmx_r2ri (maskmovq, regs, maskreg)

		#define movntq_r2m(mmreg,var) mmx_r2m (movntq, mmreg, var)
		@@ -284,5 +278,4 @@ typedef union {
		#define punpcklqdq_r2r(regs,regd) mmx_r2r (punpcklqdq, regs, regd)
		#define punpckhqdq_r2r(regs,regd) mmx_r2r (punpckhqdq, regs, regd)


		#endif /* AVCODEC_I386MMX_H */

drivers/staging/echo/oslec.h

+1 −1

File changed.

Contains only whitespace changes.

Admin message