len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-11-18 09:32:40 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add codecs to librbcodec.

Browse source 
Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97
Reviewed-on: http://gerrit.rockbox.org/137
Reviewed-by: Nils Wallménius <nils@rockbox.org>
Tested-by: Nils Wallménius <nils@rockbox.org>
This commit is contained in:
Sean Bartell 2011-06-25 21:32:25 -04:00 • committed by Nils Wallménius
parent a0009907de
commit f40bfc9267
757 changed files with 122 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

12
lib/rbcodec/codecs/lib/SOURCES Normal file
View file

@ -0,0 +1,12 @@
#if CONFIG_CODEC == SWCODEC /* software codec platforms */
codeclib.c
fixedpoint.c
ffmpeg_bitstream.c
mdct_lookup.c
fft-ffmpeg.c
mdct.c
#elif (CONFIG_PLATFORM & PLATFORM_HOSTED) && defined(__APPLE__)
osx.dummy.c
#endif

292
lib/rbcodec/codecs/lib/asm_arm.h Normal file
View file

@ -0,0 +1,292 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
* *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
* BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
* *
********************************************************************
function: arm7 and later wide math functions
********************************************************************/
#ifdef CPU_ARM
#define INCL_OPTIMIZED_MULT32
#if ARM_ARCH >= 6
static inline int32_t MULT32(int32_t x, int32_t y) {
int32_t hi;
asm volatile("smmul %[hi], %[x], %[y] \n\t"
: [hi] "=&r" (hi)
: [x] "r" (x), [y] "r" (y) );
return(hi);
}
#else
static inline int32_t MULT32(int32_t x, int32_t y) {
int32_t lo, hi;
asm volatile("smull\t%0, %1, %2, %3 \n\t"
: "=&r"(lo),"=&r"(hi)
: "r"(x),"r"(y) );
return(hi);
}
#endif
#define INCL_OPTIMIZED_MULT31
static inline int32_t MULT31(int32_t x, int32_t y) {
return MULT32(x,y)<<1;
}
#define INCL_OPTIMIZED_MULT31_SHIFT15
static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) {
int32_t lo,hi;
asm volatile("smull %0, %1, %2, %3\n\t"
"movs %0, %0, lsr #15\n\t"
"adc %1, %0, %1, lsl #17\n\t"
: "=&r"(lo),"=&r"(hi)
: "r"(x),"r"(y)
: "cc" );
return(hi);
}
#define INCL_OPTIMIZED_MULT31_SHIFT16
static inline int32_t MULT31_SHIFT16(int32_t x, int32_t y) {
int32_t lo,hi;
asm volatile("smull %0, %1, %2, %3\n\t"
"movs %0, %0, lsr #16\n\t"
"adc %1, %0, %1, lsl #16\n\t"
: "=&r"(lo),"=&r"(hi)
: "r"(x),"r"(y)
: "cc" );
return(hi);
}
#define INCL_OPTIMIZED_XPROD32
#define XPROD32(a, b, t, v, x, y) \
{ \
int32_t l; \
asm("smull %0, %1, %3, %5\n\t" \
"rsb %2, %6, #0\n\t" \
"smlal %0, %1, %4, %6\n\t" \
"smull %0, %2, %3, %2\n\t" \
"smlal %0, %2, %4, %5" \
: "=&r" (l), "=&r" (x), "=&r" (y) \
: "r" ((a)), "r" ((b)), "r" ((t)), "r" ((v)) ); \
}
#define INCL_OPTIMIZED_XPROD31_R
#define INCL_OPTIMIZED_XNPROD31_R
#if ARM_ARCH >= 6
/* These may yield slightly different result from the macros below
because only the high 32 bits of the multiplications are accumulated while
the below macros use a 64 bit accumulator that is truncated to 32 bits.*/
#define XPROD31_R(_a, _b, _t, _v, _x, _y)\
{\
int32_t x1, y1;\
asm("smmul %[x1], %[t], %[a] \n\t"\
"smmul %[y1], %[t], %[b] \n\t"\
"smmla %[x1], %[v], %[b], %[x1] \n\t"\
"smmls %[y1], %[v], %[a], %[y1] \n\t"\
: [x1] "=&r" (x1), [y1] "=&r" (y1)\
: [a] "r" (_a), [b] "r" (_b), [t] "r" (_t), [v] "r" (_v) );\
_x = x1 << 1;\
_y = y1 << 1;\
}
#define XNPROD31_R(_a, _b, _t, _v, _x, _y)\
{\
int32_t x1, y1;\
asm("smmul %[x1], %[t], %[a] \n\t"\
"smmul %[y1], %[t], %[b] \n\t"\
"smmls %[x1], %[v], %[b], %[x1] \n\t"\
"smmla %[y1], %[v], %[a], %[y1] \n\t"\
: [x1] "=&r" (x1), [y1] "=&r" (y1)\
: [a] "r" (_a), [b] "r" (_b), [t] "r" (_t), [v] "r" (_v) );\
_x = x1 << 1;\
_y = y1 << 1;\
}
#else
#define XPROD31_R(_a, _b, _t, _v, _x, _y)\
{\
int32_t x1, y1, l;\
asm("smull %0, %1, %5, %3\n\t"\
"rsb %2, %3, #0\n\t"\
"smlal %0, %1, %6, %4\n\t"\
"smull %0, %2, %6, %2\n\t"\
"smlal %0, %2, %5, %4"\
: "=&r" (l), "=&r" (x1), "=&r" (y1)\
: "r" (_a), "r" (_b), "r" (_t), "r" (_v) );\
_x = x1 << 1;\
_y = y1 << 1;\
}
#define XNPROD31_R(_a, _b, _t, _v, _x, _y)\
{\
int32_t x1, y1, l;\
asm("smull %0, %1, %5, %3\n\t"\
"rsb %2, %4, #0\n\t"\
"smlal %0, %1, %6, %2\n\t"\
"smull %0, %2, %5, %4\n\t"\
"smlal %0, %2, %6, %3"\
: "=&r" (l), "=&r" (x1), "=&r" (y1)\
: "r" (_a), "r" (_b), "r" (_t), "r" (_v) );\
_x = x1 << 1;\
_y = y1 << 1;\
}
#endif
#define INCL_OPTIMIZED_XPROD31
static inline void XPROD31(int32_t a, int32_t b,
int32_t t, int32_t v,
int32_t *x, int32_t *y)
{
int32_t _x1, _y1;
XPROD31_R(a, b, t, v, _x1, _y1);
*x = _x1;
*y = _y1;
}
#define INCL_OPTIMIZED_XNPROD31
static inline void XNPROD31(int32_t a, int32_t b,
int32_t t, int32_t v,
int32_t *x, int32_t *y)
{
int32_t _x1, _y1;
XNPROD31_R(a, b, t, v, _x1, _y1);
*x = _x1;
*y = _y1;
}
#ifndef _V_VECT_OPS
#define _V_VECT_OPS
/* asm versions of vector operations for block.c, window.c */
static inline
void vect_add(int32_t *x, const int32_t *y, int n)
{
while (n>=4) {
asm volatile ("ldmia %[x], {r0, r1, r2, r3};"
"ldmia %[y]!, {r4, r5, r6, r7};"
"add r0, r0, r4;"
"add r1, r1, r5;"
"add r2, r2, r6;"
"add r3, r3, r7;"
"stmia %[x]!, {r0, r1, r2, r3};"
: [x] "+r" (x), [y] "+r" (y)
: : "r0", "r1", "r2", "r3",
"r4", "r5", "r6", "r7",
"memory");
n -= 4;
}
/* add final elements */
while (n>0) {
*x++ += *y++;
n--;
}
}
static inline
void vect_copy(int32_t *x, const int32_t *y, int n)
{
while (n>=4) {
asm volatile ("ldmia %[y]!, {r0, r1, r2, r3};"
"stmia %[x]!, {r0, r1, r2, r3};"
: [x] "+r" (x), [y] "+r" (y)
: : "r0", "r1", "r2", "r3",
"memory");
n -= 4;
}
/* copy final elements */
while (n>0) {
*x++ = *y++;
n--;
}
}
static inline
void vect_mult_fw(int32_t *data, const int32_t *window, int n)
{
while (n>=4) {
asm volatile ("ldmia %[d], {r0, r1, r2, r3};"
"ldmia %[w]!, {r4, r5, r6, r7};"
"smull r8, r9, r0, r4;"
"mov r0, r9, lsl #1;"
"smull r8, r9, r1, r5;"
"mov r1, r9, lsl #1;"
"smull r8, r9, r2, r6;"
"mov r2, r9, lsl #1;"
"smull r8, r9, r3, r7;"
"mov r3, r9, lsl #1;"
"stmia %[d]!, {r0, r1, r2, r3};"
: [d] "+r" (data), [w] "+r" (window)
: : "r0", "r1", "r2", "r3",
"r4", "r5", "r6", "r7", "r8", "r9",
"memory" );
n -= 4;
}
while(n>0) {
*data = MULT31(*data, *window);
data++;
window++;
n--;
}
}
static inline
void vect_mult_bw(int32_t *data, const int32_t *window, int n)
{
while (n>=4) {
asm volatile ("ldmia %[d], {r0, r1, r2, r3};"
"ldmda %[w]!, {r4, r5, r6, r7};"
"smull r8, r9, r0, r7;"
"mov r0, r9, lsl #1;"
"smull r8, r9, r1, r6;"
"mov r1, r9, lsl #1;"
"smull r8, r9, r2, r5;"
"mov r2, r9, lsl #1;"
"smull r8, r9, r3, r4;"
"mov r3, r9, lsl #1;"
"stmia %[d]!, {r0, r1, r2, r3};"
: [d] "+r" (data), [w] "+r" (window)
: : "r0", "r1", "r2", "r3",
"r4", "r5", "r6", "r7", "r8", "r9",
"memory" );
n -= 4;
}
while(n>0) {
*data = MULT31(*data, *window);
data++;
window--;
n--;
}
}
#endif
/* not used anymore */
/*
#ifndef _V_CLIP_MATH
#define _V_CLIP_MATH
static inline int32_t CLIP_TO_15(int32_t x) {
int tmp;
asm volatile("subs %1, %0, #32768\n\t"
"movpl %0, #0x7f00\n\t"
"orrpl %0, %0, #0xff\n"
"adds %1, %0, #32768\n\t"
"movmi %0, #0x8000"
: "+r"(x),"=r"(tmp)
:
: "cc");
return(x);
}
#endif
*/
#endif

353
lib/rbcodec/codecs/lib/asm_mcf5249.h Normal file
View file

@ -0,0 +1,353 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
*
* Copyright (C) 2005 by Pedro Vasconcelos
*
* 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.
*
****************************************************************************/
/* asm routines for wide math on the MCF5249 */
#if defined(CPU_COLDFIRE)
#define INCL_OPTIMIZED_MULT32
static inline int32_t MULT32(int32_t x, int32_t y) {
asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply & shift */
"movclr.l %%acc0, %[x];" /* move & clear acc */
"asr.l #1, %[x];" /* no overflow test */
: [x] "+&d" (x)
: [y] "r" (y)
: "cc");
return x;
}
#define INCL_OPTIMIZED_MULT31
static inline int32_t MULT31(int32_t x, int32_t y) {
asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply */
"movclr.l %%acc0, %[x];" /* move and clear */
: [x] "+&r" (x)
: [y] "r" (y)
: "cc");
return x;
}
#define INCL_OPTIMIZED_MULT31_SHIFT15
/* NOTE: this requires that the emac is *NOT* rounding */
static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) {
int32_t r;
asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply */
"mulu.l %[y], %[x];" /* get lower half, avoid emac stall */
"movclr.l %%acc0, %[r];" /* get higher half */
"swap %[r];" /* hi<<16, plus one free */
"lsr.l #8, %[x];" /* (unsigned)lo >> 15 */
"lsr.l #7, %[x];"
"move.w %[x], %[r];" /* logical-or results */
: [r] "=&d" (r), [x] "+d" (x)
: [y] "d" (y)
: "cc");
return r;
}
#define INCL_OPTIMIZED_MULT31_SHIFT16
static inline int32_t MULT31_SHIFT16(int32_t x, int32_t y) {
int32_t r;
asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply */
"mulu.l %[y], %[x];" /* get lower half, avoid emac stall */
"movclr.l %%acc0, %[r];" /* get higher half */
"lsr.l #1, %[r];" /* hi >> 1, to compensate emac shift */
"move.w %[r], %[x];" /* x = x & 0xffff0000 | r & 0xffff */
"swap %[x];" /* x = (unsigned)x << 16 | (unsigned)x >> 16 */
: [r] "=&d" (r), [x] "+d" (x)
: [y] "d" (y)
: "cc");
return x;
}
#define INCL_OPTIMIZED_XPROD31
static inline
void XPROD31(int32_t a, int32_t b,
int32_t t, int32_t v,
int32_t *x, int32_t *y)
{
asm volatile ("mac.l %[a], %[t], %%acc0;"
"mac.l %[b], %[v], %%acc0;"
"mac.l %[b], %[t], %%acc1;"
"msac.l %[a], %[v], %%acc1;"
"movclr.l %%acc0, %[a];"
"move.l %[a], (%[x]);"
"movclr.l %%acc1, %[a];"
"move.l %[a], (%[y]);"
: [a] "+&r" (a)
: [x] "a" (x), [y] "a" (y),
[b] "r" (b), [t] "r" (t), [v] "r" (v)
: "cc", "memory");
}
#define INCL_OPTIMIZED_XNPROD31
static inline
void XNPROD31(int32_t a, int32_t b,
int32_t t, int32_t v,
int32_t *x, int32_t *y)
{
asm volatile ("mac.l %[a], %[t], %%acc0;"
"msac.l %[b], %[v], %%acc0;"
"mac.l %[b], %[t], %%acc1;"
"mac.l %[a], %[v], %%acc1;"
"movclr.l %%acc0, %[a];"
"move.l %[a], (%[x]);"
"movclr.l %%acc1, %[a];"
"move.l %[a], (%[y]);"
: [a] "+&r" (a)
: [x] "a" (x), [y] "a" (y),
[b] "r" (b), [t] "r" (t), [v] "r" (v)
: "cc", "memory");
}
/* this could lose the LSB by overflow, but i don't think it'll ever happen.
if anyone think they can hear a bug caused by this, please try the above
version. */
#define INCL_OPTIMIZED_XPROD32
#define XPROD32(_a, _b, _t, _v, _x, _y) \
asm volatile ("mac.l %[a], %[t], %%acc0;" \
"mac.l %[b], %[v], %%acc0;" \
"mac.l %[b], %[t], %%acc1;" \
"msac.l %[a], %[v], %%acc1;" \
"movclr.l %%acc0, %[x];" \
"asr.l #1, %[x];" \
"movclr.l %%acc1, %[y];" \
"asr.l #1, %[y];" \
: [x] "=d" (_x), [y] "=d" (_y) \
: [a] "r" (_a), [b] "r" (_b), \
[t] "r" (_t), [v] "r" (_v) \
: "cc");
#define INCL_OPTIMIZED_XPROD31_R
#define XPROD31_R(_a, _b, _t, _v, _x, _y) \
asm volatile ("mac.l %[a], %[t], %%acc0;" \
"mac.l %[b], %[v], %%acc0;" \
"mac.l %[b], %[t], %%acc1;" \
"msac.l %[a], %[v], %%acc1;" \
"movclr.l %%acc0, %[x];" \
"movclr.l %%acc1, %[y];" \
: [x] "=r" (_x), [y] "=r" (_y) \
: [a] "r" (_a), [b] "r" (_b), \
[t] "r" (_t), [v] "r" (_v) \
: "cc");
#define INCL_OPTIMIZED_XNPROD31_R
#define XNPROD31_R(_a, _b, _t, _v, _x, _y) \
asm volatile ("mac.l %[a], %[t], %%acc0;" \
"msac.l %[b], %[v], %%acc0;" \
"mac.l %[b], %[t], %%acc1;" \
"mac.l %[a], %[v], %%acc1;" \
"movclr.l %%acc0, %[x];" \
"movclr.l %%acc1, %[y];" \
: [x] "=r" (_x), [y] "=r" (_y) \
: [a] "r" (_a), [b] "r" (_b), \
[t] "r" (_t), [v] "r" (_v) \
: "cc");
#ifndef _V_VECT_OPS
#define _V_VECT_OPS
/* asm versions of vector operations for block.c, window.c */
/* assumes MAC is initialized & accumulators cleared */
static inline
void vect_add(int32_t *x, const int32_t *y, int n)
{
/* align to 16 bytes */
while(n>0 && (int)x&15) {
*x++ += *y++;
n--;
}
asm volatile ("bra 1f;"
"0:" /* loop start */
"movem.l (%[x]), %%d0-%%d3;" /* fetch values */
"movem.l (%[y]), %%a0-%%a3;"
/* add */
"add.l %%a0, %%d0;"
"add.l %%a1, %%d1;"
"add.l %%a2, %%d2;"
"add.l %%a3, %%d3;"
/* store and advance */
"movem.l %%d0-%%d3, (%[x]);"
"lea.l (4*4, %[x]), %[x];"
"lea.l (4*4, %[y]), %[y];"
"subq.l #4, %[n];" /* done 4 elements */
"1: cmpi.l #4, %[n];"
"bge 0b;"
: [n] "+d" (n), [x] "+a" (x), [y] "+a" (y)
: : "%d0", "%d1", "%d2", "%d3", "%a0", "%a1", "%a2", "%a3",
"cc", "memory");
/* add final elements */
while (n>0) {
*x++ += *y++;
n--;
}
}
static inline
void vect_copy(int32_t *x, const int32_t *y, int n)
{
/* align to 16 bytes */
while(n>0 && (int)x&15) {
*x++ = *y++;
n--;
}
asm volatile ("bra 1f;"
"0:" /* loop start */
"movem.l (%[y]), %%d0-%%d3;" /* fetch values */
"movem.l %%d0-%%d3, (%[x]);" /* store */
"lea.l (4*4, %[x]), %[x];" /* advance */
"lea.l (4*4, %[y]), %[y];"
"subq.l #4, %[n];" /* done 4 elements */
"1: cmpi.l #4, %[n];"
"bge 0b;"
: [n] "+d" (n), [x] "+a" (x), [y] "+a" (y)
: : "%d0", "%d1", "%d2", "%d3", "cc", "memory");
/* copy final elements */
while (n>0) {
*x++ = *y++;
n--;
}
}
static inline
void vect_mult_fw(int32_t *data, const int32_t *window, int n)
{
/* ensure data is aligned to 16-bytes */
while(n>0 && (int)data&15) {
*data = MULT31(*data, *window);
data++;
window++;
n--;
}
asm volatile ("movem.l (%[d]), %%d0-%%d3;" /* loop start */
"movem.l (%[w]), %%a0-%%a3;" /* pre-fetch registers */
"lea.l (4*4, %[w]), %[w];"
"bra 1f;" /* jump to loop condition */
"0:" /* loop body */
/* multiply and load next window values */
"mac.l %%d0, %%a0, (%[w])+, %%a0, %%acc0;"
"mac.l %%d1, %%a1, (%[w])+, %%a1, %%acc1;"
"mac.l %%d2, %%a2, (%[w])+, %%a2, %%acc2;"
"mac.l %%d3, %%a3, (%[w])+, %%a3, %%acc3;"
"movclr.l %%acc0, %%d0;" /* get the products */
"movclr.l %%acc1, %%d1;"
"movclr.l %%acc2, %%d2;"
"movclr.l %%acc3, %%d3;"
/* store and advance */
"movem.l %%d0-%%d3, (%[d]);"
"lea.l (4*4, %[d]), %[d];"
"movem.l (%[d]), %%d0-%%d3;"
"subq.l #4, %[n];" /* done 4 elements */
"1: cmpi.l #4, %[n];"
"bge 0b;"
/* multiply final elements */
"tst.l %[n];"
"beq 1f;" /* n=0 */
"mac.l %%d0, %%a0, %%acc0;"
"movclr.l %%acc0, %%d0;"
"move.l %%d0, (%[d])+;"
"subq.l #1, %[n];"
"beq 1f;" /* n=1 */
"mac.l %%d1, %%a1, %%acc0;"
"movclr.l %%acc0, %%d1;"
"move.l %%d1, (%[d])+;"
"subq.l #1, %[n];"
"beq 1f;" /* n=2 */
/* otherwise n = 3 */
"mac.l %%d2, %%a2, %%acc0;"
"movclr.l %%acc0, %%d2;"
"move.l %%d2, (%[d])+;"
"1:"
: [n] "+d" (n), [d] "+a" (data), [w] "+a" (window)
: : "%d0", "%d1", "%d2", "%d3", "%a0", "%a1", "%a2", "%a3",
"cc", "memory");
}
static inline
void vect_mult_bw(int32_t *data, const int32_t *window, int n)
{
/* ensure at least data is aligned to 16-bytes */
while(n>0 && (int)data&15) {
*data = MULT31(*data, *window);
data++;
window--;
n--;
}
asm volatile ("lea.l (-3*4, %[w]), %[w];" /* loop start */
"movem.l (%[d]), %%d0-%%d3;" /* pre-fetch registers */
"movem.l (%[w]), %%a0-%%a3;"
"bra 1f;" /* jump to loop condition */
"0:" /* loop body */
/* multiply and load next window value */
"mac.l %%d0, %%a3, -(%[w]), %%a3, %%acc0;"
"mac.l %%d1, %%a2, -(%[w]), %%a2, %%acc1;"
"mac.l %%d2, %%a1, -(%[w]), %%a1, %%acc2;"
"mac.l %%d3, %%a0, -(%[w]), %%a0, %%acc3;"
"movclr.l %%acc0, %%d0;" /* get the products */
"movclr.l %%acc1, %%d1;"
"movclr.l %%acc2, %%d2;"
"movclr.l %%acc3, %%d3;"
/* store and advance */
"movem.l %%d0-%%d3, (%[d]);"
"lea.l (4*4, %[d]), %[d];"
"movem.l (%[d]), %%d0-%%d3;"
"subq.l #4, %[n];" /* done 4 elements */
"1: cmpi.l #4, %[n];"
"bge 0b;"
/* multiply final elements */
"tst.l %[n];"
"beq 1f;" /* n=0 */
"mac.l %%d0, %%a3, %%acc0;"
"movclr.l %%acc0, %%d0;"
"move.l %%d0, (%[d])+;"
"subq.l #1, %[n];"
"beq 1f;" /* n=1 */
"mac.l %%d1, %%a2, %%acc0;"
"movclr.l %%acc0, %%d1;"
"move.l %%d1, (%[d])+;"
"subq.l #1, %[n];"
"beq 1f;" /* n=2 */
/* otherwise n = 3 */
"mac.l %%d2, %%a1, %%acc0;"
"movclr.l %%acc0, %%d2;"
"move.l %%d2, (%[d])+;"
"1:"
: [n] "+d" (n), [d] "+a" (data), [w] "+a" (window)
: : "%d0", "%d1", "%d2", "%d3", "%a0", "%a1", "%a2", "%a3",
"cc", "memory");
}
#endif
/* not used anymore */
/*
#ifndef _V_CLIP_MATH
#define _V_CLIP_MATH
* this is portable C and simple; why not use this as default?
static inline int32_t CLIP_TO_15(register int32_t x) {
register int32_t hi=32767, lo=-32768;
return (x>=hi ? hi : (x<=lo ? lo : x));
}
#endif
*/
#endif

182
lib/rbcodec/codecs/lib/codeclib.c Normal file
View file

@ -0,0 +1,182 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 Dave Chapman
*
* 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.
*
****************************************************************************/
/* "helper functions" common to all codecs */
#include <string.h>
#include "codecs.h"
#include "dsp.h"
#include "codeclib.h"
#include "metadata.h"
/* The following variables are used by codec_malloc() to make use of free RAM
* within the statically allocated codec buffer. */
static size_t mem_ptr = 0;
static size_t bufsize = 0;
static unsigned char* mallocbuf = NULL;
int codec_init(void)
{
/* codec_get_buffer() aligns the resulting point to CACHEALIGN_SIZE. */
mem_ptr = 0;
mallocbuf = (unsigned char *)ci->codec_get_buffer((size_t *)&bufsize);
return 0;
}
void codec_set_replaygain(const struct mp3entry *id3)
{
ci->configure(DSP_SET_TRACK_GAIN, id3->track_gain);
ci->configure(DSP_SET_ALBUM_GAIN, id3->album_gain);
ci->configure(DSP_SET_TRACK_PEAK, id3->track_peak);
ci->configure(DSP_SET_ALBUM_PEAK, id3->album_peak);
}
/* Various "helper functions" common to all the xxx2wav decoder plugins */
void* codec_malloc(size_t size)
{
void* x;
if (mem_ptr + (long)size > bufsize)
return NULL;
x=&mallocbuf[mem_ptr];
/* Keep memory aligned to CACHEALIGN_SIZE. */
mem_ptr += (size + (CACHEALIGN_SIZE-1)) & ~(CACHEALIGN_SIZE-1);
return(x);
}
void* codec_calloc(size_t nmemb, size_t size)
{
void* x;
x = codec_malloc(nmemb*size);
if (x == NULL)
return NULL;
ci->memset(x,0,nmemb*size);
return(x);
}
void codec_free(void* ptr) {
(void)ptr;
}
void* codec_realloc(void* ptr, size_t size)
{
void* x;
(void)ptr;
x = codec_malloc(size);
return(x);
}
size_t strlen(const char *s)
{
return(ci->strlen(s));
}
char *strcpy(char *dest, const char *src)
{
return(ci->strcpy(dest,src));
}
char *strcat(char *dest, const char *src)
{
return(ci->strcat(dest,src));
}
int strcmp(const char *s1, const char *s2)
{
return(ci->strcmp(s1,s2));
}
void *memcpy(void *dest, const void *src, size_t n)
{
return(ci->memcpy(dest,src,n));
}
void *memset(void *s, int c, size_t n)
{
return(ci->memset(s,c,n));
}
int memcmp(const void *s1, const void *s2, size_t n)
{
return(ci->memcmp(s1,s2,n));
}
void* memchr(const void *s, int c, size_t n)
{
return(ci->memchr(s,c,n));
}
void *memmove(void *dest, const void *src, size_t n)
{
return(ci->memmove(dest,src,n));
}
void qsort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *))
{
ci->qsort(base,nmemb,size,compar);
}
/* From ffmpeg - libavutil/common.h */
const uint8_t bs_log2_tab[256] ICONST_ATTR = {
0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
};
const uint8_t bs_clz_tab[256] ICONST_ATTR = {
8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
#ifdef RB_PROFILE
void __cyg_profile_func_enter(void *this_fn, void *call_site) {
/* This workaround is required for coldfire gcc 3.4 but is broken for 4.4
and 4.5, but for those the other way works. */
#if defined(CPU_COLDFIRE) && defined(__GNUC__) && __GNUC__ < 4
(void)call_site;
ci->profile_func_enter(this_fn, __builtin_return_address(1));
#else
ci->profile_func_enter(this_fn, call_site);
#endif
}
void __cyg_profile_func_exit(void *this_fn, void *call_site) {
ci->profile_func_exit(this_fn,call_site);
}
#endif

163
lib/rbcodec/codecs/lib/codeclib.h Normal file
View file

@ -0,0 +1,163 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 Dave Chapman
*
* 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.
*
****************************************************************************/
#ifndef __CODECLIB_H__
#define __CODECLIB_H__
#include <inttypes.h>
#include <string.h>
#include "config.h"
#include "codecs.h"
#include "mdct.h"
#include "fft.h"
extern struct codec_api *ci;
/* Standard library functions that are used by the codecs follow here */
/* Get these functions 'out of the way' of the standard functions. Not doing
* so confuses the cygwin linker, and maybe others. These functions need to
* be implemented elsewhere */
#define malloc(x) codec_malloc(x)
#define calloc(x,y) codec_calloc(x,y)
#define realloc(x,y) codec_realloc(x,y)
#define free(x) codec_free(x)
#undef alloca
#define alloca(x) __builtin_alloca(x)
void* codec_malloc(size_t size);
void* codec_calloc(size_t nmemb, size_t size);
void* codec_realloc(void* ptr, size_t size);
void codec_free(void* ptr);
void *memcpy(void *dest, const void *src, size_t n);
void *memset(void *s, int c, size_t n);
int memcmp(const void *s1, const void *s2, size_t n);
void *memmove(void *s1, const void *s2, size_t n);
size_t strlen(const char *s);
char *strcpy(char *dest, const char *src);
char *strcat(char *dest, const char *src);
/* on some platforms strcmp() seems to be a tricky define which
* breaks if we write down strcmp's prototype */
#undef strcmp
int strcmp(const char *s1, const char *s2);
void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
/*MDCT library functions*/
/* -1- Tremor mdct */
extern void mdct_backward(int n, int32_t *in, int32_t *out);
/* -2- ffmpeg fft-based mdct */
extern void ff_imdct_half(unsigned int nbits, int32_t *output, const int32_t *input);
extern void ff_imdct_calc(unsigned int nbits, int32_t *output, const int32_t *input);
/*ffmpeg fft (can be used without mdct)*/
extern void ff_fft_calc_c(int nbits, FFTComplex *z);
#if !defined(CPU_ARM) || ARM_ARCH < 5
/* From libavutil/common.h */
extern const uint8_t bs_log2_tab[256] ICONST_ATTR;
extern const uint8_t bs_clz_tab[256] ICONST_ATTR;
#endif
#define BS_LOG2 0 /* default personality, equivalent floor(log2(x)) */
#define BS_CLZ 1 /* alternate personality, Count Leading Zeros */
#define BS_SHORT 2 /* input guaranteed not to exceed 16 bits */
#define BS_0_0 4 /* guarantee mapping of 0 input to 0 output */
/* Generic bit-scanning function, used to wrap platform CLZ instruction or
scan-and-lookup code, and to provide control over output for 0 inputs. */
static inline unsigned int bs_generic(unsigned int v, int mode)
{
#if defined(CPU_ARM) && ARM_ARCH >= 5
unsigned int r = __builtin_clz(v);
if (mode & BS_CLZ)
{
if (mode & BS_0_0)
r &= 31;
} else {
r = 31 - r;
/* If mode is constant, this is a single conditional instruction */
if (mode & BS_0_0 && (signed)r < 0)
r += 1;
}
#else
const uint8_t *bs_tab;
unsigned int r;
unsigned int n = v;
int inc;
/* Set up table, increment, and initial result value based on
personality. */
if (mode & BS_CLZ)
{
bs_tab = bs_clz_tab;
r = 24;
inc = -16;
} else {
bs_tab = bs_log2_tab;
r = 0;
inc = 16;
}
if (!(mode & BS_SHORT) && n >= 0x10000) {
n >>= 16;
r += inc;
}
if (n > 0xff) {
n >>= 8;
r += inc / 2;
}
#ifdef CPU_COLDFIRE
/* The high 24 bits of n are guaranteed empty after the above, so a
superfluous ext.b instruction can be saved by loading the LUT value over
n with asm */
asm volatile (
"move.b (%1,%0.l),%0"
: "+d" (n)
: "a" (bs_tab)
);
#else
n = bs_tab[n];
#endif
r += n;
if (mode & BS_CLZ && mode & BS_0_0 && v == 0)
r = 0;
#endif
return r;
}
/* TODO figure out if we really need to care about calculating
av_log2(0) */
#define av_log2(v) bs_generic(v, BS_0_0)
/* Various codec helper functions */
int codec_init(void);
void codec_set_replaygain(const struct mp3entry *id3);
#ifdef RB_PROFILE
void __cyg_profile_func_enter(void *this_fn, void *call_site)
NO_PROF_ATTR ICODE_ATTR;
void __cyg_profile_func_exit(void *this_fn, void *call_site)
NO_PROF_ATTR ICODE_ATTR;
#endif
#endif /* __CODECLIB_H__ */

310
lib/rbcodec/codecs/lib/codeclib_misc.h Normal file
View file

@ -0,0 +1,310 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
* *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
* BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
* *
********************************************************************
function: miscellaneous math and prototypes
********************************************************************/
#ifndef _CODECLIB_MISC_H_
#define _CODECLIB_MISC_H_
#include <stdint.h>
#include "asm_arm.h"
#include "asm_mcf5249.h"
#ifndef _LOW_ACCURACY_
/* 64 bit multiply */
#ifdef ROCKBOX_LITTLE_ENDIAN
union magic {
struct {
int32_t lo;
int32_t hi;
} halves;
int64_t whole;
};
#elif defined(ROCKBOX_BIG_ENDIAN)
union magic {
struct {
int32_t hi;
int32_t lo;
} halves;
int64_t whole;
};
#endif
#ifndef INCL_OPTIMIZED_MULT32
#define INCL_OPTIMIZED_MULT32
static inline int32_t MULT32(int32_t x, int32_t y) {
union magic magic;
magic.whole = (int64_t)x * y;
return magic.halves.hi;
}
#endif
#ifndef INCL_OPTIMIZED_MULT31
#define INCL_OPTIMIZED_MULT31
static inline int32_t MULT31(int32_t x, int32_t y) {
return MULT32(x,y)<<1;
}
#endif
#ifndef INCL_OPTIMIZED_MULT31_SHIFT15
#define INCL_OPTIMIZED_MULT31_SHIFT15
static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) {
union magic magic;
magic.whole = (int64_t)x * y;
return ((uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17);
}
#endif
#ifndef INCL_OPTIMIZED_MULT31_SHIFT16
#define INCL_OPTIMIZED_MULT31_SHIFT16
static inline int32_t MULT31_SHIFT16(int32_t x, int32_t y) {
union magic magic;
magic.whole = (int64_t)x * y;
return ((uint32_t)(magic.halves.lo)>>16) | ((magic.halves.hi)<<16);
}
#endif
#else
/* Rockbox: unused */
#if 0
/* 32 bit multiply, more portable but less accurate */
/*
* Note: Precision is biased towards the first argument therefore ordering
* is important. Shift values were chosen for the best sound quality after
* many listening tests.
*/
/*
* For MULT32 and MULT31: The second argument is always a lookup table
* value already preshifted from 31 to 8 bits. We therefore take the
* opportunity to save on text space and use unsigned char for those
* tables in this case.
*/
static inline int32_t MULT32(int32_t x, int32_t y) {
return (x >> 9) * y; /* y preshifted >>23 */
}
static inline int32_t MULT31(int32_t x, int32_t y) {
return (x >> 8) * y; /* y preshifted >>23 */
}
static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) {
return (x >> 6) * y; /* y preshifted >>9 */
}
#endif
#endif
/*
* The XPROD functions are meant to optimize the cross products found all
* over the place in mdct.c by forcing memory operation ordering to avoid
* unnecessary register reloads as soon as memory is being written to.
* However this is only beneficial on CPUs with a sane number of general
* purpose registers which exclude the Intel x86. On Intel, better let the
* compiler actually reload registers directly from original memory by using
* macros.
*/
#ifndef INCL_OPTIMIZED_XPROD32
#define INCL_OPTIMIZED_XPROD32
/* replaced XPROD32 with a macro to avoid memory reference
_x, _y are the results (must be l-values) */
#define XPROD32(_a, _b, _t, _v, _x, _y) \
{ (_x)=MULT32(_a,_t)+MULT32(_b,_v); \
(_y)=MULT32(_b,_t)-MULT32(_a,_v); }
#endif
/* Rockbox: Unused */
/*
#ifdef __i386__
#define XPROD31(_a, _b, _t, _v, _x, _y) \
{ *(_x)=MULT31(_a,_t)+MULT31(_b,_v); \
*(_y)=MULT31(_b,_t)-MULT31(_a,_v); }
#define XNPROD31(_a, _b, _t, _v, _x, _y) \
{ *(_x)=MULT31(_a,_t)-MULT31(_b,_v); \
*(_y)=MULT31(_b,_t)+MULT31(_a,_v); }
#else
*/
#ifndef INCL_OPTIMIZED_XPROD31
#define INCL_OPTIMIZED_XPROD31
static inline void XPROD31(int32_t a, int32_t b,
int32_t t, int32_t v,
int32_t *x, int32_t *y)
{
*x = MULT31(a, t) + MULT31(b, v);
*y = MULT31(b, t) - MULT31(a, v);
}
#endif
#ifndef INCL_OPTIMIZED_XNPROD31
#define INCL_OPTIMIZED_XNPROD31
static inline void XNPROD31(int32_t a, int32_t b,
int32_t t, int32_t v,
int32_t *x, int32_t *y)
{
*x = MULT31(a, t) - MULT31(b, v);
*y = MULT31(b, t) + MULT31(a, v);
}
#endif
/*#endif*/
#ifndef INCL_OPTIMIZED_XPROD31_R
#define INCL_OPTIMIZED_XPROD31_R
#define XPROD31_R(_a, _b, _t, _v, _x, _y)\
{\
_x = MULT31(_a, _t) + MULT31(_b, _v);\
_y = MULT31(_b, _t) - MULT31(_a, _v);\
}
#endif
#ifndef INCL_OPTIMIZED_XNPROD31_R
#define INCL_OPTIMIZED_XNPROD31_R
#define XNPROD31_R(_a, _b, _t, _v, _x, _y)\
{\
_x = MULT31(_a, _t) - MULT31(_b, _v);\
_y = MULT31(_b, _t) + MULT31(_a, _v);\
}
#endif
#ifndef _V_VECT_OPS
#define _V_VECT_OPS
static inline
void vect_add(int32_t *x, const int32_t *y, int n)
{
while (n>0) {
*x++ += *y++;
n--;
}
}
static inline
void vect_copy(int32_t *x, const int32_t *y, int n)
{
while (n>0) {
*x++ = *y++;
n--;
}
}
static inline
void vect_mult_fw(int32_t *data, const int32_t *window, int n)
{
while(n>0) {
*data = MULT31(*data, *window);
data++;
window++;
n--;
}
}
static inline
void vect_mult_bw(int32_t *data, const int32_t *window, int n)
{
while(n>0) {
*data = MULT31(*data, *window);
data++;
window--;
n--;
}
}
#endif
/* not used anymore */
/*
#ifndef _V_CLIP_MATH
#define _V_CLIP_MATH
static inline int32_t CLIP_TO_15(int32_t x) {
int ret=x;
ret-= ((x<=32767)-1)&(x-32767);
ret-= ((x>=-32768)-1)&(x+32768);
return(ret);
}
#endif
*/
static inline int32_t VFLOAT_MULT(int32_t a,int32_t ap,
int32_t b,int32_t bp,
int32_t *p){
if(a && b){
#ifndef _LOW_ACCURACY_
*p=ap+bp+32;
return MULT32(a,b);
#else
*p=ap+bp+31;
return (a>>15)*(b>>16);
#endif
}else
return 0;
}
/*static inline int32_t VFLOAT_MULTI(int32_t a,int32_t ap,
int32_t i,
int32_t *p){
int ip=_ilog(abs(i))-31;
return VFLOAT_MULT(a,ap,i<<-ip,ip,p);
}
*/
static inline int32_t VFLOAT_ADD(int32_t a,int32_t ap,
int32_t b,int32_t bp,
int32_t *p){
if(!a){
*p=bp;
return b;
}else if(!b){
*p=ap;
return a;
}
/* yes, this can leak a bit. */
if(ap>bp){
int shift=ap-bp+1;
*p=ap+1;
a>>=1;
if(shift<32){
b=(b+(1<<(shift-1)))>>shift;
}else{
b=0;
}
}else{
int shift=bp-ap+1;
*p=bp+1;
b>>=1;
if(shift<32){
a=(a+(1<<(shift-1)))>>shift;
}else{
a=0;
}
}
a+=b;
if((a&0xc0000000)==0xc0000000 ||
(a&0xc0000000)==0){
a<<=1;
(*p)--;
}
return(a);
}
#endif

374
lib/rbcodec/codecs/lib/ffmpeg_bitstream.c Normal file
View file

@ -0,0 +1,374 @@
/*
* Common bit i/o utils
* Copyright (c) 2000, 2001 Fabrice Bellard
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
* Copyright (c) 2010 Loren Merritt
*
* alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at>
*
* 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
* bitstream api.
*/
//#include "avcodec.h"
#include "ffmpeg_get_bits.h"
#include "ffmpeg_put_bits.h"
#include "ffmpeg_intreadwrite.h"
#define av_log(...)
#ifdef ROCKBOX
#undef DEBUGF
#define DEBUGF(...)
#endif
const uint8_t ff_log2_run[32]={
0, 0, 0, 0, 1, 1, 1, 1,
2, 2, 2, 2, 3, 3, 3, 3,
4, 4, 5, 5, 6, 6, 7, 7,
8, 9,10,11,12,13,14,15
};
#if 0 // unused in rockbox
void align_put_bits(PutBitContext *s)
{
#ifdef ALT_BITSTREAM_WRITER
put_bits(s,( - s->index) & 7,0);
#else
put_bits(s,s->bit_left & 7,0);
#endif
}
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
{
while(*string){
put_bits(pb, 8, *string);
string++;
}
if(terminate_string)
put_bits(pb, 8, 0);
}
#endif
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
{
int words= length>>4;
int bits= length&15;
int i;
if(length==0) return;
if(words < 16 || put_bits_count(pb)&7){
for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i));
}else{
for(i=0; put_bits_count(pb)&31; i++)
put_bits(pb, 8, src[i]);
flush_put_bits(pb);
memcpy(put_bits_ptr(pb), src+i, 2*words-i);
skip_put_bytes(pb, 2*words-i);
}
put_bits(pb, bits, AV_RB16(src + 2*words)>>(16-bits));
}
/* VLC decoding */
//#define DEBUG_VLC
#define GET_DATA(v, table, i, wrap, size) \
{\
const uint8_t *ptr = (const uint8_t *)table + i * wrap;\
switch(size) {\
case 1:\
v = *(const uint8_t *)ptr;\
break;\
case 2:\
v = *(const uint16_t *)ptr;\
break;\
default:\
v = *(const uint32_t *)ptr;\
break;\
}\
}
static int alloc_table(VLC *vlc, int size, int use_static)
{
int index;
index = vlc->table_size;
vlc->table_size += size;
if (vlc->table_size > vlc->table_allocated) {
if(use_static)
{
DEBUGF("init_vlc() used with too little memory : table_size > allocated_memory\n");
return -1;
}
// abort(); //cant do anything, init_vlc() is used with too little memory
// vlc->table_allocated += (1 << vlc->bits);
// vlc->table = av_realloc(vlc->table,
// sizeof(VLC_TYPE) * 2 * vlc->table_allocated);
if (!vlc->table)
return -1;
}
return index;
}
/*
static av_always_inline uint32_t bitswap_32(uint32_t x) {
return av_reverse[x&0xFF]<<24
| av_reverse[(x>>8)&0xFF]<<16
| av_reverse[(x>>16)&0xFF]<<8
| av_reverse[x>>24];
}
*/
typedef struct {
uint8_t bits;
uint16_t symbol;
/** codeword, with the first bit-to-be-read in the msb
* (even if intended for a little-endian bitstream reader) */
uint32_t code;
} __attribute__((__packed__)) VLCcode; /* packed to save space */
static int compare_vlcspec(const void *a, const void *b)
{
const VLCcode *sa=a, *sb=b;
return (sa->code >> 1) - (sb->code >> 1);
}
/**
* Build VLC decoding tables suitable for use with get_vlc().
*
* @param vlc the context to be initted
*
* @param table_nb_bits max length of vlc codes to store directly in this table
* (Longer codes are delegated to subtables.)
*
* @param nb_codes number of elements in codes[]
*
* @param codes descriptions of the vlc codes
* These must be ordered such that codes going into the same subtable are contiguous.
* Sorting by VLCcode.code is sufficient, though not necessary.
*/
static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
VLCcode *codes, int flags)
{
int table_size, table_index, index, symbol, subtable_bits;
int i, j, k, n, nb, inc;
uint32_t code, code_prefix;
VLC_TYPE (*table)[2];
table_size = 1 << table_nb_bits;
table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
#ifdef DEBUG_VLC
av_log(NULL,AV_LOG_DEBUG,"new table index=%d size=%d\n",
table_index, table_size);
#endif
if (table_index < 0)
return -1;
table = &vlc->table[table_index];
for (i = 0; i < table_size; i++) {
table[i][1] = 0; //bits
table[i][0] = -1; //codes
}
/* first pass: map codes and compute auxillary table sizes */
for (i = 0; i < nb_codes; i++) {
n = codes[i].bits;
code = codes[i].code;
symbol = codes[i].symbol;
#if defined(DEBUG_VLC) && 0
av_log(NULL,AV_LOG_DEBUG,"i=%d n=%d code=0x%x\n", i, n, code);
#endif
if (n <= table_nb_bits) {
/* no need to add another table */
j = code >> (32 - table_nb_bits);
nb = 1 << (table_nb_bits - n);
inc = 1;
/* if (flags & INIT_VLC_LE) {
j = bitswap_32(code);
inc = 1 << n;
} */
for (k = 0; k < nb; k++) {
#ifdef DEBUG_VLC
av_log(NULL, AV_LOG_DEBUG, "%4x: code=%d n=%d\n",
j, i, n);
#endif
if (table[j][1] /*bits*/ != 0) {
av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
return -1;
}
table[j][1] = n; //bits
table[j][0] = symbol;
j += inc;
}
} else {
/* fill auxiliary table recursively */
n -= table_nb_bits;
code_prefix = code >> (32 - table_nb_bits);
subtable_bits = n;
codes[i].bits = n;
codes[i].code = code << table_nb_bits;
for (k = i+1; k < nb_codes; k++) {
n = codes[k].bits - table_nb_bits;
if (n <= 0)
break;
code = codes[k].code;
if (code >> (32 - table_nb_bits) != code_prefix)
break;
codes[k].bits = n;
codes[k].code = code << table_nb_bits;
subtable_bits = FFMAX(subtable_bits, n);
}
subtable_bits = FFMIN(subtable_bits, table_nb_bits);
j = /*(flags & INIT_VLC_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) :*/ code_prefix;
table[j][1] = -subtable_bits;
#ifdef DEBUG_VLC
av_log(NULL,AV_LOG_DEBUG,"%4x: n=%d (subtable)\n",
j, codes[i].bits + table_nb_bits);
#endif
index = build_table(vlc, subtable_bits, k-i, codes+i, flags);
if (index < 0)
return -1;
/* note: realloc has been done, so reload tables */
table = &vlc->table[table_index];
table[j][0] = index; //code
i = k-1;
}
}
return table_index;
}
/* Build VLC decoding tables suitable for use with get_vlc().
'nb_bits' set thee decoding table size (2^nb_bits) entries. The
bigger it is, the faster is the decoding. But it should not be too
big to save memory and L1 cache. '9' is a good compromise.
'nb_codes' : number of vlcs codes
'bits' : table which gives the size (in bits) of each vlc code.
'codes' : table which gives the bit pattern of of each vlc code.
'symbols' : table which gives the values to be returned from get_vlc().
'xxx_wrap' : give the number of bytes between each entry of the
'bits' or 'codes' tables.
'xxx_size' : gives the number of bytes of each entry of the 'bits'
or 'codes' tables.
'wrap' and 'size' allows to use any memory configuration and types
(byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
'use_static' should be set to 1 for tables, which should be freed
with av_free_static(), 0 if free_vlc() will be used.
*/
/* Rockbox: support for INIT_VLC_LE is currently disabled since none of our
codecs use it, there's a LUT based bit reverse function for this commented
out above (bitswap_32) and an inline asm version in libtremor/codebook.c
if we ever want this */
static VLCcode buf[1336+1]; /* worst case is wma, which has one table with 1336 entries */
int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
const void *bits, int bits_wrap, int bits_size,
const void *codes, int codes_wrap, int codes_size,
const void *symbols, int symbols_wrap, int symbols_size,
int flags)
{
if (nb_codes+1 > (int)(sizeof (buf)/ sizeof (VLCcode)))
{
DEBUGF("Table is larger than temp buffer!\n");
return -1;
}
int i, j, ret;
vlc->bits = nb_bits;
if(flags & INIT_VLC_USE_NEW_STATIC){
if(vlc->table_size && vlc->table_size == vlc->table_allocated){
return 0;
}else if(vlc->table_size){
DEBUGF("fatal error, we are called on a partially initialized table\n");
return -1;
// abort(); // fatal error, we are called on a partially initialized table
}
}else {
vlc->table = NULL;
vlc->table_allocated = 0;
vlc->table_size = 0;
}
#ifdef DEBUG_VLC
av_log(NULL,AV_LOG_DEBUG,"build table nb_codes=%d\n", nb_codes);
#endif
// buf = av_malloc((nb_codes+1)*sizeof(VLCcode));
// assert(symbols_size <= 2 || !symbols);
j = 0;
#define COPY(condition)\
for (i = 0; i < nb_codes; i++) {\
GET_DATA(buf[j].bits, bits, i, bits_wrap, bits_size);\
if (!(condition))\
continue;\
GET_DATA(buf[j].code, codes, i, codes_wrap, codes_size);\
/* if (flags & INIT_VLC_LE)*/\
/* buf[j].code = bitswap_32(buf[j].code);*/\
/* else*/\
buf[j].code <<= 32 - buf[j].bits;\
if (symbols)\
GET_DATA(buf[j].symbol, symbols, i, symbols_wrap, symbols_size)\
else\
buf[j].symbol = i;\
j++;\
}
COPY(buf[j].bits > nb_bits);
// qsort is the slowest part of init_vlc, and could probably be improved or avoided
qsort(buf, j, sizeof(VLCcode), compare_vlcspec);
COPY(buf[j].bits && buf[j].bits <= nb_bits);
nb_codes = j;
ret = build_table(vlc, nb_bits, nb_codes, buf, flags);
// av_free(buf);
if (ret < 0) {
// av_freep(&vlc->table);
return -1;
}
if((flags & INIT_VLC_USE_NEW_STATIC) && vlc->table_size != vlc->table_allocated) {
av_log(NULL, AV_LOG_ERROR, "needed %d had %d\n", vlc->table_size, vlc->table_allocated);
}
return 0;
}
/* not used in rockbox
void free_vlc(VLC *vlc)
{
av_freep(&vlc->table);
}
*/

150
lib/rbcodec/codecs/lib/ffmpeg_bswap.h Normal file
View file

@ -0,0 +1,150 @@
/**
* @file bswap.h
* byte swap.
*/
#ifndef __BSWAP_H__
#define __BSWAP_H__
#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
#else
#ifdef ROCKBOX
#include "codecs.h"
/* rockbox' optimised inline functions */
#define bswap_16(x) swap16(x)
#define bswap_32(x) swap32(x)
static inline uint64_t ByteSwap64(uint64_t x)
{
union {
uint64_t ll;
struct {
uint32_t l,h;
} l;
} r;
r.l.l = bswap_32 (x);
r.l.h = bswap_32 (x>>32);
return r.ll;
}
#define bswap_64(x) ByteSwap64(x)
#elif defined(ARCH_X86)
static inline unsigned short ByteSwap16(unsigned short x)
{
__asm("xchgb %b0,%h0" :
"=q" (x) :
"0" (x));
return x;
}
#define bswap_16(x) ByteSwap16(x)
static inline unsigned int ByteSwap32(unsigned int x)
{
#if __CPU__ > 386
__asm("bswap %0":
"=r" (x) :
#else
__asm("xchgb %b0,%h0\n"
" rorl $16,%0\n"
" xchgb %b0,%h0":
"=q" (x) :
#endif
"0" (x));
return x;
}
#define bswap_32(x) ByteSwap32(x)
static inline unsigned long long int ByteSwap64(unsigned long long int x)
{
register union { __extension__ uint64_t __ll;
uint32_t __l[2]; } __x;
asm("xchgl %0,%1":
"=r"(__x.__l[0]),"=r"(__x.__l[1]):
"0"(bswap_32((unsigned long)x)),"1"(bswap_32((unsigned long)(x>>32))));
return __x.__ll;
}
#define bswap_64(x) ByteSwap64(x)
#elif defined(ARCH_SH4)
static inline uint16_t ByteSwap16(uint16_t x) {
__asm__("swap.b %0,%0":"=r"(x):"0"(x));
return x;
}
static inline uint32_t ByteSwap32(uint32_t x) {
__asm__(
"swap.b %0,%0\n"
"swap.w %0,%0\n"
"swap.b %0,%0\n"
:"=r"(x):"0"(x));
return x;
}
#define bswap_16(x) ByteSwap16(x)
#define bswap_32(x) ByteSwap32(x)
static inline uint64_t ByteSwap64(uint64_t x)
{
union {
uint64_t ll;
struct {
uint32_t l,h;
} l;
} r;
r.l.l = bswap_32 (x);
r.l.h = bswap_32 (x>>32);
return r.ll;
}
#define bswap_64(x) ByteSwap64(x)
#else
#define bswap_16(x) (((x) & 0x00ff) << 8 | ((x) & 0xff00) >> 8)
// code from bits/byteswap.h (C) 1997, 1998 Free Software Foundation, Inc.
#define bswap_32(x) \
((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \
(((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24))
static inline uint64_t ByteSwap64(uint64_t x)
{
union {
uint64_t ll;
uint32_t l[2];
} w, r;
w.ll = x;
r.l[0] = bswap_32 (w.l[1]);
r.l[1] = bswap_32 (w.l[0]);
return r.ll;
}
#define bswap_64(x) ByteSwap64(x)
#endif /* !ARCH_X86 */
#endif /* !HAVE_BYTESWAP_H */
// be2me ... BigEndian to MachineEndian
// le2me ... LittleEndian to MachineEndian
#ifdef ROCKBOX_BIG_ENDIAN
#define be2me_16(x) (x)
#define be2me_32(x) (x)
#define be2me_64(x) (x)
#define le2me_16(x) bswap_16(x)
#define le2me_32(x) bswap_32(x)
#define le2me_64(x) bswap_64(x)
#else
#define be2me_16(x) bswap_16(x)
#define be2me_32(x) bswap_32(x)
#define be2me_64(x) bswap_64(x)
#define le2me_16(x) (x)
#define le2me_32(x) (x)
#define le2me_64(x) (x)
#endif
#endif /* __BSWAP_H__ */

743
lib/rbcodec/codecs/lib/ffmpeg_get_bits.h Normal file
View file

@ -0,0 +1,743 @@
/*
* copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
*
* 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
* bitstream reader API header.
*/
#ifndef AVCODEC_GET_BITS_H
#define AVCODEC_GET_BITS_H
#include <stdint.h>
#include <stdlib.h>
#include "ffmpeg_intreadwrite.h"
//#include <assert.h>
//#include "libavutil/bswap.h"
//#include "libavutil/common.h"
//#include "libavutil/intreadwrite.h"
//#include "libavutil/log.h"
//#include "mathops.h"
#include "codecs.h"
/* rockbox' optimised inline functions */
#define bswap_16(x) swap16(x)
#define bswap_32(x) swap32(x)
#ifdef ROCKBOX_BIG_ENDIAN
#define be2me_16(x) (x)
#define be2me_32(x) (x)
#define le2me_16(x) bswap_16(x)
#define le2me_32(x) bswap_32(x)
#else
#define be2me_16(x) bswap_16(x)
#define be2me_32(x) bswap_32(x)
#define le2me_16(x) (x)
#define le2me_32(x) (x)
#endif
#define av_const __attribute__((const))
#define av_always_inline inline __attribute__((always_inline))
/* The following is taken from mathops.h */
#ifndef sign_extend
static inline av_const int sign_extend(int val, unsigned bits)
{
return (val << ((8 * sizeof(int)) - bits)) >> ((8 * sizeof(int)) - bits);
}
#endif
#ifndef NEG_SSR32
# define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
#endif
#ifndef NEG_USR32
# define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
#endif
/* these 2 are from libavutil/common.h */
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER)
# define ALT_BITSTREAM_READER
#endif
/*
#if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER)
# if ARCH_ARM && !HAVE_FAST_UNALIGNED
# define A32_BITSTREAM_READER
# else
*/
# define ALT_BITSTREAM_READER
/*
//#define LIBMPEG2_BITSTREAM_READER
//#define A32_BITSTREAM_READER
# endif
#endif
*/
/* bit input */
/* buffer, buffer_end and size_in_bits must be present and used by every reader */
typedef struct GetBitContext {
const uint8_t *buffer, *buffer_end;
#ifdef ALT_BITSTREAM_READER
int index;
#elif defined LIBMPEG2_BITSTREAM_READER
uint8_t *buffer_ptr;
uint32_t cache;
int bit_count;
#elif defined A32_BITSTREAM_READER
uint32_t *buffer_ptr;
uint32_t cache0;
uint32_t cache1;
int bit_count;
#endif
int size_in_bits;
} GetBitContext;
#define VLC_TYPE int16_t
typedef struct VLC {
int bits;
VLC_TYPE (*table)[2]; ///< code, bits
int table_size, table_allocated;
} VLC;
typedef struct RL_VLC_ELEM {
int16_t level;
int8_t len;
uint8_t run;
} RL_VLC_ELEM;
/* Bitstream reader API docs:
name
arbitrary name which is used as prefix for the internal variables
gb
getbitcontext
OPEN_READER(name, gb)
loads gb into local variables
CLOSE_READER(name, gb)
stores local vars in gb
UPDATE_CACHE(name, gb)
refills the internal cache from the bitstream
after this call at least MIN_CACHE_BITS will be available,
GET_CACHE(name, gb)
will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
SHOW_UBITS(name, gb, num)
will return the next num bits
SHOW_SBITS(name, gb, num)
will return the next num bits and do sign extension
SKIP_BITS(name, gb, num)
will skip over the next num bits
note, this is equivalent to SKIP_CACHE; SKIP_COUNTER
SKIP_CACHE(name, gb, num)
will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
SKIP_COUNTER(name, gb, num)
will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
LAST_SKIP_CACHE(name, gb, num)
will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
LAST_SKIP_BITS(name, gb, num)
is equivalent to LAST_SKIP_CACHE; SKIP_COUNTER
for examples see get_bits, show_bits, skip_bits, get_vlc
*/
#ifdef ALT_BITSTREAM_READER
# define MIN_CACHE_BITS 25
/* ROCKBOX: work around "set but not used" warning */
# define OPEN_READER(name, gb)\
unsigned int name##_index= (gb)->index;\
int name##_cache __attribute__((unused)) = 0;\
# define CLOSE_READER(name, gb)\
(gb)->index= name##_index;\
# ifdef ALT_BITSTREAM_READER_LE
# define UPDATE_CACHE(name, gb)\
name##_cache= AV_RL32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\
# define SKIP_CACHE(name, gb, num)\
name##_cache >>= (num);
# else
# define UPDATE_CACHE(name, gb)\
name##_cache= AV_RB32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\
# define SKIP_CACHE(name, gb, num)\
name##_cache <<= (num);
# endif
// FIXME name?
# define SKIP_COUNTER(name, gb, num)\
name##_index += (num);\
# define SKIP_BITS(name, gb, num)\
{\
SKIP_CACHE(name, gb, num)\
SKIP_COUNTER(name, gb, num)\
}\
# define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
# define LAST_SKIP_CACHE(name, gb, num) ;
# ifdef ALT_BITSTREAM_READER_LE
# define SHOW_UBITS(name, gb, num)\
zero_extend(name##_cache, num)
# define SHOW_SBITS(name, gb, num)\
sign_extend(name##_cache, num)
# else
# define SHOW_UBITS(name, gb, num)\
NEG_USR32(name##_cache, num)
# define SHOW_SBITS(name, gb, num)\
NEG_SSR32(name##_cache, num)
# endif
# define GET_CACHE(name, gb)\
((uint32_t)name##_cache)
static inline int get_bits_count(const GetBitContext *s){
return s->index;
}
static inline void skip_bits_long(GetBitContext *s, int n){
s->index += n;
}
#elif defined LIBMPEG2_BITSTREAM_READER
//libmpeg2 like reader
# define MIN_CACHE_BITS 17
# define OPEN_READER(name, gb)\
int name##_bit_count=(gb)->bit_count;\
int name##_cache= (gb)->cache;\
uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
# define CLOSE_READER(name, gb)\
(gb)->bit_count= name##_bit_count;\
(gb)->cache= name##_cache;\
(gb)->buffer_ptr= name##_buffer_ptr;\
# define UPDATE_CACHE(name, gb)\
if(name##_bit_count >= 0){\
name##_cache+= AV_RB16(name##_buffer_ptr) << name##_bit_count; \
name##_buffer_ptr+=2;\
name##_bit_count-= 16;\
}\
# define SKIP_CACHE(name, gb, num)\
name##_cache <<= (num);\
# define SKIP_COUNTER(name, gb, num)\
name##_bit_count += (num);\
# define SKIP_BITS(name, gb, num)\
{\
SKIP_CACHE(name, gb, num)\
SKIP_COUNTER(name, gb, num)\
}\
# define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
# define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
# define SHOW_UBITS(name, gb, num)\
NEG_USR32(name##_cache, num)
# define SHOW_SBITS(name, gb, num)\
NEG_SSR32(name##_cache, num)
# define GET_CACHE(name, gb)\
((uint32_t)name##_cache)
static inline int get_bits_count(const GetBitContext *s){
return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
}
static inline void skip_bits_long(GetBitContext *s, int n){
OPEN_READER(re, s)
re_bit_count += n;
re_buffer_ptr += 2*(re_bit_count>>4);
re_bit_count &= 15;
re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count);
UPDATE_CACHE(re, s)
CLOSE_READER(re, s)
}
#elif defined A32_BITSTREAM_READER
# define MIN_CACHE_BITS 32
# define OPEN_READER(name, gb)\
int name##_bit_count=(gb)->bit_count;\
uint32_t name##_cache0= (gb)->cache0;\
uint32_t name##_cache1= (gb)->cache1;\
uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
# define CLOSE_READER(name, gb)\
(gb)->bit_count= name##_bit_count;\
(gb)->cache0= name##_cache0;\
(gb)->cache1= name##_cache1;\
(gb)->buffer_ptr= name##_buffer_ptr;\
# define UPDATE_CACHE(name, gb)\
if(name##_bit_count > 0){\
const uint32_t next= av_be2ne32( *name##_buffer_ptr );\
name##_cache0 |= NEG_USR32(next,name##_bit_count);\
name##_cache1 |= next<<name##_bit_count;\
name##_buffer_ptr++;\
name##_bit_count-= 32;\
}\
#if ARCH_X86
# define SKIP_CACHE(name, gb, num)\
__asm__(\
"shldl %2, %1, %0 \n\t"\
"shll %2, %1 \n\t"\
: "+r" (name##_cache0), "+r" (name##_cache1)\
: "Ic" ((uint8_t)(num))\
);
#else
# define SKIP_CACHE(name, gb, num)\
name##_cache0 <<= (num);\
name##_cache0 |= NEG_USR32(name##_cache1,num);\
name##_cache1 <<= (num);
#endif
# define SKIP_COUNTER(name, gb, num)\
name##_bit_count += (num);\
# define SKIP_BITS(name, gb, num)\
{\
SKIP_CACHE(name, gb, num)\
SKIP_COUNTER(name, gb, num)\
}\
# define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
# define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
# define SHOW_UBITS(name, gb, num)\
NEG_USR32(name##_cache0, num)
# define SHOW_SBITS(name, gb, num)\
NEG_SSR32(name##_cache0, num)
# define GET_CACHE(name, gb)\
(name##_cache0)
static inline int get_bits_count(const GetBitContext *s){
return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
}
static inline void skip_bits_long(GetBitContext *s, int n){
OPEN_READER(re, s)
re_bit_count += n;
re_buffer_ptr += re_bit_count>>5;
re_bit_count &= 31;
re_cache0 = av_be2ne32( re_buffer_ptr[-1] ) << re_bit_count;
re_cache1 = 0;
UPDATE_CACHE(re, s)
CLOSE_READER(re, s)
}
#endif
/**
* read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
* if MSB not set it is negative
* @param n length in bits
* @author BERO
*/
static inline int get_xbits(GetBitContext *s, int n){
register int sign;
register int32_t cache;
OPEN_READER(re, s)
UPDATE_CACHE(re, s)
cache = GET_CACHE(re,s);
sign=(~cache)>>31;
LAST_SKIP_BITS(re, s, n)
CLOSE_READER(re, s)
return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
}
static inline int get_sbits(GetBitContext *s, int n){
register int tmp;
OPEN_READER(re, s)
UPDATE_CACHE(re, s)
tmp= SHOW_SBITS(re, s, n);
LAST_SKIP_BITS(re, s, n)
CLOSE_READER(re, s)
return tmp;
}
/**
* reads 1-17 bits.
* Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't
*/
static inline unsigned int get_bits(GetBitContext *s, int n){
register int tmp;
OPEN_READER(re, s)
UPDATE_CACHE(re, s)
tmp= SHOW_UBITS(re, s, n);
LAST_SKIP_BITS(re, s, n)
CLOSE_READER(re, s)
return tmp;
}
/**
* shows 1-17 bits.
* Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't
*/
static inline unsigned int show_bits(GetBitContext *s, int n){
register int tmp;
OPEN_READER(re, s)
UPDATE_CACHE(re, s)
tmp= SHOW_UBITS(re, s, n);
// CLOSE_READER(re, s)
return tmp;
}
static inline void skip_bits(GetBitContext *s, int n){
//Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
OPEN_READER(re, s)
UPDATE_CACHE(re, s)
LAST_SKIP_BITS(re, s, n)
CLOSE_READER(re, s)
}
static inline unsigned int get_bits1(GetBitContext *s){
#ifdef ALT_BITSTREAM_READER
unsigned int index= s->index;
uint8_t result= s->buffer[ index>>3 ];
#ifdef ALT_BITSTREAM_READER_LE
result>>= (index&0x07);
result&= 1;
#else
result<<= (index&0x07);
result>>= 8 - 1;
#endif
index++;
s->index= index;
return result;
#else
return get_bits(s, 1);
#endif
}
static inline unsigned int show_bits1(GetBitContext *s){
return show_bits(s, 1);
}
static inline void skip_bits1(GetBitContext *s){
skip_bits(s, 1);
}
/**
* reads 0-32 bits.
*/
static inline unsigned int get_bits_long(GetBitContext *s, int n){
if(n<=MIN_CACHE_BITS) return get_bits(s, n);
else{
#ifdef ALT_BITSTREAM_READER_LE
int ret= get_bits(s, 16);
return ret | (get_bits(s, n-16) << 16);
#else
int ret= get_bits(s, 16) << (n-16);
return ret | get_bits(s, n-16);
#endif
}
}
/**
* reads 0-32 bits as a signed integer.
*/
static inline int get_sbits_long(GetBitContext *s, int n) {
return sign_extend(get_bits_long(s, n), n);
}
/**
* shows 0-32 bits.
*/
static inline unsigned int show_bits_long(GetBitContext *s, int n){
if(n<=MIN_CACHE_BITS) return show_bits(s, n);
else{
GetBitContext gb= *s;
return get_bits_long(&gb, n);
}
}
/* not used
static inline int check_marker(GetBitContext *s, const char *msg)
{
int bit= get_bits1(s);
if(!bit)
av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);
return bit;
}
*/
/**
* init GetBitContext.
* @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits
* because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
* @param bit_size the size of the buffer in bits
*
* While GetBitContext stores the buffer size, for performance reasons you are
* responsible for checking for the buffer end yourself (take advantage of the padding)!
*/
static inline void init_get_bits(GetBitContext *s,
const uint8_t *buffer, int bit_size)
{
int buffer_size= (bit_size+7)>>3;
if(buffer_size < 0 || bit_size < 0) {
buffer_size = bit_size = 0;
buffer = NULL;
}
s->buffer= buffer;
s->size_in_bits= bit_size;
s->buffer_end= buffer + buffer_size;
#ifdef ALT_BITSTREAM_READER
s->index=0;
#elif defined LIBMPEG2_BITSTREAM_READER
s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1));
s->bit_count = 16 + 8*((intptr_t)buffer&1);
skip_bits_long(s, 0);
#elif defined A32_BITSTREAM_READER
s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3));
s->bit_count = 32 + 8*((intptr_t)buffer&3);
skip_bits_long(s, 0);
#endif
}
static inline void align_get_bits(GetBitContext *s)
{
int n= (-get_bits_count(s)) & 7;
if(n) skip_bits(s, n);
}
#define init_vlc(vlc, nb_bits, nb_codes,\
bits, bits_wrap, bits_size,\
codes, codes_wrap, codes_size,\
flags)\
init_vlc_sparse(vlc, nb_bits, nb_codes,\
bits, bits_wrap, bits_size,\
codes, codes_wrap, codes_size,\
NULL, 0, 0, flags)
int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
const void *bits, int bits_wrap, int bits_size,
const void *codes, int codes_wrap, int codes_size,
const void *symbols, int symbols_wrap, int symbols_size,
int flags);
#define INIT_VLC_LE 2
#define INIT_VLC_USE_NEW_STATIC 4
void free_vlc(VLC *vlc);
#define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size, attr)\
{\
static VLC_TYPE table[static_size][2] attr;\
(vlc)->table= table;\
(vlc)->table_allocated= static_size;\
init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC);\
}
/**
*
* If the vlc code is invalid and max_depth=1, then no bits will be removed.
* If the vlc code is invalid and max_depth>1, then the number of bits removed
* is undefined.
*/
#define GET_VLC(code, name, gb, table, bits, max_depth)\
{\
int n, nb_bits;\
unsigned int index;\
\
index= SHOW_UBITS(name, gb, bits);\
code = table[index][0];\
n = table[index][1];\
\
if(max_depth > 1 && n < 0){\
LAST_SKIP_BITS(name, gb, bits)\
UPDATE_CACHE(name, gb)\
\
nb_bits = -n;\
\
index= SHOW_UBITS(name, gb, nb_bits) + code;\
code = table[index][0];\
n = table[index][1];\
if(max_depth > 2 && n < 0){\
LAST_SKIP_BITS(name, gb, nb_bits)\
UPDATE_CACHE(name, gb)\
\
nb_bits = -n;\
\
index= SHOW_UBITS(name, gb, nb_bits) + code;\
code = table[index][0];\
n = table[index][1];\
}\
}\
SKIP_BITS(name, gb, n)\
}
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\
{\
int n, nb_bits;\
unsigned int index;\
\
index= SHOW_UBITS(name, gb, bits);\
level = table[index].level;\
n = table[index].len;\
\
if(max_depth > 1 && n < 0){\
SKIP_BITS(name, gb, bits)\
if(need_update){\
UPDATE_CACHE(name, gb)\
}\
\
nb_bits = -n;\
\
index= SHOW_UBITS(name, gb, nb_bits) + level;\
level = table[index].level;\
n = table[index].len;\
}\
run= table[index].run;\
SKIP_BITS(name, gb, n)\
}
/**
* parses a vlc code, faster then get_vlc()
* @param bits is the number of bits which will be read at once, must be
* identical to nb_bits in init_vlc()
* @param max_depth is the number of times bits bits must be read to completely
* read the longest vlc code
* = (max_vlc_length + bits - 1) / bits
*/
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
int bits, int max_depth)
{
int code;
OPEN_READER(re, s)
UPDATE_CACHE(re, s)
GET_VLC(code, re, s, table, bits, max_depth)
CLOSE_READER(re, s)
return code;
}
//#define TRACE
#ifdef TRACE
static inline void print_bin(int bits, int n){
int i;
for(i=n-1; i>=0; i--){
av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1);
}
for(i=n; i<24; i++)
av_log(NULL, AV_LOG_DEBUG, " ");
}
static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
int r= get_bits(s, n);
print_bin(r, n);
av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line);
return r;
}
static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){
int show= show_bits(s, 24);
int pos= get_bits_count(s);
int r= get_vlc2(s, table, bits, max_depth);
int len= get_bits_count(s) - pos;
int bits2= show>>(24-len);
print_bin(bits2, len);
av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);
return r;
}
static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
int show= show_bits(s, n);
int r= get_xbits(s, n);
print_bin(show, n);
av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line);
return r;
}
#define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
#else //TRACE
#define tprintf(p, ...) {}
#endif
static inline int decode012(GetBitContext *gb){
int n;
n = get_bits1(gb);
if (n == 0)
return 0;
else
return get_bits1(gb) + 1;
}
static inline int decode210(GetBitContext *gb){
if (get_bits1(gb))
return 0;
else
return 2 - get_bits1(gb);
}
static inline int get_bits_left(GetBitContext *gb)
{
return gb->size_in_bits - get_bits_count(gb);
}
#endif /* AVCODEC_GET_BITS_H */

484
lib/rbcodec/codecs/lib/ffmpeg_intreadwrite.h Normal file
View file

@ -0,0 +1,484 @@
/*
* 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
*/
#ifndef AVUTIL_INTREADWRITE_H
#define AVUTIL_INTREADWRITE_H
#include <stdint.h>
/*
* Arch-specific headers can provide any combination of
* AV_[RW][BLN](16|24|32|64) and AV_(COPY|SWAP|ZERO)(64|128) macros.
* Preprocessor symbols must be defined, even if these are implemented
* as inline functions.
*/
/*
* Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers.
*/
#define HAVE_BIGENDIAN 0
#if HAVE_BIGENDIAN
# if defined(AV_RN16) && !defined(AV_RB16)
# define AV_RB16(p) AV_RN16(p)
# elif !defined(AV_RN16) && defined(AV_RB16)
# define AV_RN16(p) AV_RB16(p)
# endif
# if defined(AV_WN16) && !defined(AV_WB16)
# define AV_WB16(p, v) AV_WN16(p, v)
# elif !defined(AV_WN16) && defined(AV_WB16)
# define AV_WN16(p, v) AV_WB16(p, v)
# endif
# if defined(AV_RN24) && !defined(AV_RB24)
# define AV_RB24(p) AV_RN24(p)
# elif !defined(AV_RN24) && defined(AV_RB24)
# define AV_RN24(p) AV_RB24(p)
# endif
# if defined(AV_WN24) && !defined(AV_WB24)
# define AV_WB24(p, v) AV_WN24(p, v)
# elif !defined(AV_WN24) && defined(AV_WB24)
# define AV_WN24(p, v) AV_WB24(p, v)
# endif
# if defined(AV_RN32) && !defined(AV_RB32)
# define AV_RB32(p) AV_RN32(p)
# elif !defined(AV_RN32) && defined(AV_RB32)
# define AV_RN32(p) AV_RB32(p)
# endif
# if defined(AV_WN32) && !defined(AV_WB32)
# define AV_WB32(p, v) AV_WN32(p, v)
# elif !defined(AV_WN32) && defined(AV_WB32)
# define AV_WN32(p, v) AV_WB32(p, v)
# endif
# if defined(AV_RN64) && !defined(AV_RB64)
# define AV_RB64(p) AV_RN64(p)
# elif !defined(AV_RN64) && defined(AV_RB64)
# define AV_RN64(p) AV_RB64(p)
# endif
# if defined(AV_WN64) && !defined(AV_WB64)
# define AV_WB64(p, v) AV_WN64(p, v)
# elif !defined(AV_WN64) && defined(AV_WB64)
# define AV_WN64(p, v) AV_WB64(p, v)
# endif
#else /* HAVE_BIGENDIAN */
# if defined(AV_RN16) && !defined(AV_RL16)
# define AV_RL16(p) AV_RN16(p)
# elif !defined(AV_RN16) && defined(AV_RL16)
# define AV_RN16(p) AV_RL16(p)
# endif
# if defined(AV_WN16) && !defined(AV_WL16)
# define AV_WL16(p, v) AV_WN16(p, v)
# elif !defined(AV_WN16) && defined(AV_WL16)
# define AV_WN16(p, v) AV_WL16(p, v)
# endif
# if defined(AV_RN24) && !defined(AV_RL24)
# define AV_RL24(p) AV_RN24(p)
# elif !defined(AV_RN24) && defined(AV_RL24)
# define AV_RN24(p) AV_RL24(p)
# endif
# if defined(AV_WN24) && !defined(AV_WL24)
# define AV_WL24(p, v) AV_WN24(p, v)
# elif !defined(AV_WN24) && defined(AV_WL24)
# define AV_WN24(p, v) AV_WL24(p, v)
# endif
# if defined(AV_RN32) && !defined(AV_RL32)
# define AV_RL32(p) AV_RN32(p)
# elif !defined(AV_RN32) && defined(AV_RL32)
# define AV_RN32(p) AV_RL32(p)
# endif
# if defined(AV_WN32) && !defined(AV_WL32)
# define AV_WL32(p, v) AV_WN32(p, v)
# elif !defined(AV_WN32) && defined(AV_WL32)
# define AV_WN32(p, v) AV_WL32(p, v)
# endif
# if defined(AV_RN64) && !defined(AV_RL64)
# define AV_RL64(p) AV_RN64(p)
# elif !defined(AV_RN64) && defined(AV_RL64)
# define AV_RN64(p) AV_RL64(p)
# endif
# if defined(AV_WN64) && !defined(AV_WL64)
# define AV_WL64(p, v) AV_WN64(p, v)
# elif !defined(AV_WN64) && defined(AV_WL64)
# define AV_WN64(p, v) AV_WL64(p, v)
# endif
#endif /* !HAVE_BIGENDIAN */
#define HAVE_ATTRIBUTE_PACKED 0
#define HAVE_FAST_UNALIGNED 0
/*
* Define AV_[RW]N helper macros to simplify definitions not provided
* by per-arch headers.
*/
#if HAVE_ATTRIBUTE_PACKED
union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias;
union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias;
union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
# define AV_RN(s, p) (((const union unaligned_##s *) (p))->l)
# define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v))
#elif defined(__DECC)
# define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
# define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
#elif HAVE_FAST_UNALIGNED
# define AV_RN(s, p) (((const av_alias##s*)(p))->u##s)
# define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v))
#else
#ifndef AV_RB16
# define AV_RB16(x) \
((((const uint8_t*)(x))[0] << 8) | \
((const uint8_t*)(x))[1])
#endif
#ifndef AV_WB16
# define AV_WB16(p, d) do { \
((uint8_t*)(p))[1] = (d); \
((uint8_t*)(p))[0] = (d)>>8; \
} while(0)
#endif
#ifndef AV_RL16
# define AV_RL16(x) \
((((const uint8_t*)(x))[1] << 8) | \
((const uint8_t*)(x))[0])
#endif
#ifndef AV_WL16
# define AV_WL16(p, d) do { \
((uint8_t*)(p))[0] = (d); \
((uint8_t*)(p))[1] = (d)>>8; \
} while(0)
#endif
#ifndef AV_RB32
/* Coldfire and ARMv6 and above support unaligned long reads */
#if defined CPU_COLDFIRE || (defined CPU_ARM && ARM_ARCH >= 6)
#define AV_RB32(x) (htobe32(*(const uint32_t*)(x)))
#else
# define AV_RB32(x) \
((((const uint8_t*)(x))[0] << 24) | \
(((const uint8_t*)(x))[1] << 16) | \
(((const uint8_t*)(x))[2] << 8) | \
((const uint8_t*)(x))[3])
#endif
#endif
#ifndef AV_WB32
# define AV_WB32(p, d) do { \
((uint8_t*)(p))[3] = (d); \
((uint8_t*)(p))[2] = (d)>>8; \
((uint8_t*)(p))[1] = (d)>>16; \
((uint8_t*)(p))[0] = (d)>>24; \
} while(0)
#endif
#ifndef AV_RL32
# define AV_RL32(x) \
((((const uint8_t*)(x))[3] << 24) | \
(((const uint8_t*)(x))[2] << 16) | \
(((const uint8_t*)(x))[1] << 8) | \
((const uint8_t*)(x))[0])
#endif
#ifndef AV_WL32
# define AV_WL32(p, d) do { \
((uint8_t*)(p))[0] = (d); \
((uint8_t*)(p))[1] = (d)>>8; \
((uint8_t*)(p))[2] = (d)>>16; \
((uint8_t*)(p))[3] = (d)>>24; \
} while(0)
#endif
#ifndef AV_RB64
# define AV_RB64(x) \
(((uint64_t)((const uint8_t*)(x))[0] << 56) | \
((uint64_t)((const uint8_t*)(x))[1] << 48) | \
((uint64_t)((const uint8_t*)(x))[2] << 40) | \
((uint64_t)((const uint8_t*)(x))[3] << 32) | \
((uint64_t)((const uint8_t*)(x))[4] << 24) | \
((uint64_t)((const uint8_t*)(x))[5] << 16) | \
((uint64_t)((const uint8_t*)(x))[6] << 8) | \
(uint64_t)((const uint8_t*)(x))[7])
#endif
#ifndef AV_WB64
# define AV_WB64(p, d) do { \
((uint8_t*)(p))[7] = (d); \
((uint8_t*)(p))[6] = (d)>>8; \
((uint8_t*)(p))[5] = (d)>>16; \
((uint8_t*)(p))[4] = (d)>>24; \
((uint8_t*)(p))[3] = (d)>>32; \
((uint8_t*)(p))[2] = (d)>>40; \
((uint8_t*)(p))[1] = (d)>>48; \
((uint8_t*)(p))[0] = (d)>>56; \
} while(0)
#endif
#ifndef AV_RL64
# define AV_RL64(x) \
(((uint64_t)((const uint8_t*)(x))[7] << 56) | \
((uint64_t)((const uint8_t*)(x))[6] << 48) | \
((uint64_t)((const uint8_t*)(x))[5] << 40) | \
((uint64_t)((const uint8_t*)(x))[4] << 32) | \
((uint64_t)((const uint8_t*)(x))[3] << 24) | \
((uint64_t)((const uint8_t*)(x))[2] << 16) | \
((uint64_t)((const uint8_t*)(x))[1] << 8) | \
(uint64_t)((const uint8_t*)(x))[0])
#endif
#ifndef AV_WL64
# define AV_WL64(p, d) do { \
((uint8_t*)(p))[0] = (d); \
((uint8_t*)(p))[1] = (d)>>8; \
((uint8_t*)(p))[2] = (d)>>16; \
((uint8_t*)(p))[3] = (d)>>24; \
((uint8_t*)(p))[4] = (d)>>32; \
((uint8_t*)(p))[5] = (d)>>40; \
((uint8_t*)(p))[6] = (d)>>48; \
((uint8_t*)(p))[7] = (d)>>56; \
} while(0)
#endif
#if HAVE_BIGENDIAN
# define AV_RN(s, p) AV_RB##s(p)
# define AV_WN(s, p, v) AV_WB##s(p, v)
#else
# define AV_RN(s, p) AV_RL##s(p)
# define AV_WN(s, p, v) AV_WL##s(p, v)
#endif
#endif /* HAVE_FAST_UNALIGNED */
#ifndef AV_RN16
# define AV_RN16(p) AV_RN(16, p)
#endif
#ifndef AV_RN32
# define AV_RN32(p) AV_RN(32, p)
#endif
#ifndef AV_RN64
# define AV_RN64(p) AV_RN(64, p)
#endif
#ifndef AV_WN16
# define AV_WN16(p, v) AV_WN(16, p, v)
#endif
#ifndef AV_WN32
# define AV_WN32(p, v) AV_WN(32, p, v)
#endif
#ifndef AV_WN64
# define AV_WN64(p, v) AV_WN(64, p, v)
#endif
#if HAVE_BIGENDIAN
# define AV_RB(s, p) AV_RN##s(p)
# define AV_WB(s, p, v) AV_WN##s(p, v)
# define AV_RL(s, p) bswap_##s(AV_RN##s(p))
# define AV_WL(s, p, v) AV_WN##s(p, bswap_##s(v))
#else
# define AV_RB(s, p) bswap_##s(AV_RN##s(p))
# define AV_WB(s, p, v) AV_WN##s(p, bswap_##s(v))
# define AV_RL(s, p) AV_RN##s(p)
# define AV_WL(s, p, v) AV_WN##s(p, v)
#endif
#define AV_RB8(x) (((const uint8_t*)(x))[0])
#define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0)
#define AV_RL8(x) AV_RB8(x)
#define AV_WL8(p, d) AV_WB8(p, d)
#ifndef AV_RB16
# define AV_RB16(p) AV_RB(16, p)
#endif
#ifndef AV_WB16
# define AV_WB16(p, v) AV_WB(16, p, v)
#endif
#ifndef AV_RL16
# define AV_RL16(p) AV_RL(16, p)
#endif
#ifndef AV_WL16
# define AV_WL16(p, v) AV_WL(16, p, v)
#endif
#ifndef AV_RB32
# define AV_RB32(p) AV_RB(32, p)
#endif
#ifndef AV_WB32
# define AV_WB32(p, v) AV_WB(32, p, v)
#endif
#ifndef AV_RL32
# define AV_RL32(p) AV_RL(32, p)
#endif
#ifndef AV_WL32
# define AV_WL32(p, v) AV_WL(32, p, v)
#endif
#ifndef AV_RB64
# define AV_RB64(p) AV_RB(64, p)
#endif
#ifndef AV_WB64
# define AV_WB64(p, v) AV_WB(64, p, v)
#endif
#ifndef AV_RL64
# define AV_RL64(p) AV_RL(64, p)
#endif
#ifndef AV_WL64
# define AV_WL64(p, v) AV_WL(64, p, v)
#endif
#ifndef AV_RB24
# define AV_RB24(x) \
((((const uint8_t*)(x))[0] << 16) | \
(((const uint8_t*)(x))[1] << 8) | \
((const uint8_t*)(x))[2])
#endif
#ifndef AV_WB24
# define AV_WB24(p, d) do { \
((uint8_t*)(p))[2] = (d); \
((uint8_t*)(p))[1] = (d)>>8; \
((uint8_t*)(p))[0] = (d)>>16; \
} while(0)
#endif
#ifndef AV_RL24
# define AV_RL24(x) \
((((const uint8_t*)(x))[2] << 16) | \
(((const uint8_t*)(x))[1] << 8) | \
((const uint8_t*)(x))[0])
#endif
#ifndef AV_WL24
# define AV_WL24(p, d) do { \
((uint8_t*)(p))[0] = (d); \
((uint8_t*)(p))[1] = (d)>>8; \
((uint8_t*)(p))[2] = (d)>>16; \
} while(0)
#endif
/*
* The AV_[RW]NA macros access naturally aligned data
* in a type-safe way.
*/
#define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s)
#define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v))
#ifndef AV_RN16A
# define AV_RN16A(p) AV_RNA(16, p)
#endif
#ifndef AV_RN32A
# define AV_RN32A(p) AV_RNA(32, p)
#endif
#ifndef AV_RN64A
# define AV_RN64A(p) AV_RNA(64, p)
#endif
#ifndef AV_WN16A
# define AV_WN16A(p, v) AV_WNA(16, p, v)
#endif
#ifndef AV_WN32A
# define AV_WN32A(p, v) AV_WNA(32, p, v)
#endif
#ifndef AV_WN64A
# define AV_WN64A(p, v) AV_WNA(64, p, v)
#endif
/* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be
* naturally aligned. They may be implemented using MMX,
* so emms_c() must be called before using any float code
* afterwards.
*/
#define AV_COPY(n, d, s) \
(((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n)
#ifndef AV_COPY16
# define AV_COPY16(d, s) AV_COPY(16, d, s)
#endif
#ifndef AV_COPY32
# define AV_COPY32(d, s) AV_COPY(32, d, s)
#endif
#ifndef AV_COPY64
# define AV_COPY64(d, s) AV_COPY(64, d, s)
#endif
#ifndef AV_COPY128
# define AV_COPY128(d, s) \
do { \
AV_COPY64(d, s); \
AV_COPY64((char*)(d)+8, (char*)(s)+8); \
} while(0)
#endif
#define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b))
#ifndef AV_SWAP64
# define AV_SWAP64(a, b) AV_SWAP(64, a, b)
#endif
#define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0)
#ifndef AV_ZERO16
# define AV_ZERO16(d) AV_ZERO(16, d)
#endif
#ifndef AV_ZERO32
# define AV_ZERO32(d) AV_ZERO(32, d)
#endif
#ifndef AV_ZERO64
# define AV_ZERO64(d) AV_ZERO(64, d)
#endif
#ifndef AV_ZERO128
# define AV_ZERO128(d) \
do { \
AV_ZERO64(d); \
AV_ZERO64((char*)(d)+8); \
} while(0)
#endif
#endif /* AVUTIL_INTREADWRITE_H */

323
lib/rbcodec/codecs/lib/ffmpeg_put_bits.h Normal file
View file

@ -0,0 +1,323 @@
/*
* copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
*
* 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 libavcodec/put_bits.h
* bitstream writer API
*/
#ifndef AVCODEC_PUT_BITS_H
#define AVCODEC_PUT_BITS_H
#include <stdint.h>
#include <stdlib.h>
#include "ffmpeg_bswap.h"
#include "ffmpeg_intreadwrite.h"
#define av_log(...)
#define HAVE_FAST_UNALIGNED 0
/* buf and buf_end must be present and used by every alternative writer. */
typedef struct PutBitContext {
#ifdef ALT_BITSTREAM_WRITER
uint8_t *buf, *buf_end;
int index;
#else
uint32_t bit_buf;
int bit_left;
uint8_t *buf, *buf_ptr, *buf_end;
#endif
int size_in_bits;
} PutBitContext;
/**
* Initializes the PutBitContext s.
*
* @param buffer the buffer where to put bits
* @param buffer_size the size in bytes of buffer
*/
static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
{
if(buffer_size < 0) {
buffer_size = 0;
buffer = NULL;
}
s->size_in_bits= 8*buffer_size;
s->buf = buffer;
s->buf_end = s->buf + buffer_size;
#ifdef ALT_BITSTREAM_WRITER
s->index=0;
((uint32_t*)(s->buf))[0]=0;
// memset(buffer, 0, buffer_size);
#else
s->buf_ptr = s->buf;
s->bit_left=32;
s->bit_buf=0;
#endif
}
/**
* Returns the total number of bits written to the bitstream.
*/
static inline int put_bits_count(PutBitContext *s)
{
#ifdef ALT_BITSTREAM_WRITER
return s->index;
#else
return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
#endif
}
/**
* Pads the end of the output stream with zeros.
*/
static inline void flush_put_bits(PutBitContext *s)
{
#ifdef ALT_BITSTREAM_WRITER
align_put_bits(s);
#else
#ifndef BITSTREAM_WRITER_LE
s->bit_buf<<= s->bit_left;
#endif
while (s->bit_left < 32) {
/* XXX: should test end of buffer */
#ifdef BITSTREAM_WRITER_LE
*s->buf_ptr++=s->bit_buf;
s->bit_buf>>=8;
#else
*s->buf_ptr++=s->bit_buf >> 24;
s->bit_buf<<=8;
#endif
s->bit_left+=8;
}
s->bit_left=32;
s->bit_buf=0;
#endif
}
#if defined(ALT_BITSTREAM_WRITER) || defined(BITSTREAM_WRITER_LE)
#define align_put_bits align_put_bits_unsupported_here
#define ff_put_string ff_put_string_unsupported_here
#define ff_copy_bits ff_copy_bits_unsupported_here
#else
/**
* Pads the bitstream with zeros up to the next byte boundary.
*/
void align_put_bits(PutBitContext *s);
/**
* Puts the string string in the bitstream.
*
* @param terminate_string 0-terminates the written string if value is 1
*/
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string);
/**
* Copies the content of src to the bitstream.
*
* @param length the number of bits of src to copy
*/
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
#endif
/**
* Writes up to 31 bits into a bitstream.
* Use put_bits32 to write 32 bits.
*/
static inline void put_bits(PutBitContext *s, int n, unsigned int value)
#ifndef ALT_BITSTREAM_WRITER
{
unsigned int bit_buf;
int bit_left;
// printf("put_bits=%d %x\n", n, value);
//assert(n <= 31 && value < (1U << n));
bit_buf = s->bit_buf;
bit_left = s->bit_left;
// printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
/* XXX: optimize */
#ifdef BITSTREAM_WRITER_LE
bit_buf |= value << (32 - bit_left);
if (n >= bit_left) {
#if !HAVE_FAST_UNALIGNED
if (3 & (intptr_t) s->buf_ptr) {
AV_WL32(s->buf_ptr, bit_buf);
} else
#endif
*(uint32_t *)s->buf_ptr = le2me_32(bit_buf);
s->buf_ptr+=4;
bit_buf = (bit_left==32)?0:value >> bit_left;
bit_left+=32;
}
bit_left-=n;
#else
if (n < bit_left) {
bit_buf = (bit_buf<<n) | value;
bit_left-=n;
} else {
bit_buf<<=bit_left;
bit_buf |= value >> (n - bit_left);
#if !HAVE_FAST_UNALIGNED
if (3 & (intptr_t) s->buf_ptr) {
AV_WB32(s->buf_ptr, bit_buf);
} else
#endif
*(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
//printf("bitbuf = %08x\n", bit_buf);
s->buf_ptr+=4;
bit_left+=32 - n;
bit_buf = value;
}
#endif
s->bit_buf = bit_buf;
s->bit_left = bit_left;
}
#else /* ALT_BITSTREAM_WRITER defined */
{
# ifdef ALIGNED_BITSTREAM_WRITER
# if ARCH_X86
__asm__ volatile(
"movl %0, %%ecx \n\t"
"xorl %%eax, %%eax \n\t"
"shrdl %%cl, %1, %%eax \n\t"
"shrl %%cl, %1 \n\t"
"movl %0, %%ecx \n\t"
"shrl $3, %%ecx \n\t"
"andl $0xFFFFFFFC, %%ecx \n\t"
"bswapl %1 \n\t"
"orl %1, (%2, %%ecx) \n\t"
"bswapl %%eax \n\t"
"addl %3, %0 \n\t"
"movl %%eax, 4(%2, %%ecx) \n\t"
: "=&r" (s->index), "=&r" (value)
: "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
: "%eax", "%ecx"
);
# else
int index= s->index;
uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
value<<= 32-n;
ptr[0] |= be2me_32(value>>(index&31));
ptr[1] = be2me_32(value<<(32-(index&31)));
//if(n>24) printf("%d %d\n", n, value);
index+= n;
s->index= index;
# endif
# else //ALIGNED_BITSTREAM_WRITER
# if ARCH_X86
__asm__ volatile(
"movl $7, %%ecx \n\t"
"andl %0, %%ecx \n\t"
"addl %3, %%ecx \n\t"
"negl %%ecx \n\t"
"shll %%cl, %1 \n\t"
"bswapl %1 \n\t"
"movl %0, %%ecx \n\t"
"shrl $3, %%ecx \n\t"
"orl %1, (%%ecx, %2) \n\t"
"addl %3, %0 \n\t"
"movl $0, 4(%%ecx, %2) \n\t"
: "=&r" (s->index), "=&r" (value)
: "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
: "%ecx"
);
# else
int index= s->index;
uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
ptr[1] = 0;
//if(n>24) printf("%d %d\n", n, value);
index+= n;
s->index= index;
# endif
# endif //!ALIGNED_BITSTREAM_WRITER
}
#endif
static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
{
//assert(n >= 0 && n <= 31);
put_bits(pb, n, value & ((1<<n)-1));
}
/**
* Returns the pointer to the byte where the bitstream writer will put
* the next bit.
*/
static inline uint8_t* put_bits_ptr(PutBitContext *s)
{
#ifdef ALT_BITSTREAM_WRITER
return s->buf + (s->index>>3);
#else
return s->buf_ptr;
#endif
}
/**
* Skips the given number of bytes.
* PutBitContext must be flushed & aligned to a byte boundary before calling this.
*/
static inline void skip_put_bytes(PutBitContext *s, int n)
{
//assert((put_bits_count(s)&7)==0);
#ifdef ALT_BITSTREAM_WRITER
FIXME may need some cleaning of the buffer
s->index += n<<3;
#else
//assert(s->bit_left==32);
s->buf_ptr += n;
#endif
}
/**
* Skips the given number of bits.
* Must only be used if the actual values in the bitstream do not matter.
* If n is 0 the behavior is undefined.
*/
static inline void skip_put_bits(PutBitContext *s, int n)
{
#ifdef ALT_BITSTREAM_WRITER
s->index += n;
#else
s->bit_left -= n;
s->buf_ptr-= 4*(s->bit_left>>5);
s->bit_left &= 31;
#endif
}
/**
* Changes the end of the buffer.
*
* @param size the new size in bytes of the buffer where to put bits
*/
static inline void set_put_bits_buffer_size(PutBitContext *s, int size)
{
s->buf_end= s->buf + size;
}
#endif /* AVCODEC_PUT_BITS_H */

473
lib/rbcodec/codecs/lib/fft-ffmpeg.c Normal file
View file

@ -0,0 +1,473 @@
/*
* FFT/IFFT transforms converted to integer precision
* Copyright (c) 2010 Dave Hooper, Mohamed Tarek, Michael Giacomelli
* Copyright (c) 2008 Loren Merritt
* Copyright (c) 2002 Fabrice Bellard
* Partly based on libdjbfft by D. J. Bernstein
*
* 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 libavcodec/fft.c
* FFT/IFFT transforms.
*/
#ifdef CPU_ARM
// we definitely want CONFIG_SMALL undefined for ipod
// so we get the inlined version of fft16 (which is measurably faster)
#undef CONFIG_SMALL
#else
#undef CONFIG_SMALL
#endif
#include "fft.h"
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <inttypes.h>
#include <time.h>
#include <codecs/lib/codeclib.h>
#include "codeclib_misc.h"
#include "mdct_lookup.h"
/* constants for fft_16 (same constants as in mdct_arm.S ... ) */
#define cPI1_8 (0x7641af3d) /* cos(pi/8) s.31 */
#define cPI2_8 (0x5a82799a) /* cos(2pi/8) = 1/sqrt(2) s.31 */
#define cPI3_8 (0x30fbc54d) /* cos(3pi/8) s.31 */
/* asm-optimised functions and/or macros */
#include "fft-ffmpeg_arm.h"
#include "fft-ffmpeg_cf.h"
#ifndef ICODE_ATTR_TREMOR_MDCT
#define ICODE_ATTR_TREMOR_MDCT ICODE_ATTR
#endif
#if 0
static int split_radix_permutation(int i, int n, int inverse)
{
int m;
if(n <= 2) return i&1;
m = n >> 1;
if(!(i&m)) return split_radix_permutation(i, m, inverse)*2;
m >>= 1;
if(inverse == !(i&m)) return split_radix_permutation(i, m, inverse)*4 + 1;
else return split_radix_permutation(i, m, inverse)*4 - 1;
}
static void ff_fft_permute_c(FFTContext *s, FFTComplex *z)
{
int j, k, np;
FFTComplex tmp;
//const uint16_t *revtab = s->revtab;
np = 1 << s->nbits;
const int revtab_shift = (12 - s->nbits);
/* reverse */
for(j=0;j<np;j++) {
k = revtab[j]>>revtab_shift;
if (k < j) {
tmp = z[k];
z[k] = z[j];
z[j] = tmp;
}
}
}
#endif
#define BF(x,y,a,b) {\
x = a - b;\
y = a + b;\
}
#define BF_REV(x,y,a,b) {\
x = a + b;\
y = a - b;\
}
#ifndef FFT_FFMPEG_INCL_OPTIMISED_BUTTERFLIES
#define BUTTERFLIES(a0,a1,a2,a3) {\
{\
FFTSample temp1,temp2;\
BF(temp1, temp2, t5, t1);\
BF(a2.re, a0.re, a0.re, temp2);\
BF(a3.im, a1.im, a1.im, temp1);\
}\
{\
FFTSample temp1,temp2;\
BF(temp1, temp2, t2, t6);\
BF(a3.re, a1.re, a1.re, temp1);\
BF(a2.im, a0.im, a0.im, temp2);\
}\
}
// force loading all the inputs before storing any.
// this is slightly slower for small data, but avoids store->load aliasing
// for addresses separated by large powers of 2.
#define BUTTERFLIES_BIG(a0,a1,a2,a3) {\
FFTSample r0=a0.re, i0=a0.im, r1=a1.re, i1=a1.im;\
{\
FFTSample temp1, temp2;\
BF(temp1, temp2, t5, t1);\
BF(a2.re, a0.re, r0, temp2);\
BF(a3.im, a1.im, i1, temp1);\
}\
{\
FFTSample temp1, temp2;\
BF(temp1, temp2, t2, t6);\
BF(a3.re, a1.re, r1, temp1);\
BF(a2.im, a0.im, i0, temp2);\
}\
}
#endif
/*
see conjugate pair description in
http://www.fftw.org/newsplit.pdf
a0 = z[k]
a1 = z[k+N/4]
a2 = z[k+2N/4]
a3 = z[k+3N/4]
result:
y[k] = z[k]+w(z[k+2N/4])+w'(z[k+3N/4])
y[k+N/4] = z[k+N/4]-iw(z[k+2N/4])+iw'(z[k+3N/4])
y[k+2N/4] = z[k]-w(z[k+2N/4])-w'(z[k+3N/4])
y[k+3N/4] = z[k+N/4]+iw(z[k+2N/4])-iw'(z[k+3N/4])
i.e.
a0 = a0 + (w.a2 + w'.a3)
a1 = a1 - i(w.a2 - w'.a3)
a2 = a0 - (w.a2 + w'.a3)
a3 = a1 + i(w.a2 - w'.a3)
note re(w') = re(w) and im(w') = -im(w)
so therefore
re(a0) = re(a0) + re(w.a2) + re(w.a3)
im(a0) = im(a0) + im(w.a2) - im(w.a3) etc
and remember also that
Re([s+it][u+iv]) = su-tv
Im([s+it][u+iv]) = sv+tu
so
Re(w'.(s+it)) = Re(w').s - Im(w').t = Re(w).s + Im(w).t
Im(w'.(s+it)) = Re(w').t + Im(w').s = Re(w).t - Im(w).s
For inverse dft we take the complex conjugate of all twiddle factors.
Hence
a0 = a0 + (w'.a2 + w.a3)
a1 = a1 - i(w'.a2 - w.a3)
a2 = a0 - (w'.a2 + w.a3)
a3 = a1 + i(w'.a2 - w.a3)
Define t1 = Re(w'.a2) = Re(w)*Re(a2) + Im(w)*Im(a2)
t2 = Im(w'.a2) = Re(w)*Im(a2) - Im(w)*Re(a2)
t5 = Re(w.a3) = Re(w)*Re(a3) - Im(w)*Im(a3)
t6 = Im(w.a3) = Re(w)*Im(a3) + Im(w)*Re(a3)
Then we just output:
a0.re = a0.re + ( t1 + t5 )
a0.im = a0.im + ( t2 + t6 )
a1.re = a1.re + ( t2 - t6 ) // since we multiply by -i and i(-i) = 1
a1.im = a1.im - ( t1 - t5 ) // since we multiply by -i and 1(-i) = -i
a2.re = a0.re - ( t1 + t5 )
a2.im = a0.im - ( t1 + t5 )
a3.re = a1.re - ( t2 - t6 ) // since we multiply by +i and i(+i) = -1
a3.im = a1.im + ( t1 - t5 ) // since we multiply by +i and 1(+i) = i
*/
#ifndef FFT_FFMPEG_INCL_OPTIMISED_TRANSFORM
static inline FFTComplex* TRANSFORM(FFTComplex * z, unsigned int n, FFTSample wre, FFTSample wim)
{
register FFTSample t1,t2,t5,t6,r_re,r_im;
r_re = z[n*2].re;
r_im = z[n*2].im;
XPROD31_R(r_re, r_im, wre, wim, t1,t2);
r_re = z[n*3].re;
r_im = z[n*3].im;
XNPROD31_R(r_re, r_im, wre, wim, t5,t6);
BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]);
return z+1;
}
static inline FFTComplex* TRANSFORM_W01(FFTComplex * z, unsigned int n, const FFTSample * w)
{
register const FFTSample wre=w[0],wim=w[1];
register FFTSample t1,t2,t5,t6,r_re,r_im;
r_re = z[n*2].re;
r_im = z[n*2].im;
XPROD31_R(r_re, r_im, wre, wim, t1,t2);
r_re = z[n*3].re;
r_im = z[n*3].im;
XNPROD31_R(r_re, r_im, wre, wim, t5,t6);
BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]);
return z+1;
}
static inline FFTComplex* TRANSFORM_W10(FFTComplex * z, unsigned int n, const FFTSample * w)
{
register const FFTSample wim=w[0],wre=w[1];
register FFTSample t1,t2,t5,t6,r_re,r_im;
r_re = z[n*2].re;
r_im = z[n*2].im;
XPROD31_R(r_re, r_im, wre, wim, t1,t2);
r_re = z[n*3].re;
r_im = z[n*3].im;
XNPROD31_R(r_re, r_im, wre, wim, t5,t6);
BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]);
return z+1;
}
static inline FFTComplex* TRANSFORM_EQUAL(FFTComplex * z, unsigned int n)
{
register FFTSample t1,t2,t5,t6,temp1,temp2;
register FFTSample * my_z = (FFTSample *)(z);
my_z += n*4;
t2 = MULT31(my_z[0], cPI2_8);
temp1 = MULT31(my_z[1], cPI2_8);
my_z += n*2;
temp2 = MULT31(my_z[0], cPI2_8);
t5 = MULT31(my_z[1], cPI2_8);
t1 = ( temp1 + t2 );
t2 = ( temp1 - t2 );
t6 = ( temp2 + t5 );
t5 = ( temp2 - t5 );
my_z -= n*6;
BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]);
return z+1;
}
static inline FFTComplex* TRANSFORM_ZERO(FFTComplex * z, unsigned int n)
{
FFTSample t1,t2,t5,t6;
t1 = z[n*2].re;
t2 = z[n*2].im;
t5 = z[n*3].re;
t6 = z[n*3].im;
BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]);
return z+1;
}
#endif
/* z[0...8n-1], w[1...2n-1] */
static void pass(FFTComplex *z_arg, unsigned int STEP_arg, unsigned int n_arg) ICODE_ATTR_TREMOR_MDCT;
static void pass(FFTComplex *z_arg, unsigned int STEP_arg, unsigned int n_arg)
{
register FFTComplex * z = z_arg;
register unsigned int STEP = STEP_arg;
register unsigned int n = n_arg;
register const FFTSample *w = sincos_lookup0+STEP;
/* wre = *(wim+1) . ordering is sin,cos */
register const FFTSample *w_end = sincos_lookup0+1024;
/* first two are special (well, first one is special, but we need to do pairs) */
z = TRANSFORM_ZERO(z,n);
z = TRANSFORM_W10(z,n,w);
w += STEP;
/* first pass forwards through sincos_lookup0*/
do {
z = TRANSFORM_W10(z,n,w);
w += STEP;
z = TRANSFORM_W10(z,n,w);
w += STEP;
} while(LIKELY(w < w_end));
/* second half: pass backwards through sincos_lookup0*/
/* wim and wre are now in opposite places so ordering now [0],[1] */
w_end=sincos_lookup0;
while(LIKELY(w>w_end))
{
z = TRANSFORM_W01(z,n,w);
w -= STEP;
z = TRANSFORM_W01(z,n,w);
w -= STEP;
}
}
/* what is STEP?
sincos_lookup0 has sin,cos pairs for 1/4 cycle, in 1024 points
so half cycle would be 2048 points
ff_cos_16 has 8 elements corresponding to 4 cos points and 4 sin points
so each of the 4 points pairs corresponds to a 256*2-byte jump in sincos_lookup0
8192/16 (from "ff_cos_16") is 512 bytes.
i.e. for fft16, STEP = 8192/16 */
#define DECL_FFT(n,n2,n4)\
static void fft##n(FFTComplex *z) ICODE_ATTR_TREMOR_MDCT;\
static void fft##n(FFTComplex *z)\
{\
fft##n2(z);\
fft##n4(z+n4*2);\
fft##n4(z+n4*3);\
pass(z,8192/n,n4);\
}
#ifndef FFT_FFMPEG_INCL_OPTIMISED_FFT4
static inline void fft4(FFTComplex *z)
{
FFTSample t1, t2, t3, t4, t5, t6, t7, t8;
BF(t3, t1, z[0].re, z[1].re); // t3=r1-r3 ; t1 = r1+r3
BF(t8, t6, z[3].re, z[2].re); // t8=r7-r5 ; t6 = r7+r5
BF(z[2].re, z[0].re, t1, t6); // r5=t1-t6 ; r1 = t1+t6
BF(t4, t2, z[0].im, z[1].im); // t4=r2-r4 ; t2 = r2+r4
BF(t7, t5, z[2].im, z[3].im); // t7=r6-r8 ; t5 = r6+r8
BF(z[3].im, z[1].im, t4, t8); // r8=t4-t8 ; r4 = t4+t8
BF(z[3].re, z[1].re, t3, t7); // r7=t3-t7 ; r3 = t3+t7
BF(z[2].im, z[0].im, t2, t5); // r6=t2-t5 ; r2 = t2+t5
}
#endif
static void fft4_dispatch(FFTComplex *z)
{
fft4(z);
}
#ifndef FFT_FFMPEG_INCL_OPTIMISED_FFT8
static inline void fft8(FFTComplex *z)
{
fft4(z);
FFTSample t1,t2,t3,t4,t7,t8;
BF(t1, z[5].re, z[4].re, -z[5].re);
BF(t2, z[5].im, z[4].im, -z[5].im);
BF(t3, z[7].re, z[6].re, -z[7].re);
BF(t4, z[7].im, z[6].im, -z[7].im);
BF(t8, t1, t3, t1);
BF(t7, t2, t2, t4);
BF(z[4].re, z[0].re, z[0].re, t1);
BF(z[4].im, z[0].im, z[0].im, t2);
BF(z[6].re, z[2].re, z[2].re, t7);
BF(z[6].im, z[2].im, z[2].im, t8);
z++;
TRANSFORM_EQUAL(z,2);
}
#endif
static void fft8_dispatch(FFTComplex *z)
{
fft8(z);
}
#ifndef CONFIG_SMALL
static void fft16(FFTComplex *z) ICODE_ATTR_TREMOR_MDCT;
static void fft16(FFTComplex *z)
{
fft8(z);
fft4(z+8);
fft4(z+12);
TRANSFORM_ZERO(z,4);
z+=2;
TRANSFORM_EQUAL(z,4);
z-=1;
TRANSFORM(z,4,cPI1_8,cPI3_8);
z+=2;
TRANSFORM(z,4,cPI3_8,cPI1_8);
}
#else
DECL_FFT(16,8,4)
#endif
DECL_FFT(32,16,8)
DECL_FFT(64,32,16)
DECL_FFT(128,64,32)
DECL_FFT(256,128,64)
DECL_FFT(512,256,128)
DECL_FFT(1024,512,256)
DECL_FFT(2048,1024,512)
DECL_FFT(4096,2048,1024)
static void (*fft_dispatch[])(FFTComplex*) = {
fft4_dispatch, fft8_dispatch, fft16, fft32, fft64, fft128, fft256, fft512, fft1024,
fft2048, fft4096
};
void ff_fft_calc_c(int nbits, FFTComplex *z)
{
fft_dispatch[nbits-2](z);
}
#if 0
int main (void)
{
#define PRECISION 16
#define FFT_SIZE 1024
#define ftofix32(x) ((fixed32)((x) * (float)(1 << PRECISION) + ((x) < 0 ? -0.5 : 0.5)))
#define itofix32(x) ((x) << PRECISION)
#define fixtoi32(x) ((x) >> PRECISION)
int j;
const long N = FFT_SIZE;
double r[FFT_SIZE] = {0.0}, i[FFT_SIZE] = {0.0};
long n;
double t;
double amp, phase;
clock_t start, end;
double exec_time = 0;
FFTContext s;
FFTComplex z[FFT_SIZE];
memset(z, 0, 64*sizeof(FFTComplex));
/* Generate saw-tooth test data */
for (n = 0; n < FFT_SIZE; n++)
{
t = (2 * M_PI * n)/N;
/*z[n].re = 1.1 + sin( t) +
0.5 * sin(2.0 * t) +
(1.0/3.0) * sin(3.0 * t) +
0.25 * sin(4.0 * t) +
0.2 * sin(5.0 * t) +
(1.0/6.0) * sin(6.0 * t) +
(1.0/7.0) * sin(7.0 * t) ;*/
z[n].re = ftofix32(cos(2*M_PI*n/64));
//printf("z[%d] = %f\n", n, z[n].re);
//getchar();
}
ff_fft_init(&s, 10, 1);
//start = clock();
//for(n = 0; n < 1000000; n++)
ff_fft_permute_c(&s, z);
ff_fft_calc_c(&s, z);
//end = clock();
//exec_time = (((double)end-(double)start)/CLOCKS_PER_SEC);
for(j = 0; j < FFT_SIZE; j++)
{
printf("%8.4f\n", sqrt(pow(fixtof32(z[j].re),2)+ pow(fixtof32(z[j].im), 2)));
//getchar();
}
printf("muls = %d, adds = %d\n", muls, adds);
//printf(" Time elapsed = %f\n", exec_time);
//ff_fft_end(&s);
}
#endif

456
lib/rbcodec/codecs/lib/fft-ffmpeg_arm.h Normal file
View file

@ -0,0 +1,456 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2010 Dave Hooper
*
* ARM optimisations for ffmpeg's fft (used in fft-ffmpeg.c)
*
* 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.
*
****************************************************************************/
#ifdef CPU_ARM
/* Start off with optimised variants of the butterflies that work
nicely on arm */
/* 1. where y and a share the same variable/register */
#define BF_OPT(x,y,a,b) {\
y = a + b;\
x = y - (b<<1);\
}
/* 2. where y and b share the same variable/register */
#define BF_OPT2(x,y,a,b) {\
x = a - b;\
y = x + (b<<1);\
}
/* 3. where y and b share the same variable/register (but y=(-b)) */
#define BF_OPT2_REV(x,y,a,b) {\
x = a + b;\
y = x - (b<<1);\
}
/* standard BUTTERFLIES package. Note, we actually manually inline this
in all the TRANSFORM macros below anyway */
#define FFT_FFMPEG_INCL_OPTIMISED_BUTTERFLIES
#define BUTTERFLIES(a0,a1,a2,a3) {\
{\
BF_OPT(t1, t5, t5, t1);\
BF_OPT(t6, t2, t2, t6);\
BF_OPT(a2.re, a0.re, a0.re, t5);\
BF_OPT(a2.im, a0.im, a0.im, t2);\
BF_OPT(a3.re, a1.re, a1.re, t6);\
BF_OPT(a3.im, a1.im, a1.im, t1);\
}\
}
#define FFT_FFMPEG_INCL_OPTIMISED_TRANSFORM
static inline FFTComplex* TRANSFORM( FFTComplex* z, int n, FFTSample wre, FFTSample wim )
{
register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9");
z += n*2; /* z[o2] */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
XPROD31_R(r_re, r_im, wre, wim, t1,t2);
z += n; /* z[o3] */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
XNPROD31_R(r_re, r_im, wre, wim, t5,t6);
BF_OPT(t1, t5, t5, t1);
BF_OPT(t6, t2, t2, t6);
{
register FFTSample rt0temp asm("r4");
/*{*/
/* BF_OPT(t1, t5, t5, t1);*/
/* BF_OPT(t6, t2, t2, t6);*/
/* BF_OPT(a2.re, a0.re, a0.re, t5);*/
/* BF_OPT(a2.im, a0.im, a0.im, t2);*/
/* BF_OPT(a3.re, a1.re, a1.re, t6);*/
/* BF_OPT(a3.im, a1.im, a1.im, t1);*/
/*}*/
z -= n*3;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(rt0temp, r_re, r_re, t5);
BF_OPT(t2, r_im, r_im, t2);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory" );
z += n;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(t5, r_re, r_re, t6);
BF_OPT(t6, r_im, r_im, t1);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* my_z[0] = rt0temp; my_z[1] = t2; */
asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory");
}
z += n;
/* my_z[0] = t5; my_z[1] = t6; */
asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory");
z -= n*3;
return(z);
}
static inline FFTComplex* TRANSFORM_W01( FFTComplex* z, int n, const FFTSample* w )
{
register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9");
/* load wre,wim into t5,t6 */
asm volatile( "ldmia %[w], {%[wre], %[wim]}\n\t":[wre] "=r" (t5), [wim] "=r" (t6):[w] "r" (w));
z += n*2; /* z[o2] -- 2n * 2 since complex numbers */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
XPROD31_R(r_re, r_im, t5 /*wre*/, t6 /*wim*/, t1,t2);
z += n; /* z[o3] */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
XNPROD31_R(r_re, r_im, t5 /*wre*/, t6 /*wim*/, t5,t6);
BF_OPT(t1, t5, t5, t1);
BF_OPT(t6, t2, t2, t6);
{
register FFTSample rt0temp asm("r4");
/*{*/
/* BF_OPT(t1, t5, t5, t1);*/
/* BF_OPT(t6, t2, t2, t6);*/
/* BF_OPT(a2.re, a0.re, a0.re, t5);*/
/* BF_OPT(a2.im, a0.im, a0.im, t2);*/
/* BF_OPT(a3.re, a1.re, a1.re, t6);*/
/* BF_OPT(a3.im, a1.im, a1.im, t1);*/
/*}*/
z -= n*3;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(rt0temp, r_re, r_re, t5);
BF_OPT(t2, r_im, r_im, t2);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(t5, r_re, r_re, t6);
BF_OPT(t6, r_im, r_im, t1);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* my_z[0] = rt0temp; my_z[1] = t2; */
asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory");
}
z += n;
/* my_z[0] = t5; my_z[1] = t6; */
asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory");
z -= n*3;
return(z);
}
static inline FFTComplex* TRANSFORM_W10( FFTComplex* z, int n, const FFTSample* w )
{
register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9");
/* load wim,wre into t5,t6 */
asm volatile( "ldmia %[w], {%[wim], %[wre]}\n\t":[wim] "=r" (t5), [wre] "=r" (t6):[w] "r" (w));
z += n*2; /* z[o2] -- 2n * 2 since complex numbers */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
XPROD31_R(r_re, r_im, t6 /*wim*/, t5 /*wre*/, t1,t2);
z += n; /* z[o3] */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
XNPROD31_R(r_re, r_im, t6 /*wim*/, t5 /*wre*/, t5,t6);
BF_OPT(t1, t5, t5, t1);
BF_OPT(t6, t2, t2, t6);
{
register FFTSample rt0temp asm("r4");
/*{*/
/* BF_OPT(t1, t5, t5, t1);*/
/* BF_OPT(t6, t2, t2, t6);*/
/* BF_OPT(a2.re, a0.re, a0.re, t5);*/
/* BF_OPT(a2.im, a0.im, a0.im, t2);*/
/* BF_OPT(a3.re, a1.re, a1.re, t6);*/
/* BF_OPT(a3.im, a1.im, a1.im, t1);*/
/*}*/
z -= n*3;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(rt0temp, r_re, r_re, t5);
BF_OPT(t2, r_im, r_im, t2);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(t5, r_re, r_re, t6);
BF_OPT(t6, r_im, r_im, t1);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* my_z[0] = rt0temp; my_z[1] = t2; */
asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory");
}
z += n;
/* my_z[0] = t5; my_z[1] = t6; */
asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory");
z -= n*3;
return(z);
}
static inline FFTComplex* TRANSFORM_EQUAL( FFTComplex* z, int n )
{
register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9");
z += n*2; /* z[o2] -- 2n * 2 since complex numbers */
asm volatile( "ldmia %[my_z], {%[t5],%[t6]}\n\t":[t5] "=r" (t5), [t6] "=r" (t6):[my_z] "r" (z));
z += n; /* z[o3] */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
/**/
/*t2 = MULT32(cPI2_8, t5);*/
/*t1 = MULT31(cPI2_8, t6);*/
/*t6 = MULT31(cPI2_8, r_re);*/
/*t5 = MULT32(cPI2_8, r_im);*/
/*t1 = ( t1 + (t2<<1) );*/
/*t2 = ( t1 - (t2<<2) );*/
/*t6 = ( t6 + (t5<<1) );*/
/*t5 = ( t6 - (t5<<2) );*/
/**/
t2 = MULT31(cPI2_8, t5);
t6 = MULT31(cPI2_8, t6);
r_re = MULT31(cPI2_8, r_re);
t5 = MULT31(cPI2_8, r_im);
t1 = ( t6 + t2 );
t2 = ( t6 - t2 );
t6 = ( r_re + t5 );
t5 = ( r_re - t5 );
BF_OPT(t1, t5, t5, t1);
BF_OPT(t6, t2, t2, t6);
{
register FFTSample rt0temp asm("r4");
/*{*/
/* BF_OPT(t1, t5, t5, t1);*/
/* BF_OPT(t6, t2, t2, t6);*/
/* BF_OPT(a2.re, a0.re, a0.re, t5);*/
/* BF_OPT(a2.im, a0.im, a0.im, t2);*/
/* BF_OPT(a3.re, a1.re, a1.re, t6);*/
/* BF_OPT(a3.im, a1.im, a1.im, t1);*/
/*}*/
z -= n*3;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(rt0temp, r_re, r_re, t5);
BF_OPT(t2, r_im, r_im, t2);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(t5, r_re, r_re, t6);
BF_OPT(t6, r_im, r_im, t1);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* my_z[0] = rt0temp; my_z[1] = t2; */
asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory");
}
z += n;
/* my_z[0] = t5; my_z[1] = t6; */
asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory");
z -= n*3;
return(z);
}
static inline FFTComplex* TRANSFORM_ZERO( FFTComplex* z, int n )
{
register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"), r_re asm("r8"), r_im asm("r9");
z += n*2; /* z[o2] -- 2n * 2 since complex numbers */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
z += n; /* z[o3] */
asm volatile( "ldmia %[my_z], {%[t5],%[t6]}\n\t":[t5] "=r" (t5), [t6] "=r" (t6):[my_z] "r" (z));
BF_OPT(t1, t5, t5, r_re);
BF_OPT(t6, t2, r_im, t6);
{
register FFTSample rt0temp asm("r4");
/*{*/
/* BF_OPT(t1, t5, t5, t1);*/
/* BF_OPT(t6, t2, t2, t6);*/
/* BF_OPT(a2.re, a0.re, a0.re, t5);*/
/* BF_OPT(a2.im, a0.im, a0.im, t2);*/
/* BF_OPT(a3.re, a1.re, a1.re, t6);*/
/* BF_OPT(a3.im, a1.im, a1.im, t1);*/
/*}*/
z -= n*3;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(rt0temp, r_re, r_re, t5);
BF_OPT(t2, r_im, r_im, t2);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* r_re = my_z[0]; r_im = my_z[1]; */
asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z));
BF_OPT(t5, r_re, r_re, t6);
BF_OPT(t6, r_im, r_im, t1);
/* my_z[0] = r_re; my_z[1] = r_im; */
asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory");
z += n;
/* my_z[0] = rt0temp; my_z[1] = t2; */
asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory");
}
z += n;
/* my_z[0] = t5; my_z[1] = t6; */
asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory");
z -= n*3;
return(z);
}
#define FFT_FFMPEG_INCL_OPTIMISED_FFT4
static inline FFTComplex* fft4(FFTComplex * z)
{
FFTSample temp;
/* input[0..7] -> output[0..7] */
/* load r1=z[0],r2=z[1],...,r8=z[7] */
asm volatile(
"ldmia %[z], {r1-r8}\n\t"
"add r1,r1,r3\n\t" /* r1 :=t1 */
"sub r3,r1,r3, lsl #1\n\t" /* r3 :=t3 */
"sub r7,r7,r5\n\t" /* r10:=t8 */
"add r5,r7,r5, lsl #1\n\t" /* r5 :=t6 */
"add r1,r1,r5\n\t" /* r1 = o[0] */
"sub r5,r1,r5, lsl #1\n\t" /* r5 = o[4] */
"add r2,r2,r4\n\t" /* r2 :=t2 */
"sub r4,r2,r4, lsl #1\n\t" /* r9 :=t4 */
"add %[temp],r6,r8\n\t" /* r10:=t5 */
"sub r6,r6,r8\n\t" /* r6 :=t7 */
"sub r8,r4,r7\n\t" /* r8 = o[7]*/
"add r4,r4,r7\n\t" /* r4 = o[3]*/
"sub r7,r3,r6\n\t" /* r7 = o[6]*/
"add r3,r3,r6\n\t" /* r3 = o[2]*/
"sub r6,r2,%[temp]\n\t" /* r6 = o[5]*/
"add r2,r2,%[temp]\n\t" /* r2 = o[1]*/
"stmia %[z]!, {r1-r8}\n\t"
: /* outputs */ [z] "+r" (z), [temp] "=r" (temp)
: /* inputs */
: /* clobbers */
"r1","r2","r3","r4","r5","r6","r7","r8","memory"
);
return z;
}
#define FFT_FFMPEG_INCL_OPTIMISED_FFT8
/* The chunk of asm below is equivalent to the following:
// first load in z[4].re thru z[7].im into local registers
// ...
BF_OPT2_REV(z[4].re, z[5].re, z[4].re, z[5].re); // x=a+b; y=x-(b<<1)
BF_OPT2_REV(z[4].im, z[5].im, z[4].im, z[5].im);
BF_REV (temp, z[7].re, z[6].re, z[7].re); // x=a+b; y=a-b;
BF_REV (z[6].re, z[7].im, z[6].im, z[7].im);
// save z[7].re and z[7].im as those are complete now
// z[5].re and z[5].im are also complete now but save these later on
BF(z[6].im, z[4].re, temp, z[4].re); // x=a-b; y=a+b
BF_OPT(z[6].re, z[4].im, z[4].im, z[6].re); // y=a+b; x=y-(b<<1)
// now load z[2].re and z[2].im
// ...
BF_OPT(z[6].re, z[2].re, z[2].re, z[6].re); // y=a+b; x=y-(b<<1)
BF_OPT(z[6].im, z[2].im, z[2].im, z[6].im); // y=a+b; x=y-(b<<1)
// Now save z[6].re and z[6].im, along with z[5].re and z[5].im
// for efficiency. Also save z[2].re and z[2].im.
// Now load z[0].re and z[0].im
// ...
BF_OPT(z[4].re, z[0].re, z[0].re, z[4].re); // y=a+b; x=y-(b<<1)
BF_OPT(z[4].im, z[0].im, z[0].im, z[4].im); // y=a+b; x=y-(b<<1)
// Finally save out z[4].re, z[4].im, z[0].re and z[0].im
// ...
*/
static inline void fft8(FFTComplex * z)
{
FFTComplex* m4 = fft4(z);
{
/* note that we increment z_ptr on the final stmia, which
leaves z_ptr pointing to z[1].re ready for the Transform step */
register FFTSample temp;
asm volatile(
/* read in z[4].re thru z[7].im */
"ldmia %[z4_ptr]!, {r1-r8}\n\t"
/* (now points one word past &z[7].im) */
"add r1,r1,r3\n\t"
"sub r3,r1,r3,lsl #1\n\t"
"add r2,r2,r4\n\t"
"sub r4,r2,r4,lsl #1\n\t"
"add %[temp],r5,r7\n\t"
"sub r7,r5,r7\n\t"
"add r5,r6,r8\n\t"
"sub r8,r6,r8\n\t"
"stmdb %[z4_ptr]!, {r7,r8}\n\t" /* write z[7].re,z[7].im straight away */
/* Note, registers r7 & r8 now free */
"sub r6,%[temp],r1\n\t"
"add r1,%[temp],r1\n\t"
"add r2,r2,r5\n\t"
"sub r5,r2,r5,lsl #1\n\t"
"add %[temp], %[z_ptr], #16\n\t" /* point to &z[2].re */
"ldmia %[temp],{r7,r8}\n\t" /* load z[2].re and z[2].im */
"add r7,r7,r5\n\t"
"sub r5,r7,r5,lsl #1\n\t"
"add r8,r8,r6\n\t"
"sub r6,r8,r6,lsl #1\n\t"
/* write out z[5].re, z[5].im, z[6].re, z[6].im in one go*/
"stmdb %[z4_ptr]!, {r3-r6}\n\t"
"stmia %[temp],{r7,r8}\n\t" /* write out z[2].re, z[2].im */
"ldmia %[z_ptr],{r7,r8}\n\t" /* load r[0].re, r[0].im */
"add r7,r7,r1\n\t"
"sub r1,r7,r1,lsl #1\n\t"
"add r8,r8,r2\n\t"
"sub r2,r8,r2,lsl #1\n\t"
"stmia %[z_ptr]!,{r7,r8}\n\t" /* write out z[0].re, z[0].im */
"stmdb %[z4_ptr], {r1,r2}\n\t" /* write out z[4].re, z[4].im */
: [z4_ptr] "+r" (m4), [temp] "=r" (temp), [z_ptr] "+r" (z)
:
: "r1","r2","r3","r4","r5","r6","r7","r8","memory"
);
}
TRANSFORM_EQUAL(z,2);
}
#endif // CPU_ARM

370
lib/rbcodec/codecs/lib/fft-ffmpeg_cf.h Normal file
View file

@ -0,0 +1,370 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2010 Nils Wallménius
*
* Coldfire v2 optimisations for ffmpeg's fft (used in fft-ffmpeg.c)
*
* 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.
*
****************************************************************************/
#ifdef CPU_COLDFIRE
#define FFT_FFMPEG_INCL_OPTIMISED_FFT4
static inline void fft4(FFTComplex * z)
{
asm volatile ("movem.l (%[z]), %%d0-%%d7\n\t"
"move.l %%d0, %%a0\n\t"
"add.l %%d2, %%d0\n\t" /* d0 == t1 */
"neg.l %%d2\n\t"
"add.l %%a0, %%d2\n\t" /* d2 == t3, a0 free */
"move.l %%d6, %%a0\n\t"
"sub.l %%d4, %%d6\n\t" /* d6 == t8 */
"add.l %%d4, %%a0\n\t" /* a0 == t6 */
"move.l %%d0, %%d4\n\t"
"sub.l %%a0, %%d4\n\t" /* z[2].re done */
"add.l %%a0, %%d0\n\t" /* z[0].re done, a0 free */
"move.l %%d5, %%a0\n\t"
"sub.l %%d7, %%d5\n\t" /* d5 == t7 */
"add.l %%d7, %%a0\n\t" /* a0 == t5 */
"move.l %%d1, %%d7\n\t"
"sub.l %%d3, %%d7\n\t" /* d7 == t4 */
"add.l %%d3, %%d1\n\t" /* d1 == t2 */
"move.l %%d7, %%d3\n\t"
"sub.l %%d6, %%d7\n\t" /* z[3].im done */
"add.l %%d6, %%d3\n\t" /* z[1].im done */
"move.l %%d2, %%d6\n\t"
"sub.l %%d5, %%d6\n\t" /* z[3].re done */
"add.l %%d5, %%d2\n\t" /* z[1].re done */
"move.l %%d1, %%d5\n\t"
"sub.l %%a0, %%d5\n\t" /* z[2].im done */
"add.l %%a0, %%d1\n\t" /* z[0].im done */
"movem.l %%d0-%%d7, (%[z])\n\t"
: :[z] "a" (z)
: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"a0", "cc", "memory");
}
#define FFT_FFMPEG_INCL_OPTIMISED_FFT8
static inline void fft8(FFTComplex *z)
{
asm volatile ("movem.l (4*8, %[z]), %%d0-%%d7\n\t"
"move.l %%d0, %%a1\n\t"
"add.l %%d2, %%a1\n\t" /* a1 == t1 */
"sub.l %%d2, %%d0\n\t" /* d0 == z[5].re */
"move.l %%d1, %%a2\n\t"
"add.l %%d3, %%a2\n\t" /* a2 == t2 */
"sub.l %%d3, %%d1\n\t" /* d1 == z[5].im */
"move.l %%d4, %%d2\n\t"
"add.l %%d6, %%d2\n\t" /* d2 == t3 */
"sub.l %%d6, %%d4\n\t" /* d4 == z[7].re */
"move.l %%d5, %%d3\n\t"
"add.l %%d7, %%d3\n\t" /* d3 == t4 */
"sub.l %%d7, %%d5\n\t" /* d5 == z[7].im */
"move.l %%d2, %%a4\n\t"
"sub.l %%a1, %%a4\n\t" /* a4 == t8 */
"add.l %%d2, %%a1\n\t" /* a1 == t1, d2 free */
"move.l %%a2, %%a3\n\t"
"sub.l %%d3, %%a3\n\t" /* a3 == t7 */
"add.l %%d3, %%a2\n\t" /* a2 == t2, d3 free */
/* emac block from TRANSFORM_EQUAL, do this now
so we don't need to store and load z[5] and z[7] */
"move.l %[_cPI2_8], %%d2\n\t"
"mac.l %%d2, %%d0, %%acc0\n\t"
"mac.l %%d2, %%d1, %%acc1\n\t"
"mac.l %%d2, %%d4, %%acc2\n\t"
"mac.l %%d2, %%d5, %%acc3\n\t"
/* fft4, clobbers all d regs and a0 */
"movem.l (%[z]), %%d0-%%d7\n\t"
"move.l %%d0, %%a0\n\t"
"add.l %%d2, %%d0\n\t" /* d0 == t1 */
"neg.l %%d2\n\t"
"add.l %%a0, %%d2\n\t" /* d2 == t3, a0 free */
"move.l %%d6, %%a0\n\t"
"sub.l %%d4, %%d6\n\t" /* d6 == t8 */
"add.l %%d4, %%a0\n\t" /* a0 == t6 */
"move.l %%d0, %%d4\n\t"
"sub.l %%a0, %%d4\n\t" /* z[2].re done */
"add.l %%a0, %%d0\n\t" /* z[0].re done, a0 free */
"move.l %%d5, %%a0\n\t"
"sub.l %%d7, %%d5\n\t" /* d5 == t7 */
"add.l %%d7, %%a0\n\t" /* a0 == t5 */
"move.l %%d1, %%d7\n\t"
"sub.l %%d3, %%d7\n\t" /* d7 == t4 */
"add.l %%d3, %%d1\n\t" /* d1 == t2 */
"move.l %%d7, %%d3\n\t"
"sub.l %%d6, %%d7\n\t" /* z[3].im done */
"add.l %%d6, %%d3\n\t" /* z[1].im done */
"move.l %%d2, %%d6\n\t"
"sub.l %%d5, %%d6\n\t" /* z[3].re done */
"add.l %%d5, %%d2\n\t" /* z[1].re done */
"move.l %%d1, %%d5\n\t"
"sub.l %%a0, %%d5\n\t" /* z[2].im done */
"add.l %%a0, %%d1\n\t" /* z[0].im done */
/* end of fft4, but don't store yet */
"move.l %%d0, %%a0\n\t"
"add.l %%a1, %%d0\n\t"
"sub.l %%a1, %%a0\n\t" /* z[4].re, z[0].re done, a1 free */
"move.l %%d1, %%a1\n\t"
"add.l %%a2, %%d1\n\t"
"sub.l %%a2, %%a1\n\t" /* z[4].im, z[0].im done, a2 free */
"move.l %%d4, %%a2\n\t"
"add.l %%a3, %%d4\n\t"
"sub.l %%a3, %%a2\n\t" /* z[6].re, z[2].re done, a3 free */
"move.l %%d5, %%a3\n\t"
"add.l %%a4, %%d5\n\t"
"sub.l %%a4, %%a3\n\t" /* z[6].im, z[2].im done, a4 free */
"movem.l %%d0-%%d1, (%[z])\n\t" /* save z[0] */
"movem.l %%d4-%%d5, (2*8, %[z])\n\t" /* save z[2] */
"movem.l %%a0-%%a1, (4*8, %[z])\n\t" /* save z[4] */
"movem.l %%a2-%%a3, (6*8, %[z])\n\t" /* save z[6] */
/* TRANSFORM_EQUAL */
"movclr.l %%acc0, %%d0\n\t"
"movclr.l %%acc1, %%d1\n\t"
"movclr.l %%acc2, %%d4\n\t"
"movclr.l %%acc3, %%d5\n\t"
"move.l %%d1, %%a0\n\t"
"add.l %%d0, %%a0\n\t" /* a0 == t1 */
"sub.l %%d0, %%d1\n\t" /* d1 == t2 */
"move.l %%d4, %%d0\n\t"
"add.l %%d5, %%d0\n\t" /* d0 == t6 */
"sub.l %%d5, %%d4\n\t" /* d4 == t5 */
"move.l %%d4, %%a1\n\t"
"sub.l %%a0, %%a1\n\t" /* a1 == temp1 */
"add.l %%a0, %%d4\n\t" /* d4 == temp2 */
"move.l %%d2, %%a2\n\t"
"sub.l %%d4, %%a2\n\t" /* a2 == z[5].re */
"add.l %%d4, %%d2\n\t" /* z[1].re done */
"move.l %%d7, %%d5\n\t"
"sub.l %%a1, %%d5\n\t" /* d5 == z[7].im */
"add.l %%a1, %%d7\n\t" /* z[3].im done */
"move.l %%d1, %%a0\n\t"
"sub.l %%d0, %%a0\n\t" /* a0 == temp1 */
"add.l %%d0, %%d1\n\t" /* d1 == temp2 */
"move.l %%d6, %%d4\n\t"
"sub.l %%a0, %%d4\n\t" /* d4 == z[7].re */
"add.l %%a0, %%d6\n\t" /* z[3].re done */
"move.l %%d3, %%a3\n\t"
"sub.l %%d1, %%a3\n\t" /* a3 == z[5].im */
"add.l %%d1, %%d3\n\t" /* z[1].im done */
"movem.l %%d2-%%d3, (1*8, %[z])\n\t" /* save z[1] */
"movem.l %%d6-%%d7, (3*8, %[z])\n\t" /* save z[3] */
"movem.l %%a2-%%a3, (5*8, %[z])\n\t" /* save z[5] */
"movem.l %%d4-%%d5, (7*8, %[z])\n\t" /* save z[7] */
: :[z] "a" (z), [_cPI2_8] "i" (cPI2_8)
: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"a0", "a1", "a2", "a3", "a4", "cc", "memory");
}
#define FFT_FFMPEG_INCL_OPTIMISED_TRANSFORM
static inline FFTComplex* TRANSFORM(FFTComplex * z, unsigned int n, FFTSample wre, FFTSample wim)
{
asm volatile ("move.l (%[z2]), %%d5\n\t"
"mac.l %%d5, %[wre], (4, %[z2]), %%d4, %%acc0\n\t"
"mac.l %%d4, %[wim], %%acc0\n\t"
"mac.l %%d4, %[wre], (%[z3]), %%d6, %%acc1\n\t"
"msac.l %%d5, %[wim], (4, %[z3]), %%d7, %%acc1\n\t"
"mac.l %%d6, %[wre], (%[z])+, %%d4, %%acc2\n\t"
"msac.l %%d7, %[wim], (%[z])+, %%d5, %%acc2\n\t"
"mac.l %%d7, %[wre], %%acc3\n\t"
"mac.l %%d6, %[wim], %%acc3\n\t"
"movclr.l %%acc0, %[wre]\n\t" /* t1 */
"movclr.l %%acc2, %[wim]\n\t" /* t5 */
"move.l %%d4, %%d6\n\t"
"move.l %[wim], %%d7\n\t"
"sub.l %[wre], %[wim]\n\t" /* t5 = t5-t1 */
"add.l %[wre], %%d7\n\t"
"sub.l %%d7, %%d6\n\t" /* d6 = a0re - (t5+t1) => a2re */
"add.l %%d7, %%d4\n\t" /* d4 = a0re + (t5+t1) => a0re */
"movclr.l %%acc3, %%d7\n\t" /* t6 */
"movclr.l %%acc1, %%d3\n\t" /* t2 */
"move.l %%d3, %[wre]\n\t"
"add.l %%d7, %[wre]\n\t"
"sub.l %%d7, %%d3\n\t" /* t2 = t6-t2 */
"move.l %%d5, %%d7\n\t"
"sub.l %[wre], %%d7\n\t" /* d7 = a0im - (t2+t6) => a2im */
"movem.l %%d6-%%d7, (%[z2])\n\t" /* store z2 */
"add.l %[wre], %%d5\n\t" /* d5 = a0im + (t2+t6) => a0im */
"movem.l %%d4-%%d5, (-8, %[z])\n\t" /* store z0 */
"movem.l (%[z1]), %%d4-%%d5\n\t" /* load z1 */
"move.l %%d4, %%d6\n\t"
"sub.l %%d3, %%d6\n\t" /* d6 = a1re - (t2-t6) => a3re */
"add.l %%d3, %%d4\n\t" /* d4 = a1re + (t2-t6) => a1re */
"move.l %%d5, %%d7\n\t"
"sub.l %[wim], %%d7\n\t"
"movem.l %%d6-%%d7, (%[z3])\n\t" /* store z3 */
"add.l %[wim], %%d5\n\t"
"movem.l %%d4-%%d5, (%[z1])\n\t" /* store z1 */
: [wre] "+r" (wre), [wim] "+r" (wim), /* we clobber these after using them */
[z] "+a" (z)
: [z1] "a" (&z[n]), [z2] "a" (&z[2*n]), [z3] "a" (&z[3*n])
: "d3", "d4", "d5", "d6", "d7", "cc", "memory");
return z;
}
static inline FFTComplex* TRANSFORM_W01(FFTComplex * z, unsigned int n, const FFTSample * w)
{
return TRANSFORM(z, n, w[0], w[1]);
}
static inline FFTComplex* TRANSFORM_W10(FFTComplex * z, unsigned int n, const FFTSample * w)
{
return TRANSFORM(z, n, w[1], w[0]);
}
static inline FFTComplex* TRANSFORM_ZERO(FFTComplex * z, unsigned int n)
{
asm volatile("movem.l (%[z]), %%d4-%%d5\n\t" /* load z0 */
"move.l %%d4, %%d6\n\t"
"movem.l (%[z2]), %%d2-%%d3\n\t" /* load z2 */
"movem.l (%[z3]), %%d0-%%d1\n\t" /* load z0 */
"move.l %%d0, %%d7\n\t"
"sub.l %%d2, %%d0\n\t"
"add.l %%d2, %%d7\n\t"
"sub.l %%d7, %%d6\n\t" /* d6 = a0re - (t5+t1) => a2re */
"add.l %%d7, %%d4\n\t" /* d4 = a0re + (t5+t1) => a0re */
"move.l %%d5, %%d7\n\t"
"move.l %%d3, %%d2\n\t"
"add.l %%d1, %%d2\n\t"
"sub.l %%d2, %%d7\n\t" /* d7 = a0im - (t2+t6) => a2im */
"movem.l %%d6-%%d7, (%[z2])\n\t" /* store z2 */
"add.l %%d2, %%d5\n\t" /* d5 = a0im + (t2+t6) => a0im */
"movem.l %%d4-%%d5, (%[z])\n\t" /* store z0 */
"movem.l (%[z1]), %%d4-%%d5\n\t" /* load z1 */
"move.l %%d4, %%d6\n\t"
"sub.l %%d1, %%d3\n\t"
"sub.l %%d3, %%d6\n\t" /* d6 = a1re - (t2-t6) => a3re */
"add.l %%d3, %%d4\n\t" /* d4 = a1re + (t2-t6) => a1re */
"move.l %%d5, %%d7\n\t"
"sub.l %%d0, %%d7\n\t"
"movem.l %%d6-%%d7, (%[z3])\n\t" /* store z3 */
"add.l %%d0, %%d5\n\t"
"movem.l %%d4-%%d5, (%[z1])\n\t" /* store z1 */
:
: [z] "a" (z), [z1] "a" (&z[n]), [z2] "a" (&z[2*n]), [z3] "a" (&z[3*n])
: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory");
return z+1;
}
static inline FFTComplex* TRANSFORM_EQUAL(FFTComplex * z, unsigned int n)
{
asm volatile ("movem.l (%[z2]), %%d0-%%d1\n\t"
"move.l %[_cPI2_8], %%d2\n\t"
"mac.l %%d0, %%d2, (%[z3]), %%d0, %%acc0\n\t"
"mac.l %%d1, %%d2, (4, %[z3]), %%d1, %%acc1\n\t"
"mac.l %%d0, %%d2, (%[z]), %%d4, %%acc2\n\t"
"mac.l %%d1, %%d2, (4, %[z]), %%d5, %%acc3\n\t"
"movclr.l %%acc0, %%d0\n\t"
"movclr.l %%acc1, %%d1\n\t"
"movclr.l %%acc2, %%d2\n\t"
"movclr.l %%acc3, %%d3\n\t"
"move.l %%d0, %%d7\n\t"
"add.l %%d1, %%d0\n\t" /* d0 == t1 */
"sub.l %%d7, %%d1\n\t" /* d1 == t2 */
"move.l %%d3, %%d7\n\t"
"add.l %%d2, %%d3\n\t" /* d3 == t6 */
"sub.l %%d7, %%d2\n\t" /* d2 == t5 */
"move.l %%d4, %%d6\n\t"
"move.l %%d2, %%d7\n\t"
"sub.l %%d0, %%d2\n\t" /* t5 = t5-t1 */
"add.l %%d0, %%d7\n\t"
"sub.l %%d7, %%d6\n\t" /* d6 = a0re - (t5+t1) => a2re */
"add.l %%d7, %%d4\n\t" /* d4 = a0re + (t5+t1) => a0re */
"move.l %%d1, %%d0\n\t"
"add.l %%d3, %%d0\n\t"
"sub.l %%d3, %%d1\n\t" /* t2 = t6-t2 */
"move.l %%d5, %%d7\n\t"
"sub.l %%d0, %%d7\n\t" /* d7 = a0im - (t2+t6) => a2im */
"movem.l %%d6-%%d7, (%[z2])\n\t" /* store z2 */
"add.l %%d0, %%d5\n\t" /* d5 = a0im + (t2+t6) => a0im */
"movem.l %%d4-%%d5, (%[z])\n\t" /* store z0 */
"movem.l (%[z1]), %%d4-%%d5\n\t" /* load z1 */
"move.l %%d4, %%d6\n\t"
"sub.l %%d1, %%d6\n\t" /* d6 = a1re - (t2-t6) => a3re */
"add.l %%d1, %%d4\n\t" /* d4 = a1re + (t2-t6) => a1re */
"move.l %%d5, %%d7\n\t"
"sub.l %%d2, %%d7\n\t"
"movem.l %%d6-%%d7, (%[z3])\n\t" /* store z3 */
"add.l %%d2, %%d5\n\t"
"movem.l %%d4-%%d5, (%[z1])\n\t" /* store z1 */
:: [z] "a" (z), [z1] "a" (&z[n]), [z2] "a" (&z[2*n]), [z3] "a" (&z[3*n]),
[_cPI2_8] "i" (cPI2_8)
: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory");
return z+1;
}
#endif /* CPU_COLDIFRE */

64
lib/rbcodec/codecs/lib/fft.h Normal file
View file

@ -0,0 +1,64 @@
/*
* WMA compatible decoder
* Copyright (c) 2002 The FFmpeg Project.
*
* This library 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 of the License, or (at your option) any later version.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef CODECLIB_FFT_H_INCLUDED
#define CODECLIB_FFT_H_INCLUDED
#include <inttypes.h>
typedef int32_t fixed32;
typedef int64_t fixed64;
#define FFT_FIXED
#ifdef FFT_FIXED
typedef fixed32 FFTSample;
#else /* FFT_FIXED */
typedef float FFTSample;
#endif /* FFT_FIXED */
typedef struct FFTComplex {
FFTSample re, im;
} FFTComplex;
typedef struct FFTContext {
int nbits;
int inverse;
uint16_t *revtab;
int mdct_size; /* size of MDCT (i.e. number of input data * 2) */
int mdct_bits; /* n = 2^nbits */
/* pre/post rotation tables */
FFTSample *tcos;
FFTSample *tsin;
void (*fft_permute)(struct FFTContext *s, FFTComplex *z);
void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
void (*imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input);
void (*imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input);
void (*mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input);
int split_radix;
int permutation;
#define FF_MDCT_PERM_NONE 0
#define FF_MDCT_PERM_INTERLEAVE 1
} FFTContext;
// internal api (fft<->mdct)
//int fft_calc_unscaled(FFTContext *s, FFTComplex *z);
//void ff_fft_permute_c(FFTContext *s, FFTComplex *z); // internal only?
void ff_fft_calc_c(int nbits, FFTComplex *z);
#endif // CODECLIB_FFT_H_INCLUDED

1
lib/rbcodec/codecs/lib/fixedpoint.c Normal file
View file

@ -0,0 +1 @@
#include "../../../apps/fixedpoint.c"

49
lib/rbcodec/codecs/lib/fixedpoint.h Normal file
View file

@ -0,0 +1,49 @@
/***************************************************************************
* __________ __ ___.
* 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.
*
****************************************************************************/
/** CODECS - 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
*
* Calculate sin and cos of an angle:
* fp_sincos(phase, *cos)
* where phase is a 32 bit unsigned integer with 0 representing 0
* and 0xFFFFFFFF representing 2*pi, and *cos is the address to
* a long signed integer. Value returned is a long signed integer
* from -0x80000000 to 0x7fffffff, representing -1 to 1 respectively.
* That is, value is a fixed point integer with 31 fractional bits.
*
* Take square root of a fixed point number:
* fp_sqrt(x, fracbits)
*
*/
#ifndef _FIXEDPOINT_H_CODECS
#define _FIXEDPOINT_H_CODECS
long fp_sincos(unsigned long phase, long *cos);
long fp_sqrt(long a, unsigned int fracbits);
#endif

37
lib/rbcodec/codecs/lib/libcodec.make Normal file
View file

@ -0,0 +1,37 @@
# __________ __ ___.
# Open \______ \ ____ ____ | | _\_ |__ _______ ___
# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
# \/ \/ \/ \/ \/
# $Id$
#
CODECLIB := $(CODECDIR)/libcodec.a
CODECLIB_SRC := $(call preprocess, $(RBCODECLIB_DIR)/codecs/lib/SOURCES)
CODECLIB_OBJ := $(call c2obj, $(CODECLIB_SRC))
OTHER_SRC += $(CODECLIB_SRC)
$(CODECLIB): $(CODECLIB_OBJ)
$(SILENT)$(shell rm -f $@)
$(call PRINTS,AR $(@F))$(AR) rcs $@ $^ >/dev/null
CODECLIBFLAGS = $(filter-out -O%,$(CODECFLAGS))
ifeq ($(MEMORYSIZE),2)
CODECLIBFLAGS += -Os
else ifeq ($(ARCH),arch_m68k)
CODECLIBFLAGS += -O2
else
CODECLIBFLAGS += -O1
endif
# Do not use '-ffunction-sections' when compiling sdl-sim
ifneq ($(findstring sdl-sim, $(APP_TYPE)), sdl-sim)
CODECLIBFLAGS += -ffunction-sections
endif
$(CODECDIR)/lib/%.o: $(RBCODECLIB_DIR)/codecs/lib/%.c
$(SILENT)mkdir -p $(dir $@)
$(call PRINTS,CC $(subst $(ROOTDIR)/,,$<))$(CC) \
-I$(dir $<) $(CODECLIBFLAGS) -c $< -o $@

644
lib/rbcodec/codecs/lib/mdct.c Normal file
View file

@ -0,0 +1,644 @@
/*
* Fixed Point IMDCT
* Copyright (c) 2002 The FFmpeg Project.
* Copyright (c) 2010 Dave Hooper, Mohamed Tarek, Michael Giacomelli
*
* This library 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 of the License, or (at your option) any later version.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "codeclib.h"
#include "mdct.h"
#include "codeclib_misc.h"
#include "mdct_lookup.h"
#ifndef ICODE_ATTR_TREMOR_MDCT
#define ICODE_ATTR_TREMOR_MDCT ICODE_ATTR
#endif
/**
* Compute the middle half of the inverse MDCT of size N = 2^nbits
* thus excluding the parts that can be derived by symmetry
* @param output N/2 samples
* @param input N/2 samples
*
* NOTE - CANNOT CURRENTLY OPERATE IN PLACE (input and output must
* not overlap or intersect at all)
*/
void ff_imdct_half(unsigned int nbits, fixed32 *output, const fixed32 *input) ICODE_ATTR_TREMOR_MDCT;
void ff_imdct_half(unsigned int nbits, fixed32 *output, const fixed32 *input)
{
int n8, n4, n2, n, j;
const fixed32 *in1, *in2;
(void)j;
n = 1 << nbits;
n2 = n >> 1;
n4 = n >> 2;
n8 = n >> 3;
FFTComplex *z = (FFTComplex *)output;
/* pre rotation */
in1 = input;
in2 = input + n2 - 1;
/* revtab comes from the fft; revtab table is sized for N=4096 size fft = 2^12.
The fft is size N/4 so s->nbits-2, so our shift needs to be (12-(nbits-2)) */
const int revtab_shift = (14- nbits);
/* bitreverse reorder the input and rotate; result here is in OUTPUT ... */
/* (note that when using the current split radix, the bitreverse ordering is
complex, meaning that this reordering cannot easily be done in-place) */
/* Using the following pdf, you can see that it is possible to rearrange
the 'classic' pre/post rotate with an alternative one that enables
us to use fewer distinct twiddle factors.
http://www.eurasip.org/Proceedings/Eusipco/Eusipco2006/papers/1568980508.pdf
For prerotation, the factors are just sin,cos(2PI*i/N)
For postrotation, the factors are sin,cos(2PI*(i+1/4)/N)
Therefore, prerotation can immediately reuse the same twiddles as fft
(for postrotation it's still a bit complex, we reuse the fft trig tables
where we can, or a special table for N=2048, or interpolate between
trig tables for N>2048)
*/
const int32_t *T = sincos_lookup0;
const int step = 2<<(12-nbits);
const uint16_t * p_revtab=revtab;
{
const uint16_t * const p_revtab_end = p_revtab + n8;
#ifdef CPU_COLDFIRE
asm volatile ("move.l (%[in2]), %%d0\n\t"
"move.l (%[in1]), %%d1\n\t"
"bra.s 1f\n\t"
"0:\n\t"
"movem.l (%[T]), %%d2-%%d3\n\t"
"addq.l #8, %[in1]\n\t"
"subq.l #8, %[in2]\n\t"
"lea (%[step]*4, %[T]), %[T]\n\t"
"mac.l %%d0, %%d3, (%[T]), %%d4, %%acc0;"
"msac.l %%d1, %%d2, (4, %[T]), %%d5, %%acc0;"
"mac.l %%d1, %%d3, (%[in1]), %%d1, %%acc1;"
"mac.l %%d0, %%d2, (%[in2]), %%d0, %%acc1;"
"addq.l #8, %[in1]\n\t"
"subq.l #8, %[in2]\n\t"
"mac.l %%d0, %%d5, %%acc2;"
"msac.l %%d1, %%d4, (%[p_revtab])+, %%d2, %%acc2;"
"mac.l %%d1, %%d5, (%[in1]), %%d1, %%acc3;"
"mac.l %%d0, %%d4, (%[in2]), %%d0, %%acc3;"
"clr.l %%d3\n\t"
"move.w %%d2, %%d3\n\t"
"eor.l %%d3, %%d2\n\t"
"swap %%d2\n\t"
"lsr.l %[revtab_shift], %%d2\n\t"
"movclr.l %%acc0, %%d4;"
"movclr.l %%acc1, %%d5;"
"lsl.l #3, %%d2\n\t"
"lea (%%d2, %[z]), %%a1\n\t"
"movem.l %%d4-%%d5, (%%a1)\n\t"
"lsr.l %[revtab_shift], %%d3\n\t"
"movclr.l %%acc2, %%d4;"
"movclr.l %%acc3, %%d5;"
"lsl.l #3, %%d3\n\t"
"lea (%%d3, %[z]), %%a1\n\t"
"movem.l %%d4-%%d5, (%%a1)\n\t"
"lea (%[step]*4, %[T]), %[T]\n\t"
"1:\n\t"
"cmp.l %[p_revtab_end], %[p_revtab]\n\t"
"bcs.s 0b\n\t"
: [in1] "+a" (in1), [in2] "+a" (in2), [T] "+a" (T),
[p_revtab] "+a" (p_revtab)
: [z] "a" (z), [step] "d" (step), [revtab_shift] "d" (revtab_shift),
[p_revtab_end] "r" (p_revtab_end)
: "d0", "d1", "d2", "d3", "d4", "d5", "a1", "cc", "memory");
#else
while(LIKELY(p_revtab < p_revtab_end))
{
j = (*p_revtab)>>revtab_shift;
XNPROD31(*in2, *in1, T[1], T[0], &z[j].re, &z[j].im );
T += step;
in1 += 2;
in2 -= 2;
p_revtab++;
j = (*p_revtab)>>revtab_shift;
XNPROD31(*in2, *in1, T[1], T[0], &z[j].re, &z[j].im );
T += step;
in1 += 2;
in2 -= 2;
p_revtab++;
}
#endif
}
{
const uint16_t * const p_revtab_end = p_revtab + n8;
#ifdef CPU_COLDFIRE
asm volatile ("move.l (%[in2]), %%d0\n\t"
"move.l (%[in1]), %%d1\n\t"
"bra.s 1f\n\t"
"0:\n\t"
"movem.l (%[T]), %%d2-%%d3\n\t"
"addq.l #8, %[in1]\n\t"
"subq.l #8, %[in2]\n\t"
"lea (%[step]*4, %[T]), %[T]\n\t"
"mac.l %%d0, %%d2, (%[T]), %%d4, %%acc0;"
"msac.l %%d1, %%d3, (4, %[T]), %%d5, %%acc0;"
"mac.l %%d1, %%d2, (%[in1]), %%d1, %%acc1;"
"mac.l %%d0, %%d3, (%[in2]), %%d0, %%acc1;"
"addq.l #8, %[in1]\n\t"
"subq.l #8, %[in2]\n\t"
"mac.l %%d0, %%d4, %%acc2;"
"msac.l %%d1, %%d5, (%[p_revtab])+, %%d2, %%acc2;"
"mac.l %%d1, %%d4, (%[in1]), %%d1, %%acc3;"
"mac.l %%d0, %%d5, (%[in2]), %%d0, %%acc3;"
"clr.l %%d3\n\t"
"move.w %%d2, %%d3\n\t"
"eor.l %%d3, %%d2\n\t"
"swap %%d2\n\t"
"lsr.l %[revtab_shift], %%d2\n\t"
"movclr.l %%acc0, %%d4;"
"movclr.l %%acc1, %%d5;"
"lsl.l #3, %%d2\n\t"
"lea (%%d2, %[z]), %%a1\n\t"
"movem.l %%d4-%%d5, (%%a1)\n\t"
"lsr.l %[revtab_shift], %%d3\n\t"
"movclr.l %%acc2, %%d4;"
"movclr.l %%acc3, %%d5;"
"lsl.l #3, %%d3\n\t"
"lea (%%d3, %[z]), %%a1\n\t"
"movem.l %%d4-%%d5, (%%a1)\n\t"
"lea (%[step]*4, %[T]), %[T]\n\t"
"1:\n\t"
"cmp.l %[p_revtab_end], %[p_revtab]\n\t"
"bcs.s 0b\n\t"
: [in1] "+a" (in1), [in2] "+a" (in2), [T] "+a" (T),
[p_revtab] "+a" (p_revtab)
: [z] "a" (z), [step] "d" (-step), [revtab_shift] "d" (revtab_shift),
[p_revtab_end] "r" (p_revtab_end)
: "d0", "d1", "d2", "d3", "d4", "d5", "a1", "cc", "memory");
#else
while(LIKELY(p_revtab < p_revtab_end))
{
j = (*p_revtab)>>revtab_shift;
XNPROD31(*in2, *in1, T[0], T[1], &z[j].re, &z[j].im);
T -= step;
in1 += 2;
in2 -= 2;
p_revtab++;
j = (*p_revtab)>>revtab_shift;
XNPROD31(*in2, *in1, T[0], T[1], &z[j].re, &z[j].im);
T -= step;
in1 += 2;
in2 -= 2;
p_revtab++;
}
#endif
}
/* ... and so fft runs in OUTPUT buffer */
ff_fft_calc_c(nbits-2, z);
/* post rotation + reordering. now keeps the result within the OUTPUT buffer */
switch( nbits )
{
default:
{
fixed32 * z1 = (fixed32 *)(&z[0]);
int magic_step = step>>2;
int newstep;
if(n<=1024)
{
T = sincos_lookup0 + magic_step;
newstep = step>>1;
}
else
{
T = sincos_lookup1;
newstep = 2;
}
#ifdef CPU_COLDFIRE
fixed32 * z2 = (fixed32 *)(&z[n4]);
int c = n4;
if (newstep == 2)
{
asm volatile ("movem.l (%[z1]), %%d0-%%d1\n\t"
"addq.l #8, %[z1]\n\t"
"movem.l (%[T]), %%d2-%%d3\n\t"
"addq.l #8, %[T]\n\t"
"bra.s 1f\n\t"
"0:\n\t"
"msac.l %%d1, %%d2, (%[T])+, %%a3, %%acc0\n\t"
"mac.l %%d0, %%d3, (%[T])+, %%a4, %%acc0\n\t"
"msac.l %%d1, %%d3, -(%[z2]), %%d1, %%acc1\n\t"
"msac.l %%d0, %%d2, -(%[z2]), %%d0, %%acc1\n\t"
"msac.l %%d1, %%a4, (%[T])+, %%d2, %%acc2\n\t"
"mac.l %%d0, %%a3, (%[T])+, %%d3, %%acc2\n\t"
"msac.l %%d0, %%a4, (%[z1])+, %%d0, %%acc3\n\t"
"msac.l %%d1, %%a3, (%[z1])+, %%d1, %%acc3\n\t"
"movclr.l %%acc0, %%a3\n\t"
"movclr.l %%acc3, %%a4\n\t"
"movem.l %%a3-%%a4, (-16, %[z1])\n\t"
"movclr.l %%acc1, %%a4\n\t"
"movclr.l %%acc2, %%a3\n\t"
"movem.l %%a3-%%a4, (%[z2])\n\t"
"subq.l #2, %[n]\n\t"
"1:\n\t"
"bhi.s 0b\n\t"
: [z1] "+a" (z1), [z2] "+a" (z2), [T] "+a" (T), [n] "+d" (c)
:
: "d0", "d1", "d2", "d3", "a3", "a4", "cc", "memory");
}
else
{
asm volatile ("movem.l (%[z1]), %%d0-%%d1\n\t"
"addq.l #8, %[z1]\n\t"
"movem.l (%[T]), %%d2-%%d3\n\t"
"lea (%[newstep]*4, %[T]), %[T]\n\t"
"bra.s 1f\n\t"
"0:\n\t"
"msac.l %%d1, %%d2, (%[T]), %%a3, %%acc0\n\t"
"mac.l %%d0, %%d3, (4, %[T]), %%a4, %%acc0\n\t"
"msac.l %%d1, %%d3, -(%[z2]), %%d1, %%acc1\n\t"
"msac.l %%d0, %%d2, -(%[z2]), %%d0, %%acc1\n\t"
"lea (%[newstep]*4, %[T]), %[T]\n\t"
"msac.l %%d1, %%a4, (%[T]), %%d2, %%acc2\n\t"
"mac.l %%d0, %%a3, (4, %[T]), %%d3, %%acc2\n\t"
"msac.l %%d0, %%a4, (%[z1])+, %%d0, %%acc3\n\t"
"msac.l %%d1, %%a3, (%[z1])+, %%d1, %%acc3\n\t"
"lea (%[newstep]*4, %[T]), %[T]\n\t"
"movclr.l %%acc0, %%a3\n\t"
"movclr.l %%acc3, %%a4\n\t"
"movem.l %%a3-%%a4, (-16, %[z1])\n\t"
"movclr.l %%acc1, %%a4\n\t"
"movclr.l %%acc2, %%a3\n\t"
"movem.l %%a3-%%a4, (%[z2])\n\t"
"subq.l #2, %[n]\n\t"
"1:\n\t"
"bhi.s 0b\n\t"
: [z1] "+a" (z1), [z2] "+a" (z2), [T] "+a" (T), [n] "+d" (c)
: [newstep] "d" (newstep)
: "d0", "d1", "d2", "d3", "a3", "a4", "cc", "memory");
}
#else
fixed32 * z2 = (fixed32 *)(&z[n4-1]);
while(z1<z2)
{
fixed32 r0,i0,r1,i1;
XNPROD31_R(z1[1], z1[0], T[0], T[1], r0, i1 ); T+=newstep;
XNPROD31_R(z2[1], z2[0], T[1], T[0], r1, i0 ); T+=newstep;
z1[0] = -r0;
z1[1] = -i0;
z2[0] = -r1;
z2[1] = -i1;
z1+=2;
z2-=2;
}
#endif
break;
}
case 12: /* n=4096 */
{
/* linear interpolation (50:50) between sincos_lookup0 and sincos_lookup1 */
const int32_t * V = sincos_lookup1;
T = sincos_lookup0;
int32_t t0,t1,v0,v1;
fixed32 * z1 = (fixed32 *)(&z[0]);
fixed32 * z2 = (fixed32 *)(&z[n4-1]);
t0 = T[0]>>1; t1=T[1]>>1;
while(z1<z2)
{
fixed32 r0,i0,r1,i1;
t0 += (v0 = (V[0]>>1));
t1 += (v1 = (V[1]>>1));
XNPROD31_R(z1[1], z1[0], t0, t1, r0, i1 );
T+=2;
v0 += (t0 = (T[0]>>1));
v1 += (t1 = (T[1]>>1));
XNPROD31_R(z2[1], z2[0], v1, v0, r1, i0 );
z1[0] = -r0;
z1[1] = -i0;
z2[0] = -r1;
z2[1] = -i1;
z1+=2;
z2-=2;
V+=2;
}
break;
}
case 13: /* n = 8192 */
{
/* weight linear interpolation between sincos_lookup0 and sincos_lookup1
specifically: 25:75 for first twiddle and 75:25 for second twiddle */
const int32_t * V = sincos_lookup1;
T = sincos_lookup0;
int32_t t0,t1,v0,v1,q0,q1;
fixed32 * z1 = (fixed32 *)(&z[0]);
fixed32 * z2 = (fixed32 *)(&z[n4-1]);
t0 = T[0]; t1=T[1];
while(z1<z2)
{
fixed32 r0,i0,r1,i1;
v0 = V[0]; v1 = V[1];
t0 += (q0 = (v0-t0)>>1);
t1 += (q1 = (v1-t1)>>1);
XNPROD31_R(z1[1], z1[0], t0, t1, r0, i1 );
t0 = v0-q0;
t1 = v1-q1;
XNPROD31_R(z2[1], z2[0], t1, t0, r1, i0 );
z1[0] = -r0;
z1[1] = -i0;
z2[0] = -r1;
z2[1] = -i1;
z1+=2;
z2-=2;
T+=2;
t0 = T[0]; t1 = T[1];
v0 += (q0 = (t0-v0)>>1);
v1 += (q1 = (t1-v1)>>1);
XNPROD31_R(z1[1], z1[0], v0, v1, r0, i1 );
v0 = t0-q0;
v1 = t1-q1;
XNPROD31_R(z2[1], z2[0], v1, v0, r1, i0 );
z1[0] = -r0;
z1[1] = -i0;
z2[0] = -r1;
z2[1] = -i1;
z1+=2;
z2-=2;
V+=2;
}
break;
}
}
}
/**
* Compute inverse MDCT of size N = 2^nbits
* @param output N samples
* @param input N/2 samples
* "In-place" processing can be achieved provided that:
* [0 .. N/2-1 | N/2 .. N-1 ]
* <----input---->
* <-----------output----------->
*
* The result of ff_imdct_half is to put the 'half' imdct here
*
* N/2 N-1
* <--half imdct-->
*
* We want it here for the full imdct:
* N/4 3N/4-1
* <-------------->
*
* In addition we need to apply two symmetries to get the full imdct:
*
* <AAAAAA> <DDDDDD>
* <BBBBBB><CCCCCC>
*
* D is a reflection of C
* A is a reflection of B (but with sign flipped)
*
* We process the symmetries at the same time as we 'move' the half imdct
* from [N/2,N-1] to [N/4,3N/4-1]
*
* TODO: find a way to make ff_imdct_half put the result in [N/4..3N/4-1]
* This would require being able to use revtab 'inplace' (since the input
* and output of imdct_half would then overlap somewhat)
*/
void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input) ICODE_ATTR_TREMOR_MDCT;
#ifndef CPU_ARM
void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input)
{
const int n = (1<<nbits);
const int n2 = (n>>1);
const int n4 = (n>>2);
/* tell imdct_half to put the output in [N/2..3N/4-1] i.e. output+n2 */
ff_imdct_half(nbits,output+n2,input);
fixed32 * in_r, * in_r2, * out_r, * out_r2;
/* Copy BBBB to AAAA, reflected and sign-flipped.
Also copy BBBB to its correct destination (from [N/2..3N/4-1] to [N/4..N/2-1]) */
out_r = output;
out_r2 = output+n2-8;
in_r = output+n2+n4-8;
while(out_r<out_r2)
{
#if defined CPU_COLDFIRE
asm volatile(
"movem.l (%[in_r]), %%d0-%%d7\n\t"
"movem.l %%d0-%%d7, (%[out_r2])\n\t"
"neg.l %%d7\n\t"
"move.l %%d7, (%[out_r])+\n\t"
"neg.l %%d6\n\t"
"move.l %%d6, (%[out_r])+\n\t"
"neg.l %%d5\n\t"
"move.l %%d5, (%[out_r])+\n\t"
"neg.l %%d4\n\t"
"move.l %%d4, (%[out_r])+\n\t"
"neg.l %%d3\n\t"
"move.l %%d3, (%[out_r])+\n\t"
"neg.l %%d2\n\t"
"move.l %%d2, (%[out_r])+\n\t"
"lea.l (-8*4, %[in_r]), %[in_r]\n\t"
"neg.l %%d1\n\t"
"move.l %%d1, (%[out_r])+\n\t"
"lea.l (-8*4, %[out_r2]), %[out_r2]\n\t"
"neg.l %%d0\n\t"
"move.l %%d0, (%[out_r])+\n\t"
: [in_r] "+a" (in_r), [out_r] "+a" (out_r), [out_r2] "+a" (out_r2)
:
: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory" );
#else
out_r[0] = -(out_r2[7] = in_r[7]);
out_r[1] = -(out_r2[6] = in_r[6]);
out_r[2] = -(out_r2[5] = in_r[5]);
out_r[3] = -(out_r2[4] = in_r[4]);
out_r[4] = -(out_r2[3] = in_r[3]);
out_r[5] = -(out_r2[2] = in_r[2]);
out_r[6] = -(out_r2[1] = in_r[1]);
out_r[7] = -(out_r2[0] = in_r[0]);
in_r -= 8;
out_r += 8;
out_r2 -= 8;
#endif
}
in_r = output + n2+n4;
in_r2 = output + n-4;
out_r = output + n2;
out_r2 = output + n2 + n4 - 4;
while(in_r<in_r2)
{
#if defined CPU_COLDFIRE
asm volatile(
"movem.l (%[in_r]), %%d0-%%d3\n\t"
"movem.l %%d0-%%d3, (%[out_r])\n\t"
"movem.l (%[in_r2]), %%d4-%%d7\n\t"
"movem.l %%d4-%%d7, (%[out_r2])\n\t"
"move.l %%d0, %%a3\n\t"
"move.l %%d3, %%d0\n\t"
"move.l %%d1, %%d3\n\t"
"movem.l %%d0/%%d2-%%d3/%%a3, (%[in_r2])\n\t"
"move.l %%d7, %%d1\n\t"
"move.l %%d6, %%d2\n\t"
"move.l %%d5, %%d3\n\t"
"movem.l %%d1-%%d4, (%[in_r])\n\t"
"lea.l (4*4, %[in_r]), %[in_r]\n\t"
"lea.l (-4*4, %[in_r2]), %[in_r2]\n\t"
"lea.l (4*4, %[out_r]), %[out_r]\n\t"
"lea.l (-4*4, %[out_r2]), %[out_r2]\n\t"
: [in_r] "+a" (in_r), [in_r2] "+a" (in_r2),
[out_r] "+a" (out_r), [out_r2] "+a" (out_r2)
:
: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a3", "memory", "cc" );
#else
register fixed32 t0,t1,t2,t3;
register fixed32 s0,s1,s2,s3;
/* Copy and reflect CCCC to DDDD. Because CCCC is already where
we actually want to put DDDD this is a bit complicated.
* So simultaneously do the following things:
* 1. copy range from [n2+n4 .. n-1] to range[n2 .. n2+n4-1]
* 2. reflect range from [n2+n4 .. n-1] inplace
*
* [ | ]
* ^a -> <- ^b ^c -> <- ^d
*
* #1: copy from ^c to ^a
* #2: copy from ^d to ^b
* #3: swap ^c and ^d in place
*/
/* #1 pt1 : load 4 words from ^c. */
t0=in_r[0]; t1=in_r[1]; t2=in_r[2]; t3=in_r[3];
/* #1 pt2 : write to ^a */
out_r[0]=t0;out_r[1]=t1;out_r[2]=t2;out_r[3]=t3;
/* #2 pt1 : load 4 words from ^d */
s0=in_r2[0];s1=in_r2[1];s2=in_r2[2];s3=in_r2[3];
/* #2 pt2 : write to ^b */
out_r2[0]=s0;out_r2[1]=s1;out_r2[2]=s2;out_r2[3]=s3;
/* #3 pt1 : write words from #2 to ^c */
in_r[0]=s3;in_r[1]=s2;in_r[2]=s1;in_r[3]=s0;
/* #3 pt2 : write words from #1 to ^d */
in_r2[0]=t3;in_r2[1]=t2;in_r2[2]=t1;in_r2[3]=t0;
in_r += 4;
in_r2 -= 4;
out_r += 4;
out_r2 -= 4;
#endif
}
}
#else
/* Follows the same structure as the canonical version above */
void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input)
{
const int n = (1<<nbits);
const int n2 = (n>>1);
const int n4 = (n>>2);
ff_imdct_half(nbits,output+n2,input);
fixed32 * in_r, * in_r2, * out_r, * out_r2;
out_r = output;
out_r2 = output+n2;
in_r = output+n2+n4;
while(out_r<out_r2)
{
asm volatile(
"ldmdb %[in_r]!, {r0-r7}\n\t"
"stmdb %[out_r2]!, {r0-r7}\n\t"
"rsb r8,r0,#0\n\t"
"rsb r0,r7,#0\n\t"
"rsb r7,r1,#0\n\t"
"rsb r1,r6,#0\n\t"
"rsb r6,r2,#0\n\t"
"rsb r2,r5,#0\n\t"
"rsb r5,r3,#0\n\t"
"rsb r3,r4,#0\n\t"
"stmia %[out_r]!, {r0-r3,r5-r8}\n\t"
: [in_r] "+r" (in_r), [out_r] "+r" (out_r), [out_r2] "+r" (out_r2)
:
: "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "memory" );
}
in_r = output + n2+n4;
in_r2 = output + n;
out_r = output + n2;
out_r2 = output + n2 + n4;
while(in_r<in_r2)
{
asm volatile(
"ldmia %[in_r], {r0-r3}\n\t"
"stmia %[out_r]!, {r0-r3}\n\t"
"ldmdb %[in_r2], {r5-r8}\n\t"
"stmdb %[out_r2]!, {r5-r8}\n\t"
"mov r4,r0\n\t"
"mov r0,r3\n\t"
"mov r3,r1\n\t"
"stmdb %[in_r2]!, {r0,r2,r3,r4}\n\t"
"mov r4,r8\n\t"
"mov r8,r5\n\t"
"mov r5,r7\n\t"
"stmia %[in_r]!, {r4,r5,r6,r8}\n\t"
:
[in_r] "+r" (in_r), [in_r2] "+r" (in_r2), [out_r] "+r" (out_r), [out_r2] "+r" (out_r2)
:
: "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "memory" );
}
}
#endif

139
lib/rbcodec/codecs/lib/mdct.h Normal file
View file

@ -0,0 +1,139 @@
/*
* WMA compatible decoder
* Copyright (c) 2002 The FFmpeg Project.
*
* This library 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 of the License, or (at your option) any later version.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef CODECLIB_MDCT_H_INCLUDED
#define CODECLIB_MDCT_H_INCLUDED
//#include "types.h"
#include "fft.h"
void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input);
void ff_imdct_half(unsigned int nbits, fixed32 *output, const fixed32 *input);
#ifdef CPU_ARM
/*Sign-15.16 format */
#define fixmul32b(x, y) \
({ int32_t __hi; \
uint32_t __lo; \
int32_t __result; \
asm ("smull %0, %1, %3, %4\n\t" \
"mov %2, %1, lsl #1" \
: "=&r" (__lo), "=&r" (__hi), "=r" (__result) \
: "%r" (x), "r" (y) \
: "cc" ); \
__result; \
})
#elif defined(CPU_COLDFIRE)
static inline int32_t fixmul32b(int32_t x, int32_t y)
{
asm (
"mac.l %[x], %[y], %%acc0 \n" /* multiply */
"movclr.l %%acc0, %[x] \n" /* get higher half */
: [x] "+d" (x)
: [y] "d" (y)
);
return x;
}
#else
static inline fixed32 fixmul32b(fixed32 x, fixed32 y)
{
fixed64 temp;
temp = x;
temp *= y;
temp >>= 31; //16+31-16 = 31 bits
return (fixed32)temp;
}
#endif
#ifdef CPU_ARM
static inline
void CMUL(fixed32 *x, fixed32 *y,
fixed32 a, fixed32 b,
fixed32 t, fixed32 v)
{
/* This version loses one bit of precision. Could be solved at the cost
* of 2 extra cycles if it becomes an issue. */
int x1, y1, l;
asm(
"smull %[l], %[y1], %[b], %[t] \n"
"smlal %[l], %[y1], %[a], %[v] \n"
"rsb %[b], %[b], #0 \n"
"smull %[l], %[x1], %[a], %[t] \n"
"smlal %[l], %[x1], %[b], %[v] \n"
: [l] "=&r" (l), [x1]"=&r" (x1), [y1]"=&r" (y1), [b] "+r" (b)
: [a] "r" (a), [t] "r" (t), [v] "r" (v)
: "cc"
);
*x = x1 << 1;
*y = y1 << 1;
}
#elif defined CPU_COLDFIRE
static inline
void CMUL(fixed32 *x, fixed32 *y,
fixed32 a, fixed32 b,
fixed32 t, fixed32 v)
{
asm volatile ("mac.l %[a], %[t], %%acc0;"
"msac.l %[b], %[v], %%acc0;"
"mac.l %[b], %[t], %%acc1;"
"mac.l %[a], %[v], %%acc1;"
"movclr.l %%acc0, %[a];"
"move.l %[a], (%[x]);"
"movclr.l %%acc1, %[a];"
"move.l %[a], (%[y]);"
: [a] "+&r" (a)
: [x] "a" (x), [y] "a" (y),
[b] "r" (b), [t] "r" (t), [v] "r" (v)
: "cc", "memory");
}
#else
static inline
void CMUL(fixed32 *pre,
fixed32 *pim,
fixed32 are,
fixed32 aim,
fixed32 bre,
fixed32 bim)
{
//int64_t x,y;
fixed32 _aref = are;
fixed32 _aimf = aim;
fixed32 _bref = bre;
fixed32 _bimf = bim;
fixed32 _r1 = fixmul32b(_bref, _aref);
fixed32 _r2 = fixmul32b(_bimf, _aimf);
fixed32 _r3 = fixmul32b(_bref, _aimf);
fixed32 _r4 = fixmul32b(_bimf, _aref);
*pre = _r1 - _r2;
*pim = _r3 + _r4;
}
#endif
#endif // CODECLIB_MDCT_H_INCLUDED

872
lib/rbcodec/codecs/lib/mdct_lookup.c Normal file
View file

@ -0,0 +1,872 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2009 Michael Giacomelli
*
*
*
* 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.
*
****************************************************************************/
#ifdef ROCKBOX
#include <codecs/lib/codeclib.h>
#else
#include <stdlib.h>
#include <stdint.h>
#endif /* ROCKBOX */
/* {sin(2*i*PI/4096, cos(2*i*PI/4096)}, with i = 0 to 512 */
const int32_t sincos_lookup0[1026] ICONST_ATTR = {
0x00000000, 0x7fffffff, 0x003243f5, 0x7ffff621,
0x006487e3, 0x7fffd886, 0x0096cbc1, 0x7fffa72c,
0x00c90f88, 0x7fff6216, 0x00fb5330, 0x7fff0943,
0x012d96b1, 0x7ffe9cb2, 0x015fda03, 0x7ffe1c65,
0x01921d20, 0x7ffd885a, 0x01c45ffe, 0x7ffce093,
0x01f6a297, 0x7ffc250f, 0x0228e4e2, 0x7ffb55ce,
0x025b26d7, 0x7ffa72d1, 0x028d6870, 0x7ff97c18,
0x02bfa9a4, 0x7ff871a2, 0x02f1ea6c, 0x7ff75370,
0x03242abf, 0x7ff62182, 0x03566a96, 0x7ff4dbd9,
0x0388a9ea, 0x7ff38274, 0x03bae8b2, 0x7ff21553,
0x03ed26e6, 0x7ff09478, 0x041f6480, 0x7feeffe1,
0x0451a177, 0x7fed5791, 0x0483ddc3, 0x7feb9b85,
0x04b6195d, 0x7fe9cbc0, 0x04e8543e, 0x7fe7e841,
0x051a8e5c, 0x7fe5f108, 0x054cc7b1, 0x7fe3e616,
0x057f0035, 0x7fe1c76b, 0x05b137df, 0x7fdf9508,
0x05e36ea9, 0x7fdd4eec, 0x0615a48b, 0x7fdaf519,
0x0647d97c, 0x7fd8878e, 0x067a0d76, 0x7fd6064c,
0x06ac406f, 0x7fd37153, 0x06de7262, 0x7fd0c8a3,
0x0710a345, 0x7fce0c3e, 0x0742d311, 0x7fcb3c23,
0x077501be, 0x7fc85854, 0x07a72f45, 0x7fc560cf,
0x07d95b9e, 0x7fc25596, 0x080b86c2, 0x7fbf36aa,
0x083db0a7, 0x7fbc040a, 0x086fd947, 0x7fb8bdb8,
0x08a2009a, 0x7fb563b3, 0x08d42699, 0x7fb1f5fc,
0x09064b3a, 0x7fae7495, 0x09386e78, 0x7faadf7c,
0x096a9049, 0x7fa736b4, 0x099cb0a7, 0x7fa37a3c,
0x09cecf89, 0x7f9faa15, 0x0a00ece8, 0x7f9bc640,
0x0a3308bd, 0x7f97cebd, 0x0a6522fe, 0x7f93c38c,
0x0a973ba5, 0x7f8fa4b0, 0x0ac952aa, 0x7f8b7227,
0x0afb6805, 0x7f872bf3, 0x0b2d7baf, 0x7f82d214,
0x0b5f8d9f, 0x7f7e648c, 0x0b919dcf, 0x7f79e35a,
0x0bc3ac35, 0x7f754e80, 0x0bf5b8cb, 0x7f70a5fe,
0x0c27c389, 0x7f6be9d4, 0x0c59cc68, 0x7f671a05,
0x0c8bd35e, 0x7f62368f, 0x0cbdd865, 0x7f5d3f75,
0x0cefdb76, 0x7f5834b7, 0x0d21dc87, 0x7f531655,
0x0d53db92, 0x7f4de451, 0x0d85d88f, 0x7f489eaa,
0x0db7d376, 0x7f434563, 0x0de9cc40, 0x7f3dd87c,
0x0e1bc2e4, 0x7f3857f6, 0x0e4db75b, 0x7f32c3d1,
0x0e7fa99e, 0x7f2d1c0e, 0x0eb199a4, 0x7f2760af,
0x0ee38766, 0x7f2191b4, 0x0f1572dc, 0x7f1baf1e,
0x0f475bff, 0x7f15b8ee, 0x0f7942c7, 0x7f0faf25,
0x0fab272b, 0x7f0991c4, 0x0fdd0926, 0x7f0360cb,
0x100ee8ad, 0x7efd1c3c, 0x1040c5bb, 0x7ef6c418,
0x1072a048, 0x7ef05860, 0x10a4784b, 0x7ee9d914,
0x10d64dbd, 0x7ee34636, 0x11082096, 0x7edc9fc6,
0x1139f0cf, 0x7ed5e5c6, 0x116bbe60, 0x7ecf1837,
0x119d8941, 0x7ec8371a, 0x11cf516a, 0x7ec14270,
0x120116d5, 0x7eba3a39, 0x1232d979, 0x7eb31e78,
0x1264994e, 0x7eabef2c, 0x1296564d, 0x7ea4ac58,
0x12c8106f, 0x7e9d55fc, 0x12f9c7aa, 0x7e95ec1a,
0x132b7bf9, 0x7e8e6eb2, 0x135d2d53, 0x7e86ddc6,
0x138edbb1, 0x7e7f3957, 0x13c0870a, 0x7e778166,
0x13f22f58, 0x7e6fb5f4, 0x1423d492, 0x7e67d703,
0x145576b1, 0x7e5fe493, 0x148715ae, 0x7e57dea7,
0x14b8b17f, 0x7e4fc53e, 0x14ea4a1f, 0x7e47985b,
0x151bdf86, 0x7e3f57ff, 0x154d71aa, 0x7e37042a,
0x157f0086, 0x7e2e9cdf, 0x15b08c12, 0x7e26221f,
0x15e21445, 0x7e1d93ea, 0x16139918, 0x7e14f242,
0x16451a83, 0x7e0c3d29, 0x1676987f, 0x7e0374a0,
0x16a81305, 0x7dfa98a8, 0x16d98a0c, 0x7df1a942,
0x170afd8d, 0x7de8a670, 0x173c6d80, 0x7ddf9034,
0x176dd9de, 0x7dd6668f, 0x179f429f, 0x7dcd2981,
0x17d0a7bc, 0x7dc3d90d, 0x1802092c, 0x7dba7534,
0x183366e9, 0x7db0fdf8, 0x1864c0ea, 0x7da77359,
0x18961728, 0x7d9dd55a, 0x18c7699b, 0x7d9423fc,
0x18f8b83c, 0x7d8a5f40, 0x192a0304, 0x7d808728,
0x195b49ea, 0x7d769bb5, 0x198c8ce7, 0x7d6c9ce9,
0x19bdcbf3, 0x7d628ac6, 0x19ef0707, 0x7d58654d,
0x1a203e1b, 0x7d4e2c7f, 0x1a517128, 0x7d43e05e,
0x1a82a026, 0x7d3980ec, 0x1ab3cb0d, 0x7d2f0e2b,
0x1ae4f1d6, 0x7d24881b, 0x1b161479, 0x7d19eebf,
0x1b4732ef, 0x7d0f4218, 0x1b784d30, 0x7d048228,
0x1ba96335, 0x7cf9aef0, 0x1bda74f6, 0x7ceec873,
0x1c0b826a, 0x7ce3ceb2, 0x1c3c8b8c, 0x7cd8c1ae,
0x1c6d9053, 0x7ccda169, 0x1c9e90b8, 0x7cc26de5,
0x1ccf8cb3, 0x7cb72724, 0x1d00843d, 0x7cabcd28,
0x1d31774d, 0x7ca05ff1, 0x1d6265dd, 0x7c94df83,
0x1d934fe5, 0x7c894bde, 0x1dc4355e, 0x7c7da505,
0x1df5163f, 0x7c71eaf9, 0x1e25f282, 0x7c661dbc,
0x1e56ca1e, 0x7c5a3d50, 0x1e879d0d, 0x7c4e49b7,
0x1eb86b46, 0x7c4242f2, 0x1ee934c3, 0x7c362904,
0x1f19f97b, 0x7c29fbee, 0x1f4ab968, 0x7c1dbbb3,
0x1f7b7481, 0x7c116853, 0x1fac2abf, 0x7c0501d2,
0x1fdcdc1b, 0x7bf88830, 0x200d888d, 0x7bebfb70,
0x203e300d, 0x7bdf5b94, 0x206ed295, 0x7bd2a89e,
0x209f701c, 0x7bc5e290, 0x20d0089c, 0x7bb9096b,
0x21009c0c, 0x7bac1d31, 0x21312a65, 0x7b9f1de6,
0x2161b3a0, 0x7b920b89, 0x219237b5, 0x7b84e61f,
0x21c2b69c, 0x7b77ada8, 0x21f3304f, 0x7b6a6227,
0x2223a4c5, 0x7b5d039e, 0x225413f8, 0x7b4f920e,
0x22847de0, 0x7b420d7a, 0x22b4e274, 0x7b3475e5,
0x22e541af, 0x7b26cb4f, 0x23159b88, 0x7b190dbc,
0x2345eff8, 0x7b0b3d2c, 0x23763ef7, 0x7afd59a4,
0x23a6887f, 0x7aef6323, 0x23d6cc87, 0x7ae159ae,
0x24070b08, 0x7ad33d45, 0x243743fa, 0x7ac50dec,
0x24677758, 0x7ab6cba4, 0x2497a517, 0x7aa8766f,
0x24c7cd33, 0x7a9a0e50, 0x24f7efa2, 0x7a8b9348,
0x25280c5e, 0x7a7d055b, 0x2558235f, 0x7a6e648a,
0x2588349d, 0x7a5fb0d8, 0x25b84012, 0x7a50ea47,
0x25e845b6, 0x7a4210d8, 0x26184581, 0x7a332490,
0x26483f6c, 0x7a24256f, 0x26783370, 0x7a151378,
0x26a82186, 0x7a05eead, 0x26d809a5, 0x79f6b711,
0x2707ebc7, 0x79e76ca7, 0x2737c7e3, 0x79d80f6f,
0x27679df4, 0x79c89f6e, 0x27976df1, 0x79b91ca4,
0x27c737d3, 0x79a98715, 0x27f6fb92, 0x7999dec4,
0x2826b928, 0x798a23b1, 0x2856708d, 0x797a55e0,
0x288621b9, 0x796a7554, 0x28b5cca5, 0x795a820e,
0x28e5714b, 0x794a7c12, 0x29150fa1, 0x793a6361,
0x2944a7a2, 0x792a37fe, 0x29743946, 0x7919f9ec,
0x29a3c485, 0x7909a92d, 0x29d34958, 0x78f945c3,
0x2a02c7b8, 0x78e8cfb2, 0x2a323f9e, 0x78d846fb,
0x2a61b101, 0x78c7aba2, 0x2a911bdc, 0x78b6fda8,
0x2ac08026, 0x78a63d11, 0x2aefddd8, 0x789569df,
0x2b1f34eb, 0x78848414, 0x2b4e8558, 0x78738bb3,
0x2b7dcf17, 0x786280bf, 0x2bad1221, 0x7851633b,
0x2bdc4e6f, 0x78403329, 0x2c0b83fa, 0x782ef08b,
0x2c3ab2b9, 0x781d9b65, 0x2c69daa6, 0x780c33b8,
0x2c98fbba, 0x77fab989, 0x2cc815ee, 0x77e92cd9,
0x2cf72939, 0x77d78daa, 0x2d263596, 0x77c5dc01,
0x2d553afc, 0x77b417df, 0x2d843964, 0x77a24148,
0x2db330c7, 0x7790583e, 0x2de2211e, 0x777e5cc3,
0x2e110a62, 0x776c4edb, 0x2e3fec8b, 0x775a2e89,
0x2e6ec792, 0x7747fbce, 0x2e9d9b70, 0x7735b6af,
0x2ecc681e, 0x77235f2d, 0x2efb2d95, 0x7710f54c,
0x2f29ebcc, 0x76fe790e, 0x2f58a2be, 0x76ebea77,
0x2f875262, 0x76d94989, 0x2fb5fab2, 0x76c69647,
0x2fe49ba7, 0x76b3d0b4, 0x30133539, 0x76a0f8d2,
0x3041c761, 0x768e0ea6, 0x30705217, 0x767b1231,
0x309ed556, 0x76680376, 0x30cd5115, 0x7654e279,
0x30fbc54d, 0x7641af3d, 0x312a31f8, 0x762e69c4,
0x3158970e, 0x761b1211, 0x3186f487, 0x7607a828,
0x31b54a5e, 0x75f42c0b, 0x31e39889, 0x75e09dbd,
0x3211df04, 0x75ccfd42, 0x32401dc6, 0x75b94a9c,
0x326e54c7, 0x75a585cf, 0x329c8402, 0x7591aedd,
0x32caab6f, 0x757dc5ca, 0x32f8cb07, 0x7569ca99,
0x3326e2c3, 0x7555bd4c, 0x3354f29b, 0x75419de7,
0x3382fa88, 0x752d6c6c, 0x33b0fa84, 0x751928e0,
0x33def287, 0x7504d345, 0x340ce28b, 0x74f06b9e,
0x343aca87, 0x74dbf1ef, 0x3468aa76, 0x74c7663a,
0x34968250, 0x74b2c884, 0x34c4520d, 0x749e18cd,
0x34f219a8, 0x7489571c, 0x351fd918, 0x74748371,
0x354d9057, 0x745f9dd1, 0x357b3f5d, 0x744aa63f,
0x35a8e625, 0x74359cbd, 0x35d684a6, 0x74208150,
0x36041ad9, 0x740b53fb, 0x3631a8b8, 0x73f614c0,
0x365f2e3b, 0x73e0c3a3, 0x368cab5c, 0x73cb60a8,
0x36ba2014, 0x73b5ebd1, 0x36e78c5b, 0x73a06522,
0x3714f02a, 0x738acc9e, 0x37424b7b, 0x73752249,
0x376f9e46, 0x735f6626, 0x379ce885, 0x73499838,
0x37ca2a30, 0x7333b883, 0x37f76341, 0x731dc70a,
0x382493b0, 0x7307c3d0, 0x3851bb77, 0x72f1aed9,
0x387eda8e, 0x72db8828, 0x38abf0ef, 0x72c54fc1,
0x38d8fe93, 0x72af05a7, 0x39060373, 0x7298a9dd,
0x3932ff87, 0x72823c67, 0x395ff2c9, 0x726bbd48,
0x398cdd32, 0x72552c85, 0x39b9bebc, 0x723e8a20,
0x39e6975e, 0x7227d61c, 0x3a136712, 0x7211107e,
0x3a402dd2, 0x71fa3949, 0x3a6ceb96, 0x71e35080,
0x3a99a057, 0x71cc5626, 0x3ac64c0f, 0x71b54a41,
0x3af2eeb7, 0x719e2cd2, 0x3b1f8848, 0x7186fdde,
0x3b4c18ba, 0x716fbd68, 0x3b78a007, 0x71586b74,
0x3ba51e29, 0x71410805, 0x3bd19318, 0x7129931f,
0x3bfdfecd, 0x71120cc5, 0x3c2a6142, 0x70fa74fc,
0x3c56ba70, 0x70e2cbc6, 0x3c830a50, 0x70cb1128,
0x3caf50da, 0x70b34525, 0x3cdb8e09, 0x709b67c0,
0x3d07c1d6, 0x708378ff, 0x3d33ec39, 0x706b78e3,
0x3d600d2c, 0x70536771, 0x3d8c24a8, 0x703b44ad,
0x3db832a6, 0x7023109a, 0x3de4371f, 0x700acb3c,
0x3e10320d, 0x6ff27497, 0x3e3c2369, 0x6fda0cae,
0x3e680b2c, 0x6fc19385, 0x3e93e950, 0x6fa90921,
0x3ebfbdcd, 0x6f906d84, 0x3eeb889c, 0x6f77c0b3,
0x3f1749b8, 0x6f5f02b2, 0x3f430119, 0x6f463383,
0x3f6eaeb8, 0x6f2d532c, 0x3f9a5290, 0x6f1461b0,
0x3fc5ec98, 0x6efb5f12, 0x3ff17cca, 0x6ee24b57,
0x401d0321, 0x6ec92683, 0x40487f94, 0x6eaff099,
0x4073f21d, 0x6e96a99d, 0x409f5ab6, 0x6e7d5193,
0x40cab958, 0x6e63e87f, 0x40f60dfb, 0x6e4a6e66,
0x4121589b, 0x6e30e34a, 0x414c992f, 0x6e174730,
0x4177cfb1, 0x6dfd9a1c, 0x41a2fc1a, 0x6de3dc11,
0x41ce1e65, 0x6dca0d14, 0x41f93689, 0x6db02d29,
0x42244481, 0x6d963c54, 0x424f4845, 0x6d7c3a98,
0x427a41d0, 0x6d6227fa, 0x42a5311b, 0x6d48047e,
0x42d0161e, 0x6d2dd027, 0x42faf0d4, 0x6d138afb,
0x4325c135, 0x6cf934fc, 0x4350873c, 0x6cdece2f,
0x437b42e1, 0x6cc45698, 0x43a5f41e, 0x6ca9ce3b,
0x43d09aed, 0x6c8f351c, 0x43fb3746, 0x6c748b3f,
0x4425c923, 0x6c59d0a9, 0x4450507e, 0x6c3f055d,
0x447acd50, 0x6c242960, 0x44a53f93, 0x6c093cb6,
0x44cfa740, 0x6bee3f62, 0x44fa0450, 0x6bd3316a,
0x452456bd, 0x6bb812d1, 0x454e9e80, 0x6b9ce39b,
0x4578db93, 0x6b81a3cd, 0x45a30df0, 0x6b66536b,
0x45cd358f, 0x6b4af279, 0x45f7526b, 0x6b2f80fb,
0x4621647d, 0x6b13fef5, 0x464b6bbe, 0x6af86c6c,
0x46756828, 0x6adcc964, 0x469f59b4, 0x6ac115e2,
0x46c9405c, 0x6aa551e9, 0x46f31c1a, 0x6a897d7d,
0x471cece7, 0x6a6d98a4, 0x4746b2bc, 0x6a51a361,
0x47706d93, 0x6a359db9, 0x479a1d67, 0x6a1987b0,
0x47c3c22f, 0x69fd614a, 0x47ed5be6, 0x69e12a8c,
0x4816ea86, 0x69c4e37a, 0x48406e08, 0x69a88c19,
0x4869e665, 0x698c246c, 0x48935397, 0x696fac78,
0x48bcb599, 0x69532442, 0x48e60c62, 0x69368bce,
0x490f57ee, 0x6919e320, 0x49389836, 0x68fd2a3d,
0x4961cd33, 0x68e06129, 0x498af6df, 0x68c387e9,
0x49b41533, 0x68a69e81, 0x49dd282a, 0x6889a4f6,
0x4a062fbd, 0x686c9b4b, 0x4a2f2be6, 0x684f8186,
0x4a581c9e, 0x683257ab, 0x4a8101de, 0x68151dbe,
0x4aa9dba2, 0x67f7d3c5, 0x4ad2a9e2, 0x67da79c3,
0x4afb6c98, 0x67bd0fbd, 0x4b2423be, 0x679f95b7,
0x4b4ccf4d, 0x67820bb7, 0x4b756f40, 0x676471c0,
0x4b9e0390, 0x6746c7d8, 0x4bc68c36, 0x67290e02,
0x4bef092d, 0x670b4444, 0x4c177a6e, 0x66ed6aa1,
0x4c3fdff4, 0x66cf8120, 0x4c6839b7, 0x66b187c3,
0x4c9087b1, 0x66937e91, 0x4cb8c9dd, 0x6675658c,
0x4ce10034, 0x66573cbb, 0x4d092ab0, 0x66390422,
0x4d31494b, 0x661abbc5, 0x4d595bfe, 0x65fc63a9,
0x4d8162c4, 0x65ddfbd3, 0x4da95d96, 0x65bf8447,
0x4dd14c6e, 0x65a0fd0b, 0x4df92f46, 0x65826622,
0x4e210617, 0x6563bf92, 0x4e48d0dd, 0x6545095f,
0x4e708f8f, 0x6526438f, 0x4e984229, 0x65076e25,
0x4ebfe8a5, 0x64e88926, 0x4ee782fb, 0x64c99498,
0x4f0f1126, 0x64aa907f, 0x4f369320, 0x648b7ce0,
0x4f5e08e3, 0x646c59bf, 0x4f857269, 0x644d2722,
0x4faccfab, 0x642de50d, 0x4fd420a4, 0x640e9386,
0x4ffb654d, 0x63ef3290, 0x50229da1, 0x63cfc231,
0x5049c999, 0x63b0426d, 0x5070e92f, 0x6390b34a,
0x5097fc5e, 0x637114cc, 0x50bf031f, 0x635166f9,
0x50e5fd6d, 0x6331a9d4, 0x510ceb40, 0x6311dd64,
0x5133cc94, 0x62f201ac, 0x515aa162, 0x62d216b3,
0x518169a5, 0x62b21c7b, 0x51a82555, 0x6292130c,
0x51ced46e, 0x6271fa69, 0x51f576ea, 0x6251d298,
0x521c0cc2, 0x62319b9d, 0x524295f0, 0x6211557e,
0x5269126e, 0x61f1003f, 0x528f8238, 0x61d09be5,
0x52b5e546, 0x61b02876, 0x52dc3b92, 0x618fa5f7,
0x53028518, 0x616f146c, 0x5328c1d0, 0x614e73da,
0x534ef1b5, 0x612dc447, 0x537514c2, 0x610d05b7,
0x539b2af0, 0x60ec3830, 0x53c13439, 0x60cb5bb7,
0x53e73097, 0x60aa7050, 0x540d2005, 0x60897601,
0x5433027d, 0x60686ccf, 0x5458d7f9, 0x604754bf,
0x547ea073, 0x60262dd6, 0x54a45be6, 0x6004f819,
0x54ca0a4b, 0x5fe3b38d, 0x54efab9c, 0x5fc26038,
0x55153fd4, 0x5fa0fe1f, 0x553ac6ee, 0x5f7f8d46,
0x556040e2, 0x5f5e0db3, 0x5585adad, 0x5f3c7f6b,
0x55ab0d46, 0x5f1ae274, 0x55d05faa, 0x5ef936d1,
0x55f5a4d2, 0x5ed77c8a, 0x561adcb9, 0x5eb5b3a2,
0x56400758, 0x5e93dc1f, 0x566524aa, 0x5e71f606,
0x568a34a9, 0x5e50015d, 0x56af3750, 0x5e2dfe29,
0x56d42c99, 0x5e0bec6e, 0x56f9147e, 0x5de9cc33,
0x571deefa, 0x5dc79d7c, 0x5742bc06, 0x5da5604f,
0x57677b9d, 0x5d8314b1, 0x578c2dba, 0x5d60baa7,
0x57b0d256, 0x5d3e5237, 0x57d5696d, 0x5d1bdb65,
0x57f9f2f8, 0x5cf95638, 0x581e6ef1, 0x5cd6c2b5,
0x5842dd54, 0x5cb420e0, 0x58673e1b, 0x5c9170bf,
0x588b9140, 0x5c6eb258, 0x58afd6bd, 0x5c4be5b0,
0x58d40e8c, 0x5c290acc, 0x58f838a9, 0x5c0621b2,
0x591c550e, 0x5be32a67, 0x594063b5, 0x5bc024f0,
0x59646498, 0x5b9d1154, 0x598857b2, 0x5b79ef96,
0x59ac3cfd, 0x5b56bfbd, 0x59d01475, 0x5b3381ce,
0x59f3de12, 0x5b1035cf, 0x5a1799d1, 0x5aecdbc5,
0x5a3b47ab, 0x5ac973b5, 0x5a5ee79a, 0x5aa5fda5,
0x5a82799a, 0x5a82799a
};
/* {sin((2*i+1)*PI/4096, cos((2*i+1)*PI/4096)}, with i = 0 to 511 */
const int32_t sincos_lookup1[1024] ICONST_ATTR = {
0x001921fb, 0x7ffffd88, 0x004b65ee, 0x7fffe9cb,
0x007da9d4, 0x7fffc251, 0x00afeda8, 0x7fff8719,
0x00e23160, 0x7fff3824, 0x011474f6, 0x7ffed572,
0x0146b860, 0x7ffe5f03, 0x0178fb99, 0x7ffdd4d7,
0x01ab3e97, 0x7ffd36ee, 0x01dd8154, 0x7ffc8549,
0x020fc3c6, 0x7ffbbfe6, 0x024205e8, 0x7ffae6c7,
0x027447b0, 0x7ff9f9ec, 0x02a68917, 0x7ff8f954,
0x02d8ca16, 0x7ff7e500, 0x030b0aa4, 0x7ff6bcf0,
0x033d4abb, 0x7ff58125, 0x036f8a51, 0x7ff4319d,
0x03a1c960, 0x7ff2ce5b, 0x03d407df, 0x7ff1575d,
0x040645c7, 0x7fefcca4, 0x04388310, 0x7fee2e30,
0x046abfb3, 0x7fec7c02, 0x049cfba7, 0x7feab61a,
0x04cf36e5, 0x7fe8dc78, 0x05017165, 0x7fe6ef1c,
0x0533ab20, 0x7fe4ee06, 0x0565e40d, 0x7fe2d938,
0x05981c26, 0x7fe0b0b1, 0x05ca5361, 0x7fde7471,
0x05fc89b8, 0x7fdc247a, 0x062ebf22, 0x7fd9c0ca,
0x0660f398, 0x7fd74964, 0x06932713, 0x7fd4be46,
0x06c5598a, 0x7fd21f72, 0x06f78af6, 0x7fcf6ce8,
0x0729bb4e, 0x7fcca6a7, 0x075bea8c, 0x7fc9ccb2,
0x078e18a7, 0x7fc6df08, 0x07c04598, 0x7fc3dda9,
0x07f27157, 0x7fc0c896, 0x08249bdd, 0x7fbd9fd0,
0x0856c520, 0x7fba6357, 0x0888ed1b, 0x7fb7132b,
0x08bb13c5, 0x7fb3af4e, 0x08ed3916, 0x7fb037bf,
0x091f5d06, 0x7facac7f, 0x09517f8f, 0x7fa90d8e,
0x0983a0a7, 0x7fa55aee, 0x09b5c048, 0x7fa1949e,
0x09e7de6a, 0x7f9dbaa0, 0x0a19fb04, 0x7f99ccf4,
0x0a4c1610, 0x7f95cb9a, 0x0a7e2f85, 0x7f91b694,
0x0ab0475c, 0x7f8d8de1, 0x0ae25d8d, 0x7f895182,
0x0b147211, 0x7f850179, 0x0b4684df, 0x7f809dc5,
0x0b7895f0, 0x7f7c2668, 0x0baaa53b, 0x7f779b62,
0x0bdcb2bb, 0x7f72fcb4, 0x0c0ebe66, 0x7f6e4a5e,
0x0c40c835, 0x7f698461, 0x0c72d020, 0x7f64aabf,
0x0ca4d620, 0x7f5fbd77, 0x0cd6da2d, 0x7f5abc8a,
0x0d08dc3f, 0x7f55a7fa, 0x0d3adc4e, 0x7f507fc7,
0x0d6cda53, 0x7f4b43f2, 0x0d9ed646, 0x7f45f47b,
0x0dd0d01f, 0x7f409164, 0x0e02c7d7, 0x7f3b1aad,
0x0e34bd66, 0x7f359057, 0x0e66b0c3, 0x7f2ff263,
0x0e98a1e9, 0x7f2a40d2, 0x0eca90ce, 0x7f247ba5,
0x0efc7d6b, 0x7f1ea2dc, 0x0f2e67b8, 0x7f18b679,
0x0f604faf, 0x7f12b67c, 0x0f923546, 0x7f0ca2e7,
0x0fc41876, 0x7f067bba, 0x0ff5f938, 0x7f0040f6,
0x1027d784, 0x7ef9f29d, 0x1059b352, 0x7ef390ae,
0x108b8c9b, 0x7eed1b2c, 0x10bd6356, 0x7ee69217,
0x10ef377d, 0x7edff570, 0x11210907, 0x7ed94538,
0x1152d7ed, 0x7ed28171, 0x1184a427, 0x7ecbaa1a,
0x11b66dad, 0x7ec4bf36, 0x11e83478, 0x7ebdc0c6,
0x1219f880, 0x7eb6aeca, 0x124bb9be, 0x7eaf8943,
0x127d7829, 0x7ea85033, 0x12af33ba, 0x7ea1039b,
0x12e0ec6a, 0x7e99a37c, 0x1312a230, 0x7e922fd6,
0x13445505, 0x7e8aa8ac, 0x137604e2, 0x7e830dff,
0x13a7b1bf, 0x7e7b5fce, 0x13d95b93, 0x7e739e1d,
0x140b0258, 0x7e6bc8eb, 0x143ca605, 0x7e63e03b,
0x146e4694, 0x7e5be40c, 0x149fe3fc, 0x7e53d462,
0x14d17e36, 0x7e4bb13c, 0x1503153a, 0x7e437a9c,
0x1534a901, 0x7e3b3083, 0x15663982, 0x7e32d2f4,
0x1597c6b7, 0x7e2a61ed, 0x15c95097, 0x7e21dd73,
0x15fad71b, 0x7e194584, 0x162c5a3b, 0x7e109a24,
0x165dd9f0, 0x7e07db52, 0x168f5632, 0x7dff0911,
0x16c0cef9, 0x7df62362, 0x16f2443e, 0x7ded2a47,
0x1723b5f9, 0x7de41dc0, 0x17552422, 0x7ddafdce,
0x17868eb3, 0x7dd1ca75, 0x17b7f5a3, 0x7dc883b4,
0x17e958ea, 0x7dbf298d, 0x181ab881, 0x7db5bc02,
0x184c1461, 0x7dac3b15, 0x187d6c82, 0x7da2a6c6,
0x18aec0db, 0x7d98ff17, 0x18e01167, 0x7d8f4409,
0x19115e1c, 0x7d85759f, 0x1942a6f3, 0x7d7b93da,
0x1973ebe6, 0x7d719eba, 0x19a52ceb, 0x7d679642,
0x19d669fc, 0x7d5d7a74, 0x1a07a311, 0x7d534b50,
0x1a38d823, 0x7d4908d9, 0x1a6a0929, 0x7d3eb30f,
0x1a9b361d, 0x7d3449f5, 0x1acc5ef6, 0x7d29cd8c,
0x1afd83ad, 0x7d1f3dd6, 0x1b2ea43a, 0x7d149ad5,
0x1b5fc097, 0x7d09e489, 0x1b90d8bb, 0x7cff1af5,
0x1bc1ec9e, 0x7cf43e1a, 0x1bf2fc3a, 0x7ce94dfb,
0x1c240786, 0x7cde4a98, 0x1c550e7c, 0x7cd333f3,
0x1c861113, 0x7cc80a0f, 0x1cb70f43, 0x7cbcccec,
0x1ce80906, 0x7cb17c8d, 0x1d18fe54, 0x7ca618f3,
0x1d49ef26, 0x7c9aa221, 0x1d7adb73, 0x7c8f1817,
0x1dabc334, 0x7c837ad8, 0x1ddca662, 0x7c77ca65,
0x1e0d84f5, 0x7c6c06c0, 0x1e3e5ee5, 0x7c602fec,
0x1e6f342c, 0x7c5445e9, 0x1ea004c1, 0x7c4848ba,
0x1ed0d09d, 0x7c3c3860, 0x1f0197b8, 0x7c3014de,
0x1f325a0b, 0x7c23de35, 0x1f63178f, 0x7c179467,
0x1f93d03c, 0x7c0b3777, 0x1fc4840a, 0x7bfec765,
0x1ff532f2, 0x7bf24434, 0x2025dcec, 0x7be5ade6,
0x205681f1, 0x7bd9047c, 0x208721f9, 0x7bcc47fa,
0x20b7bcfe, 0x7bbf7860, 0x20e852f6, 0x7bb295b0,
0x2118e3dc, 0x7ba59fee, 0x21496fa7, 0x7b989719,
0x2179f64f, 0x7b8b7b36, 0x21aa77cf, 0x7b7e4c45,
0x21daf41d, 0x7b710a49, 0x220b6b32, 0x7b63b543,
0x223bdd08, 0x7b564d36, 0x226c4996, 0x7b48d225,
0x229cb0d5, 0x7b3b4410, 0x22cd12bd, 0x7b2da2fa,
0x22fd6f48, 0x7b1feee5, 0x232dc66d, 0x7b1227d3,
0x235e1826, 0x7b044dc7, 0x238e646a, 0x7af660c2,
0x23beab33, 0x7ae860c7, 0x23eeec78, 0x7ada4dd8,
0x241f2833, 0x7acc27f7, 0x244f5e5c, 0x7abdef25,
0x247f8eec, 0x7aafa367, 0x24afb9da, 0x7aa144bc,
0x24dfdf20, 0x7a92d329, 0x250ffeb7, 0x7a844eae,
0x25401896, 0x7a75b74f, 0x25702cb7, 0x7a670d0d,
0x25a03b11, 0x7a584feb, 0x25d0439f, 0x7a497feb,
0x26004657, 0x7a3a9d0f, 0x26304333, 0x7a2ba75a,
0x26603a2c, 0x7a1c9ece, 0x26902b39, 0x7a0d836d,
0x26c01655, 0x79fe5539, 0x26effb76, 0x79ef1436,
0x271fda96, 0x79dfc064, 0x274fb3ae, 0x79d059c8,
0x277f86b5, 0x79c0e062, 0x27af53a6, 0x79b15435,
0x27df1a77, 0x79a1b545, 0x280edb23, 0x79920392,
0x283e95a1, 0x79823f20, 0x286e49ea, 0x797267f2,
0x289df7f8, 0x79627e08, 0x28cd9fc1, 0x79528167,
0x28fd4140, 0x79427210, 0x292cdc6d, 0x79325006,
0x295c7140, 0x79221b4b, 0x298bffb2, 0x7911d3e2,
0x29bb87bc, 0x790179cd, 0x29eb0957, 0x78f10d0f,
0x2a1a847b, 0x78e08dab, 0x2a49f920, 0x78cffba3,
0x2a796740, 0x78bf56f9, 0x2aa8ced3, 0x78ae9fb0,
0x2ad82fd2, 0x789dd5cb, 0x2b078a36, 0x788cf94c,
0x2b36ddf7, 0x787c0a36, 0x2b662b0e, 0x786b088c,
0x2b957173, 0x7859f44f, 0x2bc4b120, 0x7848cd83,
0x2bf3ea0d, 0x7837942b, 0x2c231c33, 0x78264849,
0x2c52478a, 0x7814e9df, 0x2c816c0c, 0x780378f1,
0x2cb089b1, 0x77f1f581, 0x2cdfa071, 0x77e05f91,
0x2d0eb046, 0x77ceb725, 0x2d3db928, 0x77bcfc3f,
0x2d6cbb10, 0x77ab2ee2, 0x2d9bb5f6, 0x77994f11,
0x2dcaa9d5, 0x77875cce, 0x2df996a3, 0x7775581d,
0x2e287c5a, 0x776340ff, 0x2e575af3, 0x77511778,
0x2e863267, 0x773edb8b, 0x2eb502ae, 0x772c8d3a,
0x2ee3cbc1, 0x771a2c88, 0x2f128d99, 0x7707b979,
0x2f41482e, 0x76f5340e, 0x2f6ffb7a, 0x76e29c4b,
0x2f9ea775, 0x76cff232, 0x2fcd4c19, 0x76bd35c7,
0x2ffbe95d, 0x76aa670d, 0x302a7f3a, 0x76978605,
0x30590dab, 0x768492b4, 0x308794a6, 0x76718d1c,
0x30b61426, 0x765e7540, 0x30e48c22, 0x764b4b23,
0x3112fc95, 0x76380ec8, 0x31416576, 0x7624c031,
0x316fc6be, 0x76115f63, 0x319e2067, 0x75fdec60,
0x31cc7269, 0x75ea672a, 0x31fabcbd, 0x75d6cfc5,
0x3228ff5c, 0x75c32634, 0x32573a3f, 0x75af6a7b,
0x32856d5e, 0x759b9c9b, 0x32b398b3, 0x7587bc98,
0x32e1bc36, 0x7573ca75, 0x330fd7e1, 0x755fc635,
0x333debab, 0x754bafdc, 0x336bf78f, 0x7537876c,
0x3399fb85, 0x75234ce8, 0x33c7f785, 0x750f0054,
0x33f5eb89, 0x74faa1b3, 0x3423d78a, 0x74e63108,
0x3451bb81, 0x74d1ae55, 0x347f9766, 0x74bd199f,
0x34ad6b32, 0x74a872e8, 0x34db36df, 0x7493ba34,
0x3508fa66, 0x747eef85, 0x3536b5be, 0x746a12df,
0x356468e2, 0x74552446, 0x359213c9, 0x744023bc,
0x35bfb66e, 0x742b1144, 0x35ed50c9, 0x7415ece2,
0x361ae2d3, 0x7400b69a, 0x36486c86, 0x73eb6e6e,
0x3675edd9, 0x73d61461, 0x36a366c6, 0x73c0a878,
0x36d0d746, 0x73ab2ab4, 0x36fe3f52, 0x73959b1b,
0x372b9ee3, 0x737ff9ae, 0x3758f5f2, 0x736a4671,
0x37864477, 0x73548168, 0x37b38a6d, 0x733eaa96,
0x37e0c7cc, 0x7328c1ff, 0x380dfc8d, 0x7312c7a5,
0x383b28a9, 0x72fcbb8c, 0x38684c19, 0x72e69db7,
0x389566d6, 0x72d06e2b, 0x38c278d9, 0x72ba2cea,
0x38ef821c, 0x72a3d9f7, 0x391c8297, 0x728d7557,
0x39497a43, 0x7276ff0d, 0x39766919, 0x7260771b,
0x39a34f13, 0x7249dd86, 0x39d02c2a, 0x72333251,
0x39fd0056, 0x721c7580, 0x3a29cb91, 0x7205a716,
0x3a568dd4, 0x71eec716, 0x3a834717, 0x71d7d585,
0x3aaff755, 0x71c0d265, 0x3adc9e86, 0x71a9bdba,
0x3b093ca3, 0x71929789, 0x3b35d1a5, 0x717b5fd3,
0x3b625d86, 0x7164169d, 0x3b8ee03e, 0x714cbbeb,
0x3bbb59c7, 0x71354fc0, 0x3be7ca1a, 0x711dd220,
0x3c143130, 0x7106430e, 0x3c408f03, 0x70eea28e,
0x3c6ce38a, 0x70d6f0a4, 0x3c992ec0, 0x70bf2d53,
0x3cc5709e, 0x70a7589f, 0x3cf1a91c, 0x708f728b,
0x3d1dd835, 0x70777b1c, 0x3d49fde1, 0x705f7255,
0x3d761a19, 0x70475839, 0x3da22cd7, 0x702f2ccd,
0x3dce3614, 0x7016f014, 0x3dfa35c8, 0x6ffea212,
0x3e262bee, 0x6fe642ca, 0x3e52187f, 0x6fcdd241,
0x3e7dfb73, 0x6fb5507a, 0x3ea9d4c3, 0x6f9cbd79,
0x3ed5a46b, 0x6f841942, 0x3f016a61, 0x6f6b63d8,
0x3f2d26a0, 0x6f529d40, 0x3f58d921, 0x6f39c57d,
0x3f8481dd, 0x6f20dc92, 0x3fb020ce, 0x6f07e285,
0x3fdbb5ec, 0x6eeed758, 0x40074132, 0x6ed5bb10,
0x4032c297, 0x6ebc8db0, 0x405e3a16, 0x6ea34f3d,
0x4089a7a8, 0x6e89ffb9, 0x40b50b46, 0x6e709f2a,
0x40e064ea, 0x6e572d93, 0x410bb48c, 0x6e3daaf8,
0x4136fa27, 0x6e24175c, 0x416235b2, 0x6e0a72c5,
0x418d6729, 0x6df0bd35, 0x41b88e84, 0x6dd6f6b1,
0x41e3abbc, 0x6dbd1f3c, 0x420ebecb, 0x6da336dc,
0x4239c7aa, 0x6d893d93, 0x4264c653, 0x6d6f3365,
0x428fbabe, 0x6d551858, 0x42baa4e6, 0x6d3aec6e,
0x42e584c3, 0x6d20afac, 0x43105a50, 0x6d066215,
0x433b2585, 0x6cec03af, 0x4365e65b, 0x6cd1947c,
0x43909ccd, 0x6cb71482, 0x43bb48d4, 0x6c9c83c3,
0x43e5ea68, 0x6c81e245, 0x44108184, 0x6c67300b,
0x443b0e21, 0x6c4c6d1a, 0x44659039, 0x6c319975,
0x449007c4, 0x6c16b521, 0x44ba74bd, 0x6bfbc021,
0x44e4d71c, 0x6be0ba7b, 0x450f2edb, 0x6bc5a431,
0x45397bf4, 0x6baa7d49, 0x4563be60, 0x6b8f45c7,
0x458df619, 0x6b73fdae, 0x45b82318, 0x6b58a503,
0x45e24556, 0x6b3d3bcb, 0x460c5cce, 0x6b21c208,
0x46366978, 0x6b0637c1, 0x46606b4e, 0x6aea9cf8,
0x468a624a, 0x6acef1b2, 0x46b44e65, 0x6ab335f4,
0x46de2f99, 0x6a9769c1, 0x470805df, 0x6a7b8d1e,
0x4731d131, 0x6a5fa010, 0x475b9188, 0x6a43a29a,
0x478546de, 0x6a2794c1, 0x47aef12c, 0x6a0b7689,
0x47d8906d, 0x69ef47f6, 0x48022499, 0x69d3090e,
0x482badab, 0x69b6b9d3, 0x48552b9b, 0x699a5a4c,
0x487e9e64, 0x697dea7b, 0x48a805ff, 0x69616a65,
0x48d16265, 0x6944da10, 0x48fab391, 0x6928397e,
0x4923f97b, 0x690b88b5, 0x494d341e, 0x68eec7b9,
0x49766373, 0x68d1f68f, 0x499f8774, 0x68b5153a,
0x49c8a01b, 0x689823bf, 0x49f1ad61, 0x687b2224,
0x4a1aaf3f, 0x685e106c, 0x4a43a5b0, 0x6840ee9b,
0x4a6c90ad, 0x6823bcb7, 0x4a957030, 0x68067ac3,
0x4abe4433, 0x67e928c5, 0x4ae70caf, 0x67cbc6c0,
0x4b0fc99d, 0x67ae54ba, 0x4b387af9, 0x6790d2b6,
0x4b6120bb, 0x677340ba, 0x4b89badd, 0x67559eca,
0x4bb24958, 0x6737ecea, 0x4bdacc28, 0x671a2b20,
0x4c034345, 0x66fc596f, 0x4c2baea9, 0x66de77dc,
0x4c540e4e, 0x66c0866d, 0x4c7c622d, 0x66a28524,
0x4ca4aa41, 0x66847408, 0x4ccce684, 0x6666531d,
0x4cf516ee, 0x66482267, 0x4d1d3b7a, 0x6629e1ec,
0x4d455422, 0x660b91af, 0x4d6d60df, 0x65ed31b5,
0x4d9561ac, 0x65cec204, 0x4dbd5682, 0x65b0429f,
0x4de53f5a, 0x6591b38c, 0x4e0d1c30, 0x657314cf,
0x4e34ecfc, 0x6554666d, 0x4e5cb1b9, 0x6535a86b,
0x4e846a60, 0x6516dacd, 0x4eac16eb, 0x64f7fd98,
0x4ed3b755, 0x64d910d1, 0x4efb4b96, 0x64ba147d,
0x4f22d3aa, 0x649b08a0, 0x4f4a4f89, 0x647bed3f,
0x4f71bf2e, 0x645cc260, 0x4f992293, 0x643d8806,
0x4fc079b1, 0x641e3e38, 0x4fe7c483, 0x63fee4f8,
0x500f0302, 0x63df7c4d, 0x50363529, 0x63c0043b,
0x505d5af1, 0x63a07cc7, 0x50847454, 0x6380e5f6,
0x50ab814d, 0x63613fcd, 0x50d281d5, 0x63418a50,
0x50f975e6, 0x6321c585, 0x51205d7b, 0x6301f171,
0x5147388c, 0x62e20e17, 0x516e0715, 0x62c21b7e,
0x5194c910, 0x62a219aa, 0x51bb7e75, 0x628208a1,
0x51e22740, 0x6261e866, 0x5208c36a, 0x6241b8ff,
0x522f52ee, 0x62217a72, 0x5255d5c5, 0x62012cc2,
0x527c4bea, 0x61e0cff5, 0x52a2b556, 0x61c06410,
0x52c91204, 0x619fe918, 0x52ef61ee, 0x617f5f12,
0x5315a50e, 0x615ec603, 0x533bdb5d, 0x613e1df0,
0x536204d7, 0x611d66de, 0x53882175, 0x60fca0d2,
0x53ae3131, 0x60dbcbd1, 0x53d43406, 0x60bae7e1,
0x53fa29ed, 0x6099f505, 0x542012e1, 0x6078f344,
0x5445eedb, 0x6057e2a2, 0x546bbdd7, 0x6036c325,
0x54917fce, 0x601594d1, 0x54b734ba, 0x5ff457ad,
0x54dcdc96, 0x5fd30bbc, 0x5502775c, 0x5fb1b104,
0x55280505, 0x5f90478a, 0x554d858d, 0x5f6ecf53,
0x5572f8ed, 0x5f4d4865, 0x55985f20, 0x5f2bb2c5,
0x55bdb81f, 0x5f0a0e77, 0x55e303e6, 0x5ee85b82,
0x5608426e, 0x5ec699e9, 0x562d73b2, 0x5ea4c9b3,
0x565297ab, 0x5e82eae5, 0x5677ae54, 0x5e60fd84,
0x569cb7a8, 0x5e3f0194, 0x56c1b3a1, 0x5e1cf71c,
0x56e6a239, 0x5dfade20, 0x570b8369, 0x5dd8b6a7,
0x5730572e, 0x5db680b4, 0x57551d80, 0x5d943c4e,
0x5779d65b, 0x5d71e979, 0x579e81b8, 0x5d4f883b,
0x57c31f92, 0x5d2d189a, 0x57e7afe4, 0x5d0a9a9a,
0x580c32a7, 0x5ce80e41, 0x5830a7d6, 0x5cc57394,
0x58550f6c, 0x5ca2ca99, 0x58796962, 0x5c801354,
0x589db5b3, 0x5c5d4dcc, 0x58c1f45b, 0x5c3a7a05,
0x58e62552, 0x5c179806, 0x590a4893, 0x5bf4a7d2,
0x592e5e19, 0x5bd1a971, 0x595265df, 0x5bae9ce7,
0x59765fde, 0x5b8b8239, 0x599a4c12, 0x5b68596d,
0x59be2a74, 0x5b452288, 0x59e1faff, 0x5b21dd90,
0x5a05bdae, 0x5afe8a8b, 0x5a29727b, 0x5adb297d,
0x5a4d1960, 0x5ab7ba6c, 0x5a70b258, 0x5a943d5e,
};
/*split radix bit reverse table for FFT of size up to 2048*/
const uint16_t revtab[1<<12] = {
0, 3072, 1536, 2816, 768, 3840, 1408, 2432, 384, 3456, 1920, 2752, 704,
3776, 1216, 2240, 192, 3264, 1728, 3008, 960, 4032, 1376, 2400, 352, 3424,
1888, 2656, 608, 3680, 1120, 2144, 96, 3168, 1632, 2912, 864, 3936, 1504,
2528, 480, 3552, 2016, 2736, 688, 3760, 1200, 2224, 176, 3248, 1712, 2992,
944, 4016, 1328, 2352, 304, 3376, 1840, 2608, 560, 3632, 1072, 2096, 48,
3120, 1584, 2864, 816, 3888, 1456, 2480, 432, 3504, 1968, 2800, 752, 3824,
1264, 2288, 240, 3312, 1776, 3056, 1008, 4080, 1368, 2392, 344, 3416, 1880,
2648, 600, 3672, 1112, 2136, 88, 3160, 1624, 2904, 856, 3928, 1496, 2520,
472, 3544, 2008, 2712, 664, 3736, 1176, 2200, 152, 3224, 1688, 2968, 920,
3992, 1304, 2328, 280, 3352, 1816, 2584, 536, 3608, 1048, 2072, 24, 3096,
1560, 2840, 792, 3864, 1432, 2456, 408, 3480, 1944, 2776, 728, 3800, 1240,
2264, 216, 3288, 1752, 3032, 984, 4056, 1400, 2424, 376, 3448, 1912, 2680,
632, 3704, 1144, 2168, 120, 3192, 1656, 2936, 888, 3960, 1528, 2552, 504,
3576, 2040, 2732, 684, 3756, 1196, 2220, 172, 3244, 1708, 2988, 940, 4012,
1324, 2348, 300, 3372, 1836, 2604, 556, 3628, 1068, 2092, 44, 3116, 1580,
2860, 812, 3884, 1452, 2476, 428, 3500, 1964, 2796, 748, 3820, 1260, 2284,
236, 3308, 1772, 3052, 1004, 4076, 1356, 2380, 332, 3404, 1868, 2636, 588,
3660, 1100, 2124, 76, 3148, 1612, 2892, 844, 3916, 1484, 2508, 460, 3532,
1996, 2700, 652, 3724, 1164, 2188, 140, 3212, 1676, 2956, 908, 3980, 1292,
2316, 268, 3340, 1804, 2572, 524, 3596, 1036, 2060, 12, 3084, 1548, 2828,
780, 3852, 1420, 2444, 396, 3468, 1932, 2764, 716, 3788, 1228, 2252, 204,
3276, 1740, 3020, 972, 4044, 1388, 2412, 364, 3436, 1900, 2668, 620, 3692,
1132, 2156, 108, 3180, 1644, 2924, 876, 3948, 1516, 2540, 492, 3564, 2028,
2748, 700, 3772, 1212, 2236, 188, 3260, 1724, 3004, 956, 4028, 1340, 2364,
316, 3388, 1852, 2620, 572, 3644, 1084, 2108, 60, 3132, 1596, 2876, 828,
3900, 1468, 2492, 444, 3516, 1980, 2812, 764, 3836, 1276, 2300, 252, 3324,
1788, 3068, 1020, 4092, 1366, 2390, 342, 3414, 1878, 2646, 598, 3670, 1110,
2134, 86, 3158, 1622, 2902, 854, 3926, 1494, 2518, 470, 3542, 2006, 2710,
662, 3734, 1174, 2198, 150, 3222, 1686, 2966, 918, 3990, 1302, 2326, 278,
3350, 1814, 2582, 534, 3606, 1046, 2070, 22, 3094, 1558, 2838, 790, 3862,
1430, 2454, 406, 3478, 1942, 2774, 726, 3798, 1238, 2262, 214, 3286, 1750,
3030, 982, 4054, 1398, 2422, 374, 3446, 1910, 2678, 630, 3702, 1142, 2166,
118, 3190, 1654, 2934, 886, 3958, 1526, 2550, 502, 3574, 2038, 2726, 678,
3750, 1190, 2214, 166, 3238, 1702, 2982, 934, 4006, 1318, 2342, 294, 3366,
1830, 2598, 550, 3622, 1062, 2086, 38, 3110, 1574, 2854, 806, 3878, 1446,
2470, 422, 3494, 1958, 2790, 742, 3814, 1254, 2278, 230, 3302, 1766, 3046,
998, 4070, 1350, 2374, 326, 3398, 1862, 2630, 582, 3654, 1094, 2118, 70,
3142, 1606, 2886, 838, 3910, 1478, 2502, 454, 3526, 1990, 2694, 646, 3718,
1158, 2182, 134, 3206, 1670, 2950, 902, 3974, 1286, 2310, 262, 3334, 1798,
2566, 518, 3590, 1030, 2054, 6, 3078, 1542, 2822, 774, 3846, 1414, 2438,
390, 3462, 1926, 2758, 710, 3782, 1222, 2246, 198, 3270, 1734, 3014, 966,
4038, 1382, 2406, 358, 3430, 1894, 2662, 614, 3686, 1126, 2150, 102, 3174,
1638, 2918, 870, 3942, 1510, 2534, 486, 3558, 2022, 2742, 694, 3766, 1206,
2230, 182, 3254, 1718, 2998, 950, 4022, 1334, 2358, 310, 3382, 1846, 2614,
566, 3638, 1078, 2102, 54, 3126, 1590, 2870, 822, 3894, 1462, 2486, 438,
3510, 1974, 2806, 758, 3830, 1270, 2294, 246, 3318, 1782, 3062, 1014, 4086,
1374, 2398, 350, 3422, 1886, 2654, 606, 3678, 1118, 2142, 94, 3166, 1630,
2910, 862, 3934, 1502, 2526, 478, 3550, 2014, 2718, 670, 3742, 1182, 2206,
158, 3230, 1694, 2974, 926, 3998, 1310, 2334, 286, 3358, 1822, 2590, 542,
3614, 1054, 2078, 30, 3102, 1566, 2846, 798, 3870, 1438, 2462, 414, 3486,
1950, 2782, 734, 3806, 1246, 2270, 222, 3294, 1758, 3038, 990, 4062, 1406,
2430, 382, 3454, 1918, 2686, 638, 3710, 1150, 2174, 126, 3198, 1662, 2942,
894, 3966, 1534, 2558, 510, 3582, 2046, 2731, 683, 3755, 1195, 2219, 171,
3243, 1707, 2987, 939, 4011, 1323, 2347, 299, 3371, 1835, 2603, 555, 3627,
1067, 2091, 43, 3115, 1579, 2859, 811, 3883, 1451, 2475, 427, 3499, 1963,
2795, 747, 3819, 1259, 2283, 235, 3307, 1771, 3051, 1003, 4075, 1355, 2379,
331, 3403, 1867, 2635, 587, 3659, 1099, 2123, 75, 3147, 1611, 2891, 843,
3915, 1483, 2507, 459, 3531, 1995, 2699, 651, 3723, 1163, 2187, 139, 3211,
1675, 2955, 907, 3979, 1291, 2315, 267, 3339, 1803, 2571, 523, 3595, 1035,
2059, 11, 3083, 1547, 2827, 779, 3851, 1419, 2443, 395, 3467, 1931, 2763,
715, 3787, 1227, 2251, 203, 3275, 1739, 3019, 971, 4043, 1387, 2411, 363,
3435, 1899, 2667, 619, 3691, 1131, 2155, 107, 3179, 1643, 2923, 875, 3947,
1515, 2539, 491, 3563, 2027, 2747, 699, 3771, 1211, 2235, 187, 3259, 1723,
3003, 955, 4027, 1339, 2363, 315, 3387, 1851, 2619, 571, 3643, 1083, 2107,
59, 3131, 1595, 2875, 827, 3899, 1467, 2491, 443, 3515, 1979, 2811, 763,
3835, 1275, 2299, 251, 3323, 1787, 3067, 1019, 4091, 1363, 2387, 339, 3411,
1875, 2643, 595, 3667, 1107, 2131, 83, 3155, 1619, 2899, 851, 3923, 1491,
2515, 467, 3539, 2003, 2707, 659, 3731, 1171, 2195, 147, 3219, 1683, 2963,
915, 3987, 1299, 2323, 275, 3347, 1811, 2579, 531, 3603, 1043, 2067, 19,
3091, 1555, 2835, 787, 3859, 1427, 2451, 403, 3475, 1939, 2771, 723, 3795,
1235, 2259, 211, 3283, 1747, 3027, 979, 4051, 1395, 2419, 371, 3443, 1907,
2675, 627, 3699, 1139, 2163, 115, 3187, 1651, 2931, 883, 3955, 1523, 2547,
499, 3571, 2035, 2723, 675, 3747, 1187, 2211, 163, 3235, 1699, 2979, 931,
4003, 1315, 2339, 291, 3363, 1827, 2595, 547, 3619, 1059, 2083, 35, 3107,
1571, 2851, 803, 3875, 1443, 2467, 419, 3491, 1955, 2787, 739, 3811, 1251,
2275, 227, 3299, 1763, 3043, 995, 4067, 1347, 2371, 323, 3395, 1859, 2627,
579, 3651, 1091, 2115, 67, 3139, 1603, 2883, 835, 3907, 1475, 2499, 451,
3523, 1987, 2691, 643, 3715, 1155, 2179, 131, 3203, 1667, 2947, 899, 3971,
1283, 2307, 259, 3331, 1795, 2563, 515, 3587, 1027, 2051, 3, 3075, 1539,
2819, 771, 3843, 1411, 2435, 387, 3459, 1923, 2755, 707, 3779, 1219, 2243,
195, 3267, 1731, 3011, 963, 4035, 1379, 2403, 355, 3427, 1891, 2659, 611,
3683, 1123, 2147, 99, 3171, 1635, 2915, 867, 3939, 1507, 2531, 483, 3555,
2019, 2739, 691, 3763, 1203, 2227, 179, 3251, 1715, 2995, 947, 4019, 1331,
2355, 307, 3379, 1843, 2611, 563, 3635, 1075, 2099, 51, 3123, 1587, 2867,
819, 3891, 1459, 2483, 435, 3507, 1971, 2803, 755, 3827, 1267, 2291, 243,
3315, 1779, 3059, 1011, 4083, 1371, 2395, 347, 3419, 1883, 2651, 603, 3675,
1115, 2139, 91, 3163, 1627, 2907, 859, 3931, 1499, 2523, 475, 3547, 2011,
2715, 667, 3739, 1179, 2203, 155, 3227, 1691, 2971, 923, 3995, 1307, 2331,
283, 3355, 1819, 2587, 539, 3611, 1051, 2075, 27, 3099, 1563, 2843, 795,
3867, 1435, 2459, 411, 3483, 1947, 2779, 731, 3803, 1243, 2267, 219, 3291,
1755, 3035, 987, 4059, 1403, 2427, 379, 3451, 1915, 2683, 635, 3707, 1147,
2171, 123, 3195, 1659, 2939, 891, 3963, 1531, 2555, 507, 3579, 2043, 2735,
687, 3759, 1199, 2223, 175, 3247, 1711, 2991, 943, 4015, 1327, 2351, 303,
3375, 1839, 2607, 559, 3631, 1071, 2095, 47, 3119, 1583, 2863, 815, 3887,
1455, 2479, 431, 3503, 1967, 2799, 751, 3823, 1263, 2287, 239, 3311, 1775,
3055, 1007, 4079, 1359, 2383, 335, 3407, 1871, 2639, 591, 3663, 1103, 2127,
79, 3151, 1615, 2895, 847, 3919, 1487, 2511, 463, 3535, 1999, 2703, 655,
3727, 1167, 2191, 143, 3215, 1679, 2959, 911, 3983, 1295, 2319, 271, 3343,
1807, 2575, 527, 3599, 1039, 2063, 15, 3087, 1551, 2831, 783, 3855, 1423,
2447, 399, 3471, 1935, 2767, 719, 3791, 1231, 2255, 207, 3279, 1743, 3023,
975, 4047, 1391, 2415, 367, 3439, 1903, 2671, 623, 3695, 1135, 2159, 111,
3183, 1647, 2927, 879, 3951, 1519, 2543, 495, 3567, 2031, 2751, 703, 3775,
1215, 2239, 191, 3263, 1727, 3007, 959, 4031, 1343, 2367, 319, 3391, 1855,
2623, 575, 3647, 1087, 2111, 63, 3135, 1599, 2879, 831, 3903, 1471, 2495,
447, 3519, 1983, 2815, 767, 3839, 1279, 2303, 255, 3327, 1791, 3071, 1023,
4095, 1365, 2389, 341, 3413, 1877, 2645, 597, 3669, 1109, 2133, 85, 3157,
1621, 2901, 853, 3925, 1493, 2517, 469, 3541, 2005, 2709, 661, 3733, 1173,
2197, 149, 3221, 1685, 2965, 917, 3989, 1301, 2325, 277, 3349, 1813, 2581,
533, 3605, 1045, 2069, 21, 3093, 1557, 2837, 789, 3861, 1429, 2453, 405,
3477, 1941, 2773, 725, 3797, 1237, 2261, 213, 3285, 1749, 3029, 981, 4053,
1397, 2421, 373, 3445, 1909, 2677, 629, 3701, 1141, 2165, 117, 3189, 1653,
2933, 885, 3957, 1525, 2549, 501, 3573, 2037, 2725, 677, 3749, 1189, 2213,
165, 3237, 1701, 2981, 933, 4005, 1317, 2341, 293, 3365, 1829, 2597, 549,
3621, 1061, 2085, 37, 3109, 1573, 2853, 805, 3877, 1445, 2469, 421, 3493,
1957, 2789, 741, 3813, 1253, 2277, 229, 3301, 1765, 3045, 997, 4069, 1349,
2373, 325, 3397, 1861, 2629, 581, 3653, 1093, 2117, 69, 3141, 1605, 2885,
837, 3909, 1477, 2501, 453, 3525, 1989, 2693, 645, 3717, 1157, 2181, 133,
3205, 1669, 2949, 901, 3973, 1285, 2309, 261, 3333, 1797, 2565, 517, 3589,
1029, 2053, 5, 3077, 1541, 2821, 773, 3845, 1413, 2437, 389, 3461, 1925,
2757, 709, 3781, 1221, 2245, 197, 3269, 1733, 3013, 965, 4037, 1381, 2405,
357, 3429, 1893, 2661, 613, 3685, 1125, 2149, 101, 3173, 1637, 2917, 869,
3941, 1509, 2533, 485, 3557, 2021, 2741, 693, 3765, 1205, 2229, 181, 3253,
1717, 2997, 949, 4021, 1333, 2357, 309, 3381, 1845, 2613, 565, 3637, 1077,
2101, 53, 3125, 1589, 2869, 821, 3893, 1461, 2485, 437, 3509, 1973, 2805,
757, 3829, 1269, 2293, 245, 3317, 1781, 3061, 1013, 4085, 1373, 2397, 349,
3421, 1885, 2653, 605, 3677, 1117, 2141, 93, 3165, 1629, 2909, 861, 3933,
1501, 2525, 477, 3549, 2013, 2717, 669, 3741, 1181, 2205, 157, 3229, 1693,
2973, 925, 3997, 1309, 2333, 285, 3357, 1821, 2589, 541, 3613, 1053, 2077,
29, 3101, 1565, 2845, 797, 3869, 1437, 2461, 413, 3485, 1949, 2781, 733,
3805, 1245, 2269, 221, 3293, 1757, 3037, 989, 4061, 1405, 2429, 381, 3453,
1917, 2685, 637, 3709, 1149, 2173, 125, 3197, 1661, 2941, 893, 3965, 1533,
2557, 509, 3581, 2045, 2729, 681, 3753, 1193, 2217, 169, 3241, 1705, 2985,
937, 4009, 1321, 2345, 297, 3369, 1833, 2601, 553, 3625, 1065, 2089, 41,
3113, 1577, 2857, 809, 3881, 1449, 2473, 425, 3497, 1961, 2793, 745, 3817,
1257, 2281, 233, 3305, 1769, 3049, 1001, 4073, 1353, 2377, 329, 3401, 1865,
2633, 585, 3657, 1097, 2121, 73, 3145, 1609, 2889, 841, 3913, 1481, 2505,
457, 3529, 1993, 2697, 649, 3721, 1161, 2185, 137, 3209, 1673, 2953, 905,
3977, 1289, 2313, 265, 3337, 1801, 2569, 521, 3593, 1033, 2057, 9, 3081,
1545, 2825, 777, 3849, 1417, 2441, 393, 3465, 1929, 2761, 713, 3785, 1225,
2249, 201, 3273, 1737, 3017, 969, 4041, 1385, 2409, 361, 3433, 1897, 2665,
617, 3689, 1129, 2153, 105, 3177, 1641, 2921, 873, 3945, 1513, 2537, 489,
3561, 2025, 2745, 697, 3769, 1209, 2233, 185, 3257, 1721, 3001, 953, 4025,
1337, 2361, 313, 3385, 1849, 2617, 569, 3641, 1081, 2105, 57, 3129, 1593,
2873, 825, 3897, 1465, 2489, 441, 3513, 1977, 2809, 761, 3833, 1273, 2297,
249, 3321, 1785, 3065, 1017, 4089, 1361, 2385, 337, 3409, 1873, 2641, 593,
3665, 1105, 2129, 81, 3153, 1617, 2897, 849, 3921, 1489, 2513, 465, 3537,
2001, 2705, 657, 3729, 1169, 2193, 145, 3217, 1681, 2961, 913, 3985, 1297,
2321, 273, 3345, 1809, 2577, 529, 3601, 1041, 2065, 17, 3089, 1553, 2833,
785, 3857, 1425, 2449, 401, 3473, 1937, 2769, 721, 3793, 1233, 2257, 209,
3281, 1745, 3025, 977, 4049, 1393, 2417, 369, 3441, 1905, 2673, 625, 3697,
1137, 2161, 113, 3185, 1649, 2929, 881, 3953, 1521, 2545, 497, 3569, 2033,
2721, 673, 3745, 1185, 2209, 161, 3233, 1697, 2977, 929, 4001, 1313, 2337,
289, 3361, 1825, 2593, 545, 3617, 1057, 2081, 33, 3105, 1569, 2849, 801,
3873, 1441, 2465, 417, 3489, 1953, 2785, 737, 3809, 1249, 2273, 225, 3297,
1761, 3041, 993, 4065, 1345, 2369, 321, 3393, 1857, 2625, 577, 3649, 1089,
2113, 65, 3137, 1601, 2881, 833, 3905, 1473, 2497, 449, 3521, 1985, 2689,
641, 3713, 1153, 2177, 129, 3201, 1665, 2945, 897, 3969, 1281, 2305, 257,
3329, 1793, 2561, 513, 3585, 1025, 2049, 1, 3073, 1537, 2817, 769, 3841,
1409, 2433, 385, 3457, 1921, 2753, 705, 3777, 1217, 2241, 193, 3265, 1729,
3009, 961, 4033, 1377, 2401, 353, 3425, 1889, 2657, 609, 3681, 1121, 2145,
97, 3169, 1633, 2913, 865, 3937, 1505, 2529, 481, 3553, 2017, 2737, 689,
3761, 1201, 2225, 177, 3249, 1713, 2993, 945, 4017, 1329, 2353, 305, 3377,
1841, 2609, 561, 3633, 1073, 2097, 49, 3121, 1585, 2865, 817, 3889, 1457,
2481, 433, 3505, 1969, 2801, 753, 3825, 1265, 2289, 241, 3313, 1777, 3057,
1009, 4081, 1369, 2393, 345, 3417, 1881, 2649, 601, 3673, 1113, 2137, 89,
3161, 1625, 2905, 857, 3929, 1497, 2521, 473, 3545, 2009, 2713, 665, 3737,
1177, 2201, 153, 3225, 1689, 2969, 921, 3993, 1305, 2329, 281, 3353, 1817,
2585, 537, 3609, 1049, 2073, 25, 3097, 1561, 2841, 793, 3865, 1433, 2457,
409, 3481, 1945, 2777, 729, 3801, 1241, 2265, 217, 3289, 1753, 3033, 985,
4057, 1401, 2425, 377, 3449, 1913, 2681, 633, 3705, 1145, 2169, 121, 3193,
1657, 2937, 889, 3961, 1529, 2553, 505, 3577, 2041, 2733, 685, 3757, 1197,
2221, 173, 3245, 1709, 2989, 941, 4013, 1325, 2349, 301, 3373, 1837, 2605,
557, 3629, 1069, 2093, 45, 3117, 1581, 2861, 813, 3885, 1453, 2477, 429,
3501, 1965, 2797, 749, 3821, 1261, 2285, 237, 3309, 1773, 3053, 1005, 4077,
1357, 2381, 333, 3405, 1869, 2637, 589, 3661, 1101, 2125, 77, 3149, 1613,
2893, 845, 3917, 1485, 2509, 461, 3533, 1997, 2701, 653, 3725, 1165, 2189,
141, 3213, 1677, 2957, 909, 3981, 1293, 2317, 269, 3341, 1805, 2573, 525,
3597, 1037, 2061, 13, 3085, 1549, 2829, 781, 3853, 1421, 2445, 397, 3469,
1933, 2765, 717, 3789, 1229, 2253, 205, 3277, 1741, 3021, 973, 4045, 1389,
2413, 365, 3437, 1901, 2669, 621, 3693, 1133, 2157, 109, 3181, 1645, 2925,
877, 3949, 1517, 2541, 493, 3565, 2029, 2749, 701, 3773, 1213, 2237, 189,
3261, 1725, 3005, 957, 4029, 1341, 2365, 317, 3389, 1853, 2621, 573, 3645,
1085, 2109, 61, 3133, 1597, 2877, 829, 3901, 1469, 2493, 445, 3517, 1981,
2813, 765, 3837, 1277, 2301, 253, 3325, 1789, 3069, 1021, 4093, 1367, 2391,
343, 3415, 1879, 2647, 599, 3671, 1111, 2135, 87, 3159, 1623, 2903, 855,
3927, 1495, 2519, 471, 3543, 2007, 2711, 663, 3735, 1175, 2199, 151, 3223,
1687, 2967, 919, 3991, 1303, 2327, 279, 3351, 1815, 2583, 535, 3607, 1047,
2071, 23, 3095, 1559, 2839, 791, 3863, 1431, 2455, 407, 3479, 1943, 2775,
727, 3799, 1239, 2263, 215, 3287, 1751, 3031, 983, 4055, 1399, 2423, 375,
3447, 1911, 2679, 631, 3703, 1143, 2167, 119, 3191, 1655, 2935, 887, 3959,
1527, 2551, 503, 3575, 2039, 2727, 679, 3751, 1191, 2215, 167, 3239, 1703,
2983, 935, 4007, 1319, 2343, 295, 3367, 1831, 2599, 551, 3623, 1063, 2087,
39, 3111, 1575, 2855, 807, 3879, 1447, 2471, 423, 3495, 1959, 2791, 743,
3815, 1255, 2279, 231, 3303, 1767, 3047, 999, 4071, 1351, 2375, 327, 3399,
1863, 2631, 583, 3655, 1095, 2119, 71, 3143, 1607, 2887, 839, 3911, 1479,
2503, 455, 3527, 1991, 2695, 647, 3719, 1159, 2183, 135, 3207, 1671, 2951,
903, 3975, 1287, 2311, 263, 3335, 1799, 2567, 519, 3591, 1031, 2055, 7,
3079, 1543, 2823, 775, 3847, 1415, 2439, 391, 3463, 1927, 2759, 711, 3783,
1223, 2247, 199, 3271, 1735, 3015, 967, 4039, 1383, 2407, 359, 3431, 1895,
2663, 615, 3687, 1127, 2151, 103, 3175, 1639, 2919, 871, 3943, 1511, 2535,
487, 3559, 2023, 2743, 695, 3767, 1207, 2231, 183, 3255, 1719, 2999, 951,
4023, 1335, 2359, 311, 3383, 1847, 2615, 567, 3639, 1079, 2103, 55, 3127,
1591, 2871, 823, 3895, 1463, 2487, 439, 3511, 1975, 2807, 759, 3831, 1271,
2295, 247, 3319, 1783, 3063, 1015, 4087, 1375, 2399, 351, 3423, 1887, 2655,
607, 3679, 1119, 2143, 95, 3167, 1631, 2911, 863, 3935, 1503, 2527, 479,
3551, 2015, 2719, 671, 3743, 1183, 2207, 159, 3231, 1695, 2975, 927, 3999,
1311, 2335, 287, 3359, 1823, 2591, 543, 3615, 1055, 2079, 31, 3103, 1567,
2847, 799, 3871, 1439, 2463, 415, 3487, 1951, 2783, 735, 3807, 1247, 2271,
223, 3295, 1759, 3039, 991, 4063, 1407, 2431, 383, 3455, 1919, 2687, 639,
3711, 1151, 2175, 127, 3199, 1663, 2943, 895, 3967, 1535, 2559, 511, 3583,
2047, 2730, 682, 3754, 1194, 2218, 170, 3242, 1706, 2986, 938, 4010, 1322,
2346, 298, 3370, 1834, 2602, 554, 3626, 1066, 2090, 42, 3114, 1578, 2858,
810, 3882, 1450, 2474, 426, 3498, 1962, 2794, 746, 3818, 1258, 2282, 234,
3306, 1770, 3050, 1002, 4074, 1354, 2378, 330, 3402, 1866, 2634, 586, 3658,
1098, 2122, 74, 3146, 1610, 2890, 842, 3914, 1482, 2506, 458, 3530, 1994,
2698, 650, 3722, 1162, 2186, 138, 3210, 1674, 2954, 906, 3978, 1290, 2314,
266, 3338, 1802, 2570, 522, 3594, 1034, 2058, 10, 3082, 1546, 2826, 778,
3850, 1418, 2442, 394, 3466, 1930, 2762, 714, 3786, 1226, 2250, 202, 3274,
1738, 3018, 970, 4042, 1386, 2410, 362, 3434, 1898, 2666, 618, 3690, 1130,
2154, 106, 3178, 1642, 2922, 874, 3946, 1514, 2538, 490, 3562, 2026, 2746,
698, 3770, 1210, 2234, 186, 3258, 1722, 3002, 954, 4026, 1338, 2362, 314,
3386, 1850, 2618, 570, 3642, 1082, 2106, 58, 3130, 1594, 2874, 826, 3898,
1466, 2490, 442, 3514, 1978, 2810, 762, 3834, 1274, 2298, 250, 3322, 1786,
3066, 1018, 4090, 1362, 2386, 338, 3410, 1874, 2642, 594, 3666, 1106, 2130,
82, 3154, 1618, 2898, 850, 3922, 1490, 2514, 466, 3538, 2002, 2706, 658,
3730, 1170, 2194, 146, 3218, 1682, 2962, 914, 3986, 1298, 2322, 274, 3346,
1810, 2578, 530, 3602, 1042, 2066, 18, 3090, 1554, 2834, 786, 3858, 1426,
2450, 402, 3474, 1938, 2770, 722, 3794, 1234, 2258, 210, 3282, 1746, 3026,
978, 4050, 1394, 2418, 370, 3442, 1906, 2674, 626, 3698, 1138, 2162, 114,
3186, 1650, 2930, 882, 3954, 1522, 2546, 498, 3570, 2034, 2722, 674, 3746,
1186, 2210, 162, 3234, 1698, 2978, 930, 4002, 1314, 2338, 290, 3362, 1826,
2594, 546, 3618, 1058, 2082, 34, 3106, 1570, 2850, 802, 3874, 1442, 2466,
418, 3490, 1954, 2786, 738, 3810, 1250, 2274, 226, 3298, 1762, 3042, 994,
4066, 1346, 2370, 322, 3394, 1858, 2626, 578, 3650, 1090, 2114, 66, 3138,
1602, 2882, 834, 3906, 1474, 2498, 450, 3522, 1986, 2690, 642, 3714, 1154,
2178, 130, 3202, 1666, 2946, 898, 3970, 1282, 2306, 258, 3330, 1794, 2562,
514, 3586, 1026, 2050, 2, 3074, 1538, 2818, 770, 3842, 1410, 2434, 386,
3458, 1922, 2754, 706, 3778, 1218, 2242, 194, 3266, 1730, 3010, 962, 4034,
1378, 2402, 354, 3426, 1890, 2658, 610, 3682, 1122, 2146, 98, 3170, 1634,
2914, 866, 3938, 1506, 2530, 482, 3554, 2018, 2738, 690, 3762, 1202, 2226,
178, 3250, 1714, 2994, 946, 4018, 1330, 2354, 306, 3378, 1842, 2610, 562,
3634, 1074, 2098, 50, 3122, 1586, 2866, 818, 3890, 1458, 2482, 434, 3506,
1970, 2802, 754, 3826, 1266, 2290, 242, 3314, 1778, 3058, 1010, 4082, 1370,
2394, 346, 3418, 1882, 2650, 602, 3674, 1114, 2138, 90, 3162, 1626, 2906,
858, 3930, 1498, 2522, 474, 3546, 2010, 2714, 666, 3738, 1178, 2202, 154,
3226, 1690, 2970, 922, 3994, 1306, 2330, 282, 3354, 1818, 2586, 538, 3610,
1050, 2074, 26, 3098, 1562, 2842, 794, 3866, 1434, 2458, 410, 3482, 1946,
2778, 730, 3802, 1242, 2266, 218, 3290, 1754, 3034, 986, 4058, 1402, 2426,
378, 3450, 1914, 2682, 634, 3706, 1146, 2170, 122, 3194, 1658, 2938, 890,
3962, 1530, 2554, 506, 3578, 2042, 2734, 686, 3758, 1198, 2222, 174, 3246,
1710, 2990, 942, 4014, 1326, 2350, 302, 3374, 1838, 2606, 558, 3630, 1070,
2094, 46, 3118, 1582, 2862, 814, 3886, 1454, 2478, 430, 3502, 1966, 2798,
750, 3822, 1262, 2286, 238, 3310, 1774, 3054, 1006, 4078, 1358, 2382, 334,
3406, 1870, 2638, 590, 3662, 1102, 2126, 78, 3150, 1614, 2894, 846, 3918,
1486, 2510, 462, 3534, 1998, 2702, 654, 3726, 1166, 2190, 142, 3214, 1678,
2958, 910, 3982, 1294, 2318, 270, 3342, 1806, 2574, 526, 3598, 1038, 2062,
14, 3086, 1550, 2830, 782, 3854, 1422, 2446, 398, 3470, 1934, 2766, 718,
3790, 1230, 2254, 206, 3278, 1742, 3022, 974, 4046, 1390, 2414, 366, 3438,
1902, 2670, 622, 3694, 1134, 2158, 110, 3182, 1646, 2926, 878, 3950, 1518,
2542, 494, 3566, 2030, 2750, 702, 3774, 1214, 2238, 190, 3262, 1726, 3006,
958, 4030, 1342, 2366, 318, 3390, 1854, 2622, 574, 3646, 1086, 2110, 62,
3134, 1598, 2878, 830, 3902, 1470, 2494, 446, 3518, 1982, 2814, 766, 3838,
1278, 2302, 254, 3326, 1790, 3070, 1022, 4094, 1364, 2388, 340, 3412, 1876,
2644, 596, 3668, 1108, 2132, 84, 3156, 1620, 2900, 852, 3924, 1492, 2516,
468, 3540, 2004, 2708, 660, 3732, 1172, 2196, 148, 3220, 1684, 2964, 916,
3988, 1300, 2324, 276, 3348, 1812, 2580, 532, 3604, 1044, 2068, 20, 3092,
1556, 2836, 788, 3860, 1428, 2452, 404, 3476, 1940, 2772, 724, 3796, 1236,
2260, 212, 3284, 1748, 3028, 980, 4052, 1396, 2420, 372, 3444, 1908, 2676,
628, 3700, 1140, 2164, 116, 3188, 1652, 2932, 884, 3956, 1524, 2548, 500,
3572, 2036, 2724, 676, 3748, 1188, 2212, 164, 3236, 1700, 2980, 932, 4004,
1316, 2340, 292, 3364, 1828, 2596, 548, 3620, 1060, 2084, 36, 3108, 1572,
2852, 804, 3876, 1444, 2468, 420, 3492, 1956, 2788, 740, 3812, 1252, 2276,
228, 3300, 1764, 3044, 996, 4068, 1348, 2372, 324, 3396, 1860, 2628, 580,
3652, 1092, 2116, 68, 3140, 1604, 2884, 836, 3908, 1476, 2500, 452, 3524,
1988, 2692, 644, 3716, 1156, 2180, 132, 3204, 1668, 2948, 900, 3972, 1284,
2308, 260, 3332, 1796, 2564, 516, 3588, 1028, 2052, 4, 3076, 1540, 2820,
772, 3844, 1412, 2436, 388, 3460, 1924, 2756, 708, 3780, 1220, 2244, 196,
3268, 1732, 3012, 964, 4036, 1380, 2404, 356, 3428, 1892, 2660, 612, 3684,
1124, 2148, 100, 3172, 1636, 2916, 868, 3940, 1508, 2532, 484, 3556, 2020,
2740, 692, 3764, 1204, 2228, 180, 3252, 1716, 2996, 948, 4020, 1332, 2356,
308, 3380, 1844, 2612, 564, 3636, 1076, 2100, 52, 3124, 1588, 2868, 820,
3892, 1460, 2484, 436, 3508, 1972, 2804, 756, 3828, 1268, 2292, 244, 3316,
1780, 3060, 1012, 4084, 1372, 2396, 348, 3420, 1884, 2652, 604, 3676, 1116,
2140, 92, 3164, 1628, 2908, 860, 3932, 1500, 2524, 476, 3548, 2012, 2716,
668, 3740, 1180, 2204, 156, 3228, 1692, 2972, 924, 3996, 1308, 2332, 284,
3356, 1820, 2588, 540, 3612, 1052, 2076, 28, 3100, 1564, 2844, 796, 3868,
1436, 2460, 412, 3484, 1948, 2780, 732, 3804, 1244, 2268, 220, 3292, 1756,
3036, 988, 4060, 1404, 2428, 380, 3452, 1916, 2684, 636, 3708, 1148, 2172,
124, 3196, 1660, 2940, 892, 3964, 1532, 2556, 508, 3580, 2044, 2728, 680,
3752, 1192, 2216, 168, 3240, 1704, 2984, 936, 4008, 1320, 2344, 296, 3368,
1832, 2600, 552, 3624, 1064, 2088, 40, 3112, 1576, 2856, 808, 3880, 1448,
2472, 424, 3496, 1960, 2792, 744, 3816, 1256, 2280, 232, 3304, 1768, 3048,
1000, 4072, 1352, 2376, 328, 3400, 1864, 2632, 584, 3656, 1096, 2120, 72,
3144, 1608, 2888, 840, 3912, 1480, 2504, 456, 3528, 1992, 2696, 648, 3720,
1160, 2184, 136, 3208, 1672, 2952, 904, 3976, 1288, 2312, 264, 3336, 1800,
2568, 520, 3592, 1032, 2056, 8, 3080, 1544, 2824, 776, 3848, 1416, 2440,
392, 3464, 1928, 2760, 712, 3784, 1224, 2248, 200, 3272, 1736, 3016, 968,
4040, 1384, 2408, 360, 3432, 1896, 2664, 616, 3688, 1128, 2152, 104, 3176,
1640, 2920, 872, 3944, 1512, 2536, 488, 3560, 2024, 2744, 696, 3768, 1208,
2232, 184, 3256, 1720, 3000, 952, 4024, 1336, 2360, 312, 3384, 1848, 2616,
568, 3640, 1080, 2104, 56, 3128, 1592, 2872, 824, 3896, 1464, 2488, 440,
3512, 1976, 2808, 760, 3832, 1272, 2296, 248, 3320, 1784, 3064, 1016, 4088,
1360, 2384, 336, 3408, 1872, 2640, 592, 3664, 1104, 2128, 80, 3152, 1616,
2896, 848, 3920, 1488, 2512, 464, 3536, 2000, 2704, 656, 3728, 1168, 2192,
144, 3216, 1680, 2960, 912, 3984, 1296, 2320, 272, 3344, 1808, 2576, 528,
3600, 1040, 2064, 16, 3088, 1552, 2832, 784, 3856, 1424, 2448, 400, 3472,
1936, 2768, 720, 3792, 1232, 2256, 208, 3280, 1744, 3024, 976, 4048, 1392,
2416, 368, 3440, 1904, 2672, 624, 3696, 1136, 2160, 112, 3184, 1648, 2928,
880, 3952, 1520, 2544, 496, 3568, 2032, 2720, 672, 3744, 1184, 2208, 160,
3232, 1696, 2976, 928, 4000, 1312, 2336, 288, 3360, 1824, 2592, 544, 3616,
1056, 2080, 32, 3104, 1568, 2848, 800, 3872, 1440, 2464, 416, 3488, 1952,
2784, 736, 3808, 1248, 2272, 224, 3296, 1760, 3040, 992, 4064, 1344, 2368,
320, 3392, 1856, 2624, 576, 3648, 1088, 2112, 64, 3136, 1600, 2880, 832,
3904, 1472, 2496, 448, 3520, 1984, 2688, 640, 3712, 1152, 2176, 128, 3200,
1664, 2944, 896, 3968, 1280, 2304, 256, 3328, 1792, 2560, 512, 3584, 1024,
2048};

24
lib/rbcodec/codecs/lib/mdct_lookup.h Normal file
View file

@ -0,0 +1,24 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
* *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
* BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
* *
********************************************************************
function: sin,cos lookup tables
********************************************************************/
extern const int32_t sincos_lookup0[1026];
extern const int32_t sincos_lookup1[1024];
extern const uint16_t revtab[1<<12];

0
lib/rbcodec/codecs/lib/osx.dummy.c Normal file
View file