From fe3decb5589688d50f30a601387bd3fc873c638e Mon Sep 17 00:00:00 2001 From: Sean Bartell Date: Tue, 26 Jul 2011 23:47:30 -0400 Subject: [PATCH 2/7] rbcodec refactoring: fixedpoint and fracmul --- apps/rbcodecconfig.h | 2 + lib/rbcodec/SOURCES | 6 + lib/rbcodec/codecs/lib/fixedpoint.c | 2 +- lib/rbcodec/rbcodec.make | 1 + lib/rbcodec/test/Makefile | 5 +- lib/rbcodec/util/fixedpoint.c | 264 +++++++++++++++++++++++++++++++++++ lib/rbcodec/util/fixedpoint.h | 64 +++++++++ lib/rbcodec/util/fracmul.h | 101 +++++++++++++ lib/rbcodec/util/strlcpy.c | 51 +++++++ 9 files changed, 492 insertions(+), 4 deletions(-) create mode 100644 lib/rbcodec/util/fixedpoint.c create mode 100644 lib/rbcodec/util/fixedpoint.h create mode 100644 lib/rbcodec/util/fracmul.h create mode 100644 lib/rbcodec/util/strlcpy.c diff --git a/apps/rbcodecconfig.h b/apps/rbcodecconfig.h index 4248245..7e1225f 100644 --- a/apps/rbcodecconfig.h +++ b/apps/rbcodecconfig.h @@ -18,4 +18,6 @@ #define RBCODEC_ENABLE_CHANNEL_MODES #endif +#define HAVE_ROCKBOX_FIXEDPOINT + #endif diff --git a/lib/rbcodec/SOURCES b/lib/rbcodec/SOURCES index 0fca649..641c868 100644 --- a/lib/rbcodec/SOURCES +++ b/lib/rbcodec/SOURCES @@ -2,6 +2,12 @@ metadata/metadata.c metadata/id3tags.c metadata/mp3.c metadata/mp3data.c +#ifndef HAVE_ROCKBOX_FIXEDPOINT +util/fixedpoint.c +#endif +#ifndef HAVE_STRLCPY +util/strlcpy.c +#endif #if CONFIG_CODEC == SWCODEC dsp/dsp.c dsp/eq.c diff --git a/lib/rbcodec/codecs/lib/fixedpoint.c b/lib/rbcodec/codecs/lib/fixedpoint.c index a66dcb1..3de8450 100644 --- a/lib/rbcodec/codecs/lib/fixedpoint.c +++ b/lib/rbcodec/codecs/lib/fixedpoint.c @@ -1 +1 @@ -#include "../../../apps/fixedpoint.c" +#include "../../util/fixedpoint.c" diff --git a/lib/rbcodec/rbcodec.make b/lib/rbcodec/rbcodec.make index bf99f36..acbe532 100644 --- a/lib/rbcodec/rbcodec.make +++ b/lib/rbcodec/rbcodec.make @@ -5,6 +5,7 @@ # Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ # \/ \/ \/ \/ \/ +RBCODEC_CFLAGS += -I$(RBCODEC_DIR)/util RBCODEC_LIB = $(RBCODEC_BLD)/librbcodec.a RBCODEC_SRC := $(call preprocess, $(RBCODEC_DIR)/SOURCES, $(RBCODEC_CFLAGS) \ -imacros rbcodecconfig.h -imacros rbcodecplatform.h) diff --git a/lib/rbcodec/test/Makefile b/lib/rbcodec/test/Makefile index 2ccdf40..f587ea2 100644 --- a/lib/rbcodec/test/Makefile +++ b/lib/rbcodec/test/Makefile @@ -37,10 +37,9 @@ _ := $(shell [ ../rbcodecconfig-example.h -nt $(BUILDDIR)/rbcodecconfig.h ] && c _ := $(shell [ ../rbcodecplatform-unix.h -nt $(BUILDDIR)/rbcodecplatform.h ] && cp ../rbcodecplatform-unix.h $(BUILDDIR)/rbcodecplatform.h) include ../rbcodec.make -SRC = $(ROOTDIR)/firmware/common/strlcpy.c \ - $(ROOTDIR)/firmware/common/unicode.c \ +SRC = $(ROOTDIR)/firmware/common/unicode.c \ $(ROOTDIR)/firmware/common/structec.c \ - $(ROOTDIR)/apps/fixedpoint.c $(ROOTDIR)/uisimulator/common/io.c + $(ROOTDIR)/uisimulator/common/io.c OBJ := $(SRC:.c=.o) OBJ := $(OBJ:.S=.o) diff --git a/lib/rbcodec/util/fixedpoint.c b/lib/rbcodec/util/fixedpoint.c new file mode 100644 index 0000000..2554c8d --- /dev/null +++ b/lib/rbcodec/util/fixedpoint.c @@ -0,0 +1,264 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2006 Jens Arnold + * + * Fixed point library for plugins + * + * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include "platform.h" +#include "fixedpoint.h" + +/** TAKEN FROM ORIGINAL fixedpoint.h */ +/* Inverse gain of circular cordic rotation in s0.31 format. */ +static const long cordic_circular_gain = 0xb2458939; /* 0.607252929 */ + +/* Table of values of atan(2^-i) in 0.32 format fractions of pi where pi = 0xffffffff / 2 */ +static const unsigned long atan_table[] = { + 0x1fffffff, /* +0.785398163 (or pi/4) */ + 0x12e4051d, /* +0.463647609 */ + 0x09fb385b, /* +0.244978663 */ + 0x051111d4, /* +0.124354995 */ + 0x028b0d43, /* +0.062418810 */ + 0x0145d7e1, /* +0.031239833 */ + 0x00a2f61e, /* +0.015623729 */ + 0x00517c55, /* +0.007812341 */ + 0x0028be53, /* +0.003906230 */ + 0x00145f2e, /* +0.001953123 */ + 0x000a2f98, /* +0.000976562 */ + 0x000517cc, /* +0.000488281 */ + 0x00028be6, /* +0.000244141 */ + 0x000145f3, /* +0.000122070 */ + 0x0000a2f9, /* +0.000061035 */ + 0x0000517c, /* +0.000030518 */ + 0x000028be, /* +0.000015259 */ + 0x0000145f, /* +0.000007629 */ + 0x00000a2f, /* +0.000003815 */ + 0x00000517, /* +0.000001907 */ + 0x0000028b, /* +0.000000954 */ + 0x00000145, /* +0.000000477 */ + 0x000000a2, /* +0.000000238 */ + 0x00000051, /* +0.000000119 */ + 0x00000028, /* +0.000000060 */ + 0x00000014, /* +0.000000030 */ + 0x0000000a, /* +0.000000015 */ + 0x00000005, /* +0.000000007 */ + 0x00000002, /* +0.000000004 */ + 0x00000001, /* +0.000000002 */ + 0x00000000, /* +0.000000001 */ + 0x00000000, /* +0.000000000 */ +}; + +/* Precalculated sine and cosine * 16384 (2^14) (fixed point 18.14) */ +static const short sin_table[91] = +{ + 0, 285, 571, 857, 1142, 1427, 1712, 1996, 2280, 2563, + 2845, 3126, 3406, 3685, 3963, 4240, 4516, 4790, 5062, 5334, + 5603, 5871, 6137, 6401, 6663, 6924, 7182, 7438, 7691, 7943, + 8191, 8438, 8682, 8923, 9161, 9397, 9630, 9860, 10086, 10310, + 10531, 10748, 10963, 11173, 11381, 11585, 11785, 11982, 12175, 12365, + 12550, 12732, 12910, 13084, 13254, 13420, 13582, 13740, 13894, 14043, + 14188, 14329, 14466, 14598, 14725, 14848, 14967, 15081, 15190, 15295, + 15395, 15491, 15582, 15668, 15749, 15825, 15897, 15964, 16025, 16082, + 16135, 16182, 16224, 16261, 16294, 16321, 16344, 16361, 16374, 16381, + 16384 +}; + +/** + * Implements sin and cos using CORDIC rotation. + * + * @param phase has range from 0 to 0xffffffff, representing 0 and + * 2*pi respectively. + * @param cos return address for cos + * @return sin of phase, value is a signed value from LONG_MIN to LONG_MAX, + * representing -1 and 1 respectively. + */ +long fp_sincos(unsigned long phase, long *cos) +{ + int32_t x, x1, y, y1; + unsigned long z, z1; + int i; + + /* Setup initial vector */ + x = cordic_circular_gain; + y = 0; + z = phase; + + /* The phase has to be somewhere between 0..pi for this to work right */ + if (z < 0xffffffff / 4) { + /* z in first quadrant, z += pi/2 to correct */ + x = -x; + z += 0xffffffff / 4; + } else if (z < 3 * (0xffffffff / 4)) { + /* z in third quadrant, z -= pi/2 to correct */ + z -= 0xffffffff / 4; + } else { + /* z in fourth quadrant, z -= 3pi/2 to correct */ + x = -x; + z -= 3 * (0xffffffff / 4); + } + + /* Each iteration adds roughly 1-bit of extra precision */ + for (i = 0; i < 31; i++) { + x1 = x >> i; + y1 = y >> i; + z1 = atan_table[i]; + + /* Decided which direction to rotate vector. Pivot point is pi/2 */ + if (z >= 0xffffffff / 4) { + x -= y1; + y += x1; + z -= z1; + } else { + x += y1; + y -= x1; + z += z1; + } + } + + if (cos) + *cos = x; + + return y; +} + + +#if defined(PLUGIN) || defined(CODEC) +/** + * Fixed point square root via Newton-Raphson. + * @param x square root argument. + * @param fracbits specifies number of fractional bits in argument. + * @return Square root of argument in same fixed point format as input. + * + * This routine has been modified to run longer for greater precision, + * but cuts calculation short if the answer is reached sooner. + */ +long fp_sqrt(long x, unsigned int fracbits) +{ + unsigned long xfp, b; + int n = 8; /* iteration limit (should terminate earlier) */ + + if (x <= 0) + return 0; /* no sqrt(neg), or just sqrt(0) = 0 */ + + /* Increase working precision by one bit */ + xfp = x << 1; + fracbits++; + + /* Get the midpoint between fracbits index and the highest bit index */ + b = ((sizeof(xfp)*8-1) - __builtin_clzl(xfp) + fracbits) >> 1; + b = BIT_N(b); + + do + { + unsigned long c = b; + b = (fp_div(xfp, b, fracbits) + b) >> 1; + if (c == b) break; + } + while (n-- > 0); + + return b >> 1; +} +#endif /* PLUGIN or CODEC */ + +#if (!defined(PLUGIN) && !defined(CODEC)) +/** MODIFIED FROM replaygain.c */ + +#define FP_MUL_FRAC(x, y) fp_mul(x, y, fracbits) +#define FP_DIV_FRAC(x, y) fp_div(x, y, fracbits) + +/* constants in fixed point format, 28 fractional bits */ +#define FP28_LN2 (186065279L) /* ln(2) */ +#define FP28_LN2_INV (387270501L) /* 1/ln(2) */ +#define FP28_EXP_ZERO (44739243L) /* 1/6 */ +#define FP28_EXP_ONE (-745654L) /* -1/360 */ +#define FP28_EXP_TWO (12428L) /* 1/21600 */ +#define FP28_LN10 (618095479L) /* ln(10) */ +#define FP28_LOG10OF2 (80807124L) /* log10(2) */ + +#define TOL_BITS 2 /* log calculation tolerance */ + + +/* The fpexp10 fixed point math routine is based + * on oMathFP by Dan Carter (http://orbisstudios.com). + */ + +/** FIXED POINT EXP10 + * Return 10^x as FP integer. Argument is FP integer. + */ +static long fp_exp10(long x, unsigned int fracbits) +{ + long k; + long z; + long R; + long xp; + + /* scale constants */ + const long fp_one = (1 << fracbits); + const long fp_half = (1 << (fracbits - 1)); + const long fp_two = (2 << fracbits); + const long fp_mask = (fp_one - 1); + const long fp_ln2_inv = (FP28_LN2_INV >> (28 - fracbits)); + const long fp_ln2 = (FP28_LN2 >> (28 - fracbits)); + const long fp_ln10 = (FP28_LN10 >> (28 - fracbits)); + const long fp_exp_zero = (FP28_EXP_ZERO >> (28 - fracbits)); + const long fp_exp_one = (FP28_EXP_ONE >> (28 - fracbits)); + const long fp_exp_two = (FP28_EXP_TWO >> (28 - fracbits)); + + /* exp(0) = 1 */ + if (x == 0) + { + return fp_one; + } + + /* convert from base 10 to base e */ + x = FP_MUL_FRAC(x, fp_ln10); + + /* calculate exp(x) */ + k = (FP_MUL_FRAC(abs(x), fp_ln2_inv) + fp_half) & ~fp_mask; + + if (x < 0) + { + k = -k; + } + + x -= FP_MUL_FRAC(k, fp_ln2); + z = FP_MUL_FRAC(x, x); + R = fp_two + FP_MUL_FRAC(z, fp_exp_zero + FP_MUL_FRAC(z, fp_exp_one + + FP_MUL_FRAC(z, fp_exp_two))); + xp = fp_one + FP_DIV_FRAC(FP_MUL_FRAC(fp_two, x), R - x); + + if (k < 0) + { + k = fp_one >> (-k >> fracbits); + } + else + { + k = fp_one << (k >> fracbits); + } + + return FP_MUL_FRAC(k, xp); +} + +/** CONVERT DECIBELS TO FACTOR */ +long fp_factor(long decibels, unsigned int fracbits) +{ + /* factor = 10 ^ (decibels / 20) */ + return fp_exp10(FP_DIV_FRAC(decibels, (20L << fracbits)), fracbits); +} +#endif /* !PLUGIN and !CODEC */ diff --git a/lib/rbcodec/util/fixedpoint.h b/lib/rbcodec/util/fixedpoint.h new file mode 100644 index 0000000..6a92a03 --- /dev/null +++ b/lib/rbcodec/util/fixedpoint.h @@ -0,0 +1,64 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2006 Jens Arnold + * + * Fixed point library for plugins + * + * 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +/** APPS - FIXED POINT MATH ROUTINES - USAGE + * + * - x and y arguments are fixed point integers + * - fracbits is the number of fractional bits in the argument(s) + * - functions return long fixed point integers with the specified number + * of fractional bits unless otherwise specified + * + * Multiply two fixed point numbers: + * fp_mul(x, y, fracbits) + * + * Divide two fixed point numbers: + * fp_div(x, y, fracbits) + * + * Calculate decibel equivalent of a gain factor: + * fp_decibels(factor, fracbits) + * where fracbits is in the range 12 to 22 (higher is better), + * and factor is a positive fixed point integer. + * + * Calculate factor equivalent of a decibel value: + * fp_factor(decibels, fracbits) + * where fracbits is in the range 12 to 22 (lower is better), + * and decibels is a fixed point integer. + */ + +#ifndef _FIXEDPOINT_H_APPS +#define _FIXEDPOINT_H_APPS + +#define fp_mul(x, y, z) (long)((((long long)(x)) * ((long long)(y))) >> (z)) +#define fp_div(x, y, z) (long)((((long long)(x)) << (z)) / ((long long)(y))) + + +/** TAKEN FROM ORIGINAL fixedpoint.h */ +long fp_sincos(unsigned long phase, long *cos); + + +/* fracbits in range 12 - 22 work well. Higher is better for + * calculating dB, lower is better for calculating factor. + */ +long fp_factor(long decibels, unsigned int fracbits); + +#endif diff --git a/lib/rbcodec/util/fracmul.h b/lib/rbcodec/util/fracmul.h new file mode 100644 index 0000000..74b2834 --- /dev/null +++ b/lib/rbcodec/util/fracmul.h @@ -0,0 +1,101 @@ +#ifndef _FRACMUL_H +#define _FRACMUL_H + +#include "platform.h" + +/** FRACTIONAL MULTIPLICATION - TAKEN FROM apps/dsp.h + * Multiply two fixed point numbers with 31 fractional bits: + * FRACMUL(x, y) + * + * Multiply two fixed point numbers with 31 fractional bits, + * then shift left by z bits: + * FRACMUL_SHL(x, y, z) + * NOTE: z must be in the range 1-8 on Coldfire targets. + */ + + +/* A bunch of fixed point assembler helper macros */ +#if defined(CPU_COLDFIRE) +/* These macros use the Coldfire EMAC extension and need the MACSR flags set + * to fractional mode with no rounding. + */ + +/* Multiply two S.31 fractional integers and return the sign bit and the + * 31 most significant bits of the result. + */ +static inline int32_t FRACMUL(int32_t x, int32_t y) +{ + int32_t t; + asm ("mac.l %[a], %[b], %%acc0\n\t" + "movclr.l %%acc0, %[t]\n\t" + : [t] "=r" (t) : [a] "r" (x), [b] "r" (y)); + return t; +} + +/* Multiply two S.31 fractional integers, and return the 32 most significant + * bits after a shift left by the constant z. NOTE: Only works for shifts of + * 1 to 8 on Coldfire! + */ +static FORCE_INLINE int32_t FRACMUL_SHL(int32_t x, int32_t y, int z) +{ + int32_t t, t2; + asm ("mac.l %[a], %[b], %%acc0\n\t" + "move.l %[d], %[t]\n\t" + "move.l %%accext01, %[t2]\n\t" + "and.l %[mask], %[t2]\n\t" + "lsr.l %[t], %[t2]\n\t" + "movclr.l %%acc0, %[t]\n\t" + "asl.l %[c], %[t]\n\t" + "or.l %[t2], %[t]\n\t" + : [t] "=&d" (t), [t2] "=&d" (t2) + : [a] "r" (x), [b] "r" (y), [mask] "d" (0xff), + [c] "id" ((z)), [d] "id" (8 - (z))); + return t; +} + +#elif defined(CPU_ARM) + +/* Multiply two S.31 fractional integers and return the sign bit and the + * 31 most significant bits of the result. + */ +static inline int32_t FRACMUL(int32_t x, int32_t y) +{ + int32_t t, t2; + asm ("smull %[t], %[t2], %[a], %[b]\n\t" + "mov %[t2], %[t2], asl #1\n\t" + "orr %[t], %[t2], %[t], lsr #31\n\t" + : [t] "=&r" (t), [t2] "=&r" (t2) + : [a] "r" (x), [b] "r" (y)); + return t; +} + +/* Multiply two S.31 fractional integers, and return the 32 most significant + * bits after a shift left by the constant z. + */ +static FORCE_INLINE int32_t FRACMUL_SHL(int32_t x, int32_t y, int z) +{ + int32_t t, t2; + asm ("smull %[t], %[t2], %[a], %[b]\n\t" + "mov %[t2], %[t2], asl %[c]\n\t" + "orr %[t], %[t2], %[t], lsr %[d]\n\t" + : [t] "=&r" (t), [t2] "=&r" (t2) + : [a] "r" (x), [b] "r" (y), + [c] "Mr" ((z) + 1), [d] "Mr" (31 - (z))); + return t; +} + +#else + +static inline int32_t FRACMUL(int32_t x, int32_t y) +{ + return (int32_t) (((int64_t)x * y) >> 31); +} + +static inline int32_t FRACMUL_SHL(int32_t x, int32_t y, int z) +{ + return (int32_t) (((int64_t)x * y) >> (31 - z)); +} + +#endif + +#endif diff --git a/lib/rbcodec/util/strlcpy.c b/lib/rbcodec/util/strlcpy.c new file mode 100644 index 0000000..e320649 --- /dev/null +++ b/lib/rbcodec/util/strlcpy.c @@ -0,0 +1,51 @@ +/* $OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $ */ + +/* + * Copyright (c) 1998 Todd C. Miller + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +/* + * Copy src to string dst of size siz. At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns strlen(src); if retval >= siz, truncation occurred. + */ +size_t +strlcpy(char *dst, const char *src, size_t siz) +{ + char *d = dst; + const char *s = src; + size_t n = siz; + + /* Copy as many bytes as will fit */ + if (n != 0) { + while (--n != 0) { + if ((*d++ = *s++) == '\0') + break; + } + } + + /* Not enough room in dst, add NUL and traverse rest of src */ + if (n == 0) { + if (siz != 0) + *d = '\0'; /* NUL-terminate dst */ + while (*s++) + ; + } + + return(s - src - 1); /* count does not include NUL */ +} + -- 1.7.6