From f40bfc9267b13b54e6379dfe7539447662879d24 Mon Sep 17 00:00:00 2001 From: Sean Bartell Date: Sat, 25 Jun 2011 21:32:25 -0400 Subject: Add codecs to librbcodec. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97 Reviewed-on: http://gerrit.rockbox.org/137 Reviewed-by: Nils Wallménius Tested-by: Nils Wallménius --- lib/rbcodec/codecs/libcook/cook_fixpoint.h | 278 +++++++++++++++++++++++++++++ 1 file changed, 278 insertions(+) create mode 100644 lib/rbcodec/codecs/libcook/cook_fixpoint.h (limited to 'lib/rbcodec/codecs/libcook/cook_fixpoint.h') diff --git a/lib/rbcodec/codecs/libcook/cook_fixpoint.h b/lib/rbcodec/codecs/libcook/cook_fixpoint.h new file mode 100644 index 0000000000..5c4a5d1a5a --- /dev/null +++ b/lib/rbcodec/codecs/libcook/cook_fixpoint.h @@ -0,0 +1,278 @@ +/* + * COOK compatible decoder, fixed point implementation. + * Copyright (c) 2007 Ian Braithwaite + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +/** + * @file cook_fixpoint.h + * + * Cook AKA RealAudio G2 fixed point functions. + * + * Fixed point values are represented as 32 bit signed integers, + * which can be added and subtracted directly in C (without checks for + * overflow/saturation. + * Two multiplication routines are provided: + * 1) Multiplication by powers of two (2^-31 .. 2^31), implemented + * with C's bit shift operations. + * 2) Multiplication by 16 bit fractions (0 <= x < 1), implemented + * in C using two 32 bit integer multiplications. + */ + +#ifdef ROCKBOX +/* get definitions of MULT31, MULT31_SHIFT16, vect_add, from codelib */ +#include "codeclib_misc.h" +#include "codeclib.h" +#endif + +/* cplscales was moved from cookdata_fixpoint.h since only * + * cook_fixpoint.h should see/use it. */ +static const FIXPU* cplscales[5] = { + cplscale2, cplscale3, cplscale4, cplscale5, cplscale6 +}; + +/** + * Fixed point multiply by power of two. + * + * @param x fix point value + * @param i integer power-of-two, -31..+31 + */ +static inline FIXP fixp_pow2(FIXP x, int i) +{ + if (i < 0) + return (x >> -i); + else + return x << i; /* no check for overflow */ +} + +/** + * Fixed point multiply by fraction. + * + * @param a fix point value + * @param b fix point fraction, 0 <= b < 1 + */ +#ifdef ROCKBOX +#define fixp_mult_su(x,y) (MULT31_SHIFT16(x,y)) +#else +static inline FIXP fixp_mult_su(FIXP a, FIXPU b) +{ + int32_t hb = (a >> 16) * b; + uint32_t lb = (a & 0xffff) * b; + + return hb + (lb >> 16) + ((lb & 0x8000) >> 15); +} +#endif + +/* Faster version of the above using 32x32=64 bit multiply */ +#ifdef ROCKBOX +#define fixmul31(x,y) (MULT31(x,y)) +#else +static inline int32_t fixmul31(int32_t x, int32_t y) +{ + int64_t temp; + + temp = x; + temp *= y; + + temp >>= 31; //16+31-16 = 31 bits + + return (int32_t)temp; +} +#endif + +/** + * Clips a signed integer value into the amin-amax range. + * @param a value to clip + * @param amin minimum value of the clip range + * @param amax maximum value of the clip range + * @return clipped value + */ +static inline int av_clip(int a, int amin, int amax) +{ + if (a < amin) return amin; + else if (a > amax) return amax; + else return a; +} + +/** + * The real requantization of the mltcoefs + * + * @param q pointer to the COOKContext + * @param index index + * @param quant_index quantisation index for this band + * @param subband_coef_index array of indexes to quant_centroid_tab + * @param subband_coef_sign use random noise instead of predetermined value + * @param mlt_ptr pointer to the mlt coefficients + */ + +static void scalar_dequant_math(COOKContext *q, int index, + int quant_index, int* subband_coef_index, + int* subband_coef_sign, REAL_T *mlt_p) + ICODE_ATTR_COOK_DECODE; +static void scalar_dequant_math(COOKContext *q, int index, + int quant_index, int* subband_coef_index, + int* subband_coef_sign, REAL_T *mlt_p) +{ + /* Num. half bits to right shift */ + const int s = 33 - quant_index + av_log2(q->samples_per_channel); + const FIXP *table = quant_tables[s & 1][index]; + FIXP f; + int i; + + + if(s >= 64) + memset(mlt_p, 0, sizeof(REAL_T)*SUBBAND_SIZE); + else + { + for(i=0 ; i> (s >> 1); + /* noise coding if subband_coef_index[i] == 0 */ + if (((subband_coef_index[i] == 0) && cook_random(q)) || + ((subband_coef_index[i] != 0) && subband_coef_sign[i])) + f = -f; + + *mlt_p++ = f; + } + } +} + +/** + * The modulated lapped transform, this takes transform coefficients + * and transforms them into timedomain samples. + * A window step is also included. + * + * @param q pointer to the COOKContext + * @param inbuffer pointer to the mltcoefficients + * @param outbuffer pointer to the timedomain buffer + * @param mlt_tmp pointer to temporary storage space + */ +#include "../lib/mdct_lookup.h" + +void imlt_math(COOKContext *q, FIXP *in) ICODE_ATTR; +void imlt_math(COOKContext *q, FIXP *in) +{ + const int n = q->samples_per_channel; + const int step = 2 << (10 - av_log2(n)); + REAL_T *mdct_out = q->mono_mdct_output; + REAL_T tmp; + int i = 0, j = 0; + + ff_imdct_calc(q->mdct_nbits, q->mono_mdct_output, in); + + do { + tmp = mdct_out[i]; + mdct_out[i ] = fixmul31(-mdct_out[n+i], (sincos_lookup0[j ])); + mdct_out[n+i] = fixmul31(tmp , (sincos_lookup0[j+1])); + + j += step; + } while (++i < n/2); + + do { + j -= step; + + tmp = mdct_out[i]; + mdct_out[i ] = fixmul31(-mdct_out[n+i], (sincos_lookup0[j+1])); + mdct_out[n+i] = fixmul31(tmp , (sincos_lookup0[j ])); + } while (++i < n); +} + +/** + * Perform buffer overlapping. + * + * @param q pointer to the COOKContext + * @param gain gain correction to apply first to output buffer + * @param buffer data to overlap + */ +void overlap_math(COOKContext *q, int gain, FIXP buffer[]) ICODE_ATTR; +void overlap_math(COOKContext *q, int gain, FIXP buffer[]) +{ + int i; +#ifdef ROCKBOX + if(LIKELY(gain == 0)) + { + vect_add(q->mono_mdct_output, buffer, q->samples_per_channel); + + } else if (gain > 0){ + for(i=0 ; isamples_per_channel ; i++) { + q->mono_mdct_output[i] = (q->mono_mdct_output[i]<< gain) + buffer[i]; } + + } else { + for(i=0 ; isamples_per_channel ; i++) { + q->mono_mdct_output[i] = (q->mono_mdct_output[i]>>-gain) + buffer[i]; + } + } +#else + for(i=0 ; isamples_per_channel ; i++) { + q->mono_mdct_output[i] = + fixp_pow2(q->mono_mdct_output[i], gain) + buffer[i]; + } +#endif +} + + +/** + * the actual requantization of the timedomain samples + * + * @param q pointer to the COOKContext + * @param buffer pointer to the timedomain buffer + * @param gain_index index for the block multiplier + * @param gain_index_next index for the next block multiplier + */ +static inline void +interpolate_math(COOKContext *q, register FIXP* buffer, + int gain_index, int gain_index_next) +{ + int i; + int gain_size_factor = q->samples_per_channel / 8; + + if(gain_index == gain_index_next){ //static gain + for(i = 0; i < gain_size_factor; i++) { + buffer[i] = fixp_pow2(buffer[i], gain_index); + } + } else { //smooth gain + int step = (gain_index_next - gain_index) + << (7 - av_log2(gain_size_factor)); + int x = 0; + register FIXP* bufferend = buffer+gain_size_factor; + while(buffer < bufferend ) + { + *buffer = fixp_pow2( + fixp_mult_su(*buffer, pow128_tab[x]), + gain_index+1); + buffer++; + + x += step; + gain_index += ( (x + 128) >> 7 ) - 1; + x = ( (x + 128) & 127 ); + } + } +} + + +/** + * Decoupling calculation for joint stereo coefficients. + * + * @param x mono coefficient + * @param table number of decoupling table + * @param i table index + */ +static inline FIXP cplscale_math(FIXP x, int table, int i) +{ + return fixp_mult_su(x, cplscales[table-2][i]); +} -- cgit v1.2.3