diff options
author | Sean Bartell <wingedtachikoma@gmail.com> | 2011-06-25 21:32:25 -0400 |
---|---|---|
committer | Nils Wallménius <nils@rockbox.org> | 2012-04-25 22:13:20 +0200 |
commit | f40bfc9267b13b54e6379dfe7539447662879d24 (patch) | |
tree | 9b20069d5e62809ff434061ad730096836f916f2 /lib/rbcodec/codecs/libtremor | |
parent | a0009907de7a0107d49040d8a180f140e2eff299 (diff) | |
download | rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.tar.gz rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.zip |
Add codecs to librbcodec.
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>
Diffstat (limited to 'lib/rbcodec/codecs/libtremor')
40 files changed, 12764 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libtremor/CHANGELOG b/lib/rbcodec/codecs/libtremor/CHANGELOG new file mode 100644 index 0000000000..53f23351e2 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/CHANGELOG | |||
@@ -0,0 +1,19 @@ | |||
1 | *** 20020517: 1.0.2 *** | ||
2 | |||
3 | Playback bugfix to floor1; mode mistakenly used for sizing instead | ||
4 | of blockflag | ||
5 | |||
6 | *** 20020515: 1.0.1 *** | ||
7 | |||
8 | Added complete API documentation to source tarball. No code | ||
9 | changes. | ||
10 | |||
11 | *** 20020412: 1.0.1 *** | ||
12 | |||
13 | Fixed a clipping bug that affected ARM processors; negative | ||
14 | overflows were being properly clipped, but then clobbered to | ||
15 | positive by the positive overflow chec (asm_arm.h:CLIP_TO_15) | ||
16 | |||
17 | *** 20020403: 1.0.0 *** | ||
18 | |||
19 | Initial version \ No newline at end of file | ||
diff --git a/lib/rbcodec/codecs/libtremor/COPYING b/lib/rbcodec/codecs/libtremor/COPYING new file mode 100644 index 0000000000..6111c6c5a6 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/COPYING | |||
@@ -0,0 +1,28 @@ | |||
1 | Copyright (c) 2002, Xiph.org Foundation | ||
2 | |||
3 | Redistribution and use in source and binary forms, with or without | ||
4 | modification, are permitted provided that the following conditions | ||
5 | are met: | ||
6 | |||
7 | - Redistributions of source code must retain the above copyright | ||
8 | notice, this list of conditions and the following disclaimer. | ||
9 | |||
10 | - Redistributions in binary form must reproduce the above copyright | ||
11 | notice, this list of conditions and the following disclaimer in the | ||
12 | documentation and/or other materials provided with the distribution. | ||
13 | |||
14 | - Neither the name of the Xiph.org Foundation nor the names of its | ||
15 | contributors may be used to endorse or promote products derived from | ||
16 | this software without specific prior written permission. | ||
17 | |||
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION | ||
22 | OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | ||
24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | ||
25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | ||
26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | ||
28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
diff --git a/lib/rbcodec/codecs/libtremor/README b/lib/rbcodec/codecs/libtremor/README new file mode 100644 index 0000000000..1321175322 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/README | |||
@@ -0,0 +1,46 @@ | |||
1 | This README covers the Ogg Vorbis 'Tremor' integer playback codec | ||
2 | source as of date 2002 09 02, version 1.0.0. | ||
3 | |||
4 | ****** | ||
5 | |||
6 | The C source in this package will build on any ANSI C compiler and | ||
7 | function completely and properly on any platform. The included build | ||
8 | system assumes GNU build system and make tools (m4, automake, | ||
9 | autoconf, libtool and gmake). GCC is not required, although GCC is | ||
10 | the most tested compiler. To build using GNU tools, type in the | ||
11 | source directory: | ||
12 | |||
13 | ./autogen.sh | ||
14 | make | ||
15 | |||
16 | Currently, the source implements playback in pure C on all platforms | ||
17 | except ARM, where a [currently] small amount of assembly (see | ||
18 | asm_arm.h) is used to implement 64 bit math operations and fast LSP | ||
19 | computation. If building on ARM without the benefit of GNU build | ||
20 | system tools, be sure that '_ARM_ASSEM_' is #defined by the build | ||
21 | system if this assembly is desired, else the resulting library will | ||
22 | use whatever 64 bit math builtins the compiler implements. | ||
23 | |||
24 | No math library is required by this source. No floating point | ||
25 | operations are used at any point in either setup or decode. This | ||
26 | decoder library will properly decode any past, current or future | ||
27 | Vorbis I file or stream. | ||
28 | |||
29 | ******** | ||
30 | |||
31 | The build system produces a static and [when supported by the OS] | ||
32 | dynamic library named 'libvorbisidec'. This library exposes an API | ||
33 | nearly identical to the BSD reference library's 'libvorbisfile', | ||
34 | including all the features familiar to users of vorbisfile. This API | ||
35 | is similar enough that the proper header file to include is named | ||
36 | 'ivorbisfile.h' [included in the source build directory]. Lower level | ||
37 | libvorbis-style headers and structures are in 'ivorbiscodec.h' | ||
38 | [included in the source build directory]. A simple example program, | ||
39 | ivorbisfile_example.c, can be built with 'make example'. | ||
40 | |||
41 | ******** | ||
42 | |||
43 | Detailed Tremor API Documentation begins at doc/index.html | ||
44 | |||
45 | Monty | ||
46 | xiph.org | ||
diff --git a/lib/rbcodec/codecs/libtremor/README.rockbox b/lib/rbcodec/codecs/libtremor/README.rockbox new file mode 100644 index 0000000000..a4e141f6b3 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/README.rockbox | |||
@@ -0,0 +1,17 @@ | |||
1 | Library: Tremor-1.1.2 (Released 2002-05-17) | ||
2 | Imported: 2005-02-16 by Marcoen Hirschberg | ||
3 | |||
4 | This directory contains a local version of Tremor for use by Rockbox | ||
5 | for software decoding of Ogg Vorbis files. | ||
6 | |||
7 | LICENSING INFORMATION | ||
8 | |||
9 | Tremor is distributed under Xiph.Org's BSD-like license - see the file COPYING | ||
10 | in this directory for details. | ||
11 | |||
12 | IMPORT DETAILS | ||
13 | |||
14 | The base version first imported into Rockbox was the SVN version of | ||
15 | Tremor-1.0.2 which was checked out on 2005-02-16. | ||
16 | |||
17 | The autoconf/automake files were removed, as well as the doc and debian directories. | ||
diff --git a/lib/rbcodec/codecs/libtremor/SOURCES b/lib/rbcodec/codecs/libtremor/SOURCES new file mode 100644 index 0000000000..c622699599 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/SOURCES | |||
@@ -0,0 +1,16 @@ | |||
1 | bitwise.c | ||
2 | block.c | ||
3 | codebook.c | ||
4 | floor0.c | ||
5 | floor1.c | ||
6 | framing.c | ||
7 | info.c | ||
8 | mapping0.c | ||
9 | registry.c | ||
10 | res012.c | ||
11 | sharedbook.c | ||
12 | synthesis.c | ||
13 | vorbisfile.c | ||
14 | window.c | ||
15 | ctype.c | ||
16 | oggmalloc.c | ||
diff --git a/lib/rbcodec/codecs/libtremor/asm_arm.h b/lib/rbcodec/codecs/libtremor/asm_arm.h new file mode 100644 index 0000000000..42834a2581 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/asm_arm.h | |||
@@ -0,0 +1,190 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: arm7 and later wide math functions | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifdef _ARM_ASSEM_ | ||
19 | #if ARM_ARCH < 6 | ||
20 | #define INCL_OPTIMIZED_VECTOR_FMUL_WINDOW | ||
21 | static inline void ff_vector_fmul_window_c(ogg_int32_t *dst, const ogg_int32_t *src0, | ||
22 | const ogg_int32_t *src1, const ogg_int32_t *win, int len) | ||
23 | { | ||
24 | /* len is always a power of 2 and always >= 16 so this is unrolled 2 times*/ | ||
25 | ogg_int32_t *dst0 = dst, *dst1 = dst + 2*len; | ||
26 | const ogg_int32_t *win0 = win, *win1 = win + 2*len; | ||
27 | src1 += len; | ||
28 | asm volatile ("cmp %[len], #0\n\t" | ||
29 | "b 1f\n\t" | ||
30 | "0:\n\t" | ||
31 | "ldr r0, [%[src0]], #4\n\t" | ||
32 | "ldr r1, [%[src1], #-4]!\n\t" | ||
33 | "ldr r2, [%[win0]], #4\n\t" | ||
34 | "ldr r3, [%[win1], #-4]!\n\t" | ||
35 | "smull r4, r5, r0, r2\n\t" | ||
36 | "smlal r4, r5, r1, r3\n\t" | ||
37 | "rsb r2, r2, #0\n\t" | ||
38 | "lsl r5, r5, #1\n\t" | ||
39 | "str r5, [%[dst1], #-4]!\n\t" | ||
40 | "smull r4, r5, r0, r3\n\t" | ||
41 | "smlal r4, r5, r1, r2\n\t" | ||
42 | "ldr r0, [%[src0]], #4\n\t" | ||
43 | "ldr r1, [%[src1], #-4]!\n\t" | ||
44 | "lsl r5, r5, #1\n\t" | ||
45 | "str r5, [%[dst0]], #4\n\t" | ||
46 | |||
47 | "ldr r2, [%[win0]], #4\n\t" | ||
48 | "ldr r3, [%[win1], #-4]!\n\t" | ||
49 | "smull r4, r5, r0, r2\n\t" | ||
50 | "smlal r4, r5, r1, r3\n\t" | ||
51 | "rsb r2, r2, #0\n\t" | ||
52 | "lsl r5, r5, #1\n\t" | ||
53 | "str r5, [%[dst1], #-4]!\n\t" | ||
54 | "smull r4, r5, r0, r3\n\t" | ||
55 | "smlal r4, r5, r1, r2\n\t" | ||
56 | "subs %[len], %[len], #2\n\t" | ||
57 | "lsl r5, r5, #1\n\t" | ||
58 | "str r5, [%[dst0]], #4\n\t" | ||
59 | "1:\n\t" | ||
60 | "bgt 0b\n\t" | ||
61 | : [dst0] "+r" (dst0), [dst1] "+r" (dst1), | ||
62 | [src0] "+r" (src0), [src1] "+r" (src1), | ||
63 | [win0] "+r" (win0), [win1] "+r" (win1), | ||
64 | [len] "+r" (len) | ||
65 | :: "r0", "r1", "r2", "r3", "r4", "r5", "cc", "memory"); | ||
66 | } | ||
67 | #endif | ||
68 | #ifndef _V_LSP_MATH_ASM | ||
69 | #define _V_LSP_MATH_ASM | ||
70 | |||
71 | static inline void lsp_loop_asm(ogg_uint32_t *qip,ogg_uint32_t *pip, | ||
72 | ogg_int32_t *qexpp, | ||
73 | ogg_int32_t *ilsp,ogg_int32_t wi, | ||
74 | ogg_int32_t m){ | ||
75 | |||
76 | ogg_uint32_t qi=*qip,pi=*pip; | ||
77 | ogg_int32_t qexp=*qexpp; | ||
78 | |||
79 | asm("mov r0,%3;" | ||
80 | "movs r1,%5,asr#1;" | ||
81 | "add r0,r0,r1,lsl#3;" | ||
82 | "beq 2f;\n" | ||
83 | "1:" | ||
84 | |||
85 | "ldmdb r0!,{r1,r3};" | ||
86 | "subs r1,r1,%4;" //ilsp[j]-wi | ||
87 | "rsbmi r1,r1,#0;" //labs(ilsp[j]-wi) | ||
88 | "umull %0,r2,r1,%0;" //qi*=labs(ilsp[j]-wi) | ||
89 | |||
90 | "subs r1,r3,%4;" //ilsp[j+1]-wi | ||
91 | "rsbmi r1,r1,#0;" //labs(ilsp[j+1]-wi) | ||
92 | "umull %1,r3,r1,%1;" //pi*=labs(ilsp[j+1]-wi) | ||
93 | |||
94 | "cmn r2,r3;" // shift down 16? | ||
95 | "beq 0f;" | ||
96 | "add %2,%2,#16;" | ||
97 | "mov %0,%0,lsr #16;" | ||
98 | "orr %0,%0,r2,lsl #16;" | ||
99 | "mov %1,%1,lsr #16;" | ||
100 | "orr %1,%1,r3,lsl #16;" | ||
101 | "0:" | ||
102 | "cmp r0,%3;\n" | ||
103 | "bhi 1b;\n" | ||
104 | |||
105 | "2:" | ||
106 | // odd filter assymetry | ||
107 | "ands r0,%5,#1;\n" | ||
108 | "beq 3f;\n" | ||
109 | "add r0,%3,%5,lsl#2;\n" | ||
110 | |||
111 | "ldr r1,[r0,#-4];\n" | ||
112 | "mov r0,#0x4000;\n" | ||
113 | |||
114 | "subs r1,r1,%4;\n" //ilsp[j]-wi | ||
115 | "rsbmi r1,r1,#0;\n" //labs(ilsp[j]-wi) | ||
116 | "umull %0,r2,r1,%0;\n" //qi*=labs(ilsp[j]-wi) | ||
117 | "umull %1,r3,r0,%1;\n" //pi*=labs(ilsp[j+1]-wi) | ||
118 | |||
119 | "cmn r2,r3;\n" // shift down 16? | ||
120 | "beq 3f;\n" | ||
121 | "add %2,%2,#16;\n" | ||
122 | "mov %0,%0,lsr #16;\n" | ||
123 | "orr %0,%0,r2,lsl #16;\n" | ||
124 | "mov %1,%1,lsr #16;\n" | ||
125 | "orr %1,%1,r3,lsl #16;\n" | ||
126 | |||
127 | //qi=(pi>>shift)*labs(ilsp[j]-wi); | ||
128 | //pi=(qi>>shift)*labs(ilsp[j+1]-wi); | ||
129 | //qexp+=shift; | ||
130 | |||
131 | //} | ||
132 | |||
133 | /* normalize to max 16 sig figs */ | ||
134 | "3:" | ||
135 | "mov r2,#0;" | ||
136 | "orr r1,%0,%1;" | ||
137 | "tst r1,#0xff000000;" | ||
138 | "addne r2,r2,#8;" | ||
139 | "movne r1,r1,lsr #8;" | ||
140 | "tst r1,#0x00f00000;" | ||
141 | "addne r2,r2,#4;" | ||
142 | "movne r1,r1,lsr #4;" | ||
143 | "tst r1,#0x000c0000;" | ||
144 | "addne r2,r2,#2;" | ||
145 | "movne r1,r1,lsr #2;" | ||
146 | "tst r1,#0x00020000;" | ||
147 | "addne r2,r2,#1;" | ||
148 | "movne r1,r1,lsr #1;" | ||
149 | "tst r1,#0x00010000;" | ||
150 | "addne r2,r2,#1;" | ||
151 | "mov %0,%0,lsr r2;" | ||
152 | "mov %1,%1,lsr r2;" | ||
153 | "add %2,%2,r2;" | ||
154 | |||
155 | : "+r"(qi),"+r"(pi),"+r"(qexp) | ||
156 | : "r"(ilsp),"r"(wi),"r"(m) | ||
157 | : "r0","r1","r2","r3","cc"); | ||
158 | |||
159 | *qip=qi; | ||
160 | *pip=pi; | ||
161 | *qexpp=qexp; | ||
162 | } | ||
163 | |||
164 | static inline void lsp_norm_asm(ogg_uint32_t *qip,ogg_int32_t *qexpp){ | ||
165 | |||
166 | ogg_uint32_t qi=*qip; | ||
167 | ogg_int32_t qexp=*qexpp; | ||
168 | |||
169 | asm("tst %0,#0x0000ff00;" | ||
170 | "moveq %0,%0,lsl #8;" | ||
171 | "subeq %1,%1,#8;" | ||
172 | "tst %0,#0x0000f000;" | ||
173 | "moveq %0,%0,lsl #4;" | ||
174 | "subeq %1,%1,#4;" | ||
175 | "tst %0,#0x0000c000;" | ||
176 | "moveq %0,%0,lsl #2;" | ||
177 | "subeq %1,%1,#2;" | ||
178 | "tst %0,#0x00008000;" | ||
179 | "moveq %0,%0,lsl #1;" | ||
180 | "subeq %1,%1,#1;" | ||
181 | : "+r"(qi),"+r"(qexp) | ||
182 | : | ||
183 | : "cc"); | ||
184 | *qip=qi; | ||
185 | *qexpp=qexp; | ||
186 | } | ||
187 | |||
188 | #endif | ||
189 | #endif | ||
190 | |||
diff --git a/lib/rbcodec/codecs/libtremor/asm_mcf5249.h b/lib/rbcodec/codecs/libtremor/asm_mcf5249.h new file mode 100644 index 0000000000..38aa117d84 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/asm_mcf5249.h | |||
@@ -0,0 +1,85 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * | ||
9 | * Copyright (C) 2005 by Pedro Vasconcelos | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or | ||
12 | * modify it under the terms of the GNU General Public License | ||
13 | * as published by the Free Software Foundation; either version 2 | ||
14 | * of the License, or (at your option) any later version. | ||
15 | * | ||
16 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
17 | * KIND, either express or implied. | ||
18 | * | ||
19 | ****************************************************************************/ | ||
20 | /* asm routines for wide math on the MCF5249 */ | ||
21 | |||
22 | #include "os_types.h" | ||
23 | |||
24 | #if defined(CPU_COLDFIRE) | ||
25 | |||
26 | #ifndef _V_WIDE_MATH | ||
27 | #define _V_WIDE_MATH | ||
28 | |||
29 | #define INCL_OPTIMIZED_VECTOR_FMUL_WINDOW | ||
30 | static inline void ff_vector_fmul_window_c(ogg_int32_t *dst, const ogg_int32_t *src0, | ||
31 | const ogg_int32_t *src1, const ogg_int32_t *win, int len) | ||
32 | { | ||
33 | /* len is always a power of 2 and always >= 16 so this is unrolled 4 times*/ | ||
34 | ogg_int32_t *dst0 = dst, *dst1 = dst + 2*len; | ||
35 | const ogg_int32_t *win0 = win, *win1 = win + 2*len; | ||
36 | src1 += len; | ||
37 | asm volatile ("move.l (%[src0])+, %%d0\n\t" | ||
38 | "move.l -(%[win1]), %%d3\n\t" | ||
39 | "tst.l %[len]\n\t" | ||
40 | "bra.s 1f\n\t" | ||
41 | "0:\n\t" | ||
42 | "mac.l %%d0, %%d3, (%[win0])+, %%d2, %%acc0\n\t" | ||
43 | "mac.l %%d0, %%d2, -(%[src1]), %%d1, %%acc1\n\t" | ||
44 | "msac.l %%d1, %%d2, (%[src0])+, %%d0, %%acc0\n\t" | ||
45 | "mac.l %%d1, %%d3, -(%[win1]), %%d3, %%acc1\n\t" | ||
46 | "mac.l %%d0, %%d3, (%[win0])+, %%d2, %%acc2\n\t" | ||
47 | "mac.l %%d0, %%d2, -(%[src1]), %%d1, %%acc3\n\t" | ||
48 | "msac.l %%d1, %%d2, (%[src0])+, %%d0, %%acc2\n\t" | ||
49 | "mac.l %%d1, %%d3, -(%[win1]), %%d3, %%acc3\n\t" | ||
50 | "movclr.l %%acc0, %%d1\n\t" | ||
51 | "movclr.l %%acc2, %%d2\n\t" | ||
52 | "subq.l #8, %[dst1]\n\t" | ||
53 | "movclr.l %%acc1, %%d5\n\t" | ||
54 | "movclr.l %%acc3, %%d4\n\t" | ||
55 | "movem.l %%d4-%%d5, (%[dst1])\n\t" | ||
56 | "mac.l %%d0, %%d3, (%[win0])+, %%d5, %%acc0\n\t" | ||
57 | "mac.l %%d0, %%d5, -(%[src1]), %%d4, %%acc1\n\t" | ||
58 | "msac.l %%d4, %%d5, (%[src0])+, %%d0, %%acc0\n\t" | ||
59 | "mac.l %%d4, %%d3, -(%[win1]), %%d3, %%acc1\n\t" | ||
60 | "mac.l %%d0, %%d3, (%[win0])+, %%d5, %%acc2\n\t" | ||
61 | "mac.l %%d0, %%d5, -(%[src1]), %%d4, %%acc3\n\t" | ||
62 | "msac.l %%d4, %%d5, (%[src0])+, %%d0, %%acc2\n\t" /* will read one past end of src0 */ | ||
63 | "mac.l %%d4, %%d3, -(%[win1]), %%d3, %%acc3\n\t" /* will read one into win0 */ | ||
64 | "movclr.l %%acc0, %%d4\n\t" | ||
65 | "movclr.l %%acc2, %%d5\n\t" | ||
66 | "movem.l %%d1-%%d2/%%d4-%%d5, (%[dst0])\n\t" | ||
67 | "lea (16, %[dst0]), %[dst0]\n\t" | ||
68 | "subq.l #8, %[dst1]\n\t" | ||
69 | "movclr.l %%acc1, %%d2\n\t" | ||
70 | "movclr.l %%acc3, %%d1\n\t" | ||
71 | "movem.l %%d1-%%d2, (%[dst1])\n\t" | ||
72 | "subq.l #4, %[len]\n\t" | ||
73 | "1:\n\t" | ||
74 | "bgt.s 0b\n\t" | ||
75 | : [dst0] "+a" (dst0), [dst1] "+a" (dst1), | ||
76 | [src0] "+a" (src0), [src1] "+a" (src1), | ||
77 | [win0] "+a" (win0), [win1] "+a" (win1), | ||
78 | [len] "+d" (len) | ||
79 | :: "d0", "d1", "d2", "d3", "d4", "d5", "cc", "memory" ); | ||
80 | } | ||
81 | |||
82 | #define MB() | ||
83 | |||
84 | #endif | ||
85 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/backends.h b/lib/rbcodec/codecs/libtremor/backends.h new file mode 100644 index 0000000000..e27f1f2b80 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/backends.h | |||
@@ -0,0 +1,133 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: backend and mapping structures | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | /* this is exposed up here because we need it for static modes. | ||
19 | Lookups for each backend aren't exposed because there's no reason | ||
20 | to do so */ | ||
21 | |||
22 | #ifndef _vorbis_backend_h_ | ||
23 | #define _vorbis_backend_h_ | ||
24 | |||
25 | #include "codec_internal.h" | ||
26 | |||
27 | /* this would all be simpler/shorter with templates, but.... */ | ||
28 | /* Transform backend generic *************************************/ | ||
29 | |||
30 | /* only mdct right now. Flesh it out more if we ever transcend mdct | ||
31 | in the transform domain */ | ||
32 | |||
33 | /* Floor backend generic *****************************************/ | ||
34 | typedef struct{ | ||
35 | vorbis_info_floor *(*unpack)(vorbis_info *,oggpack_buffer *); | ||
36 | vorbis_look_floor *(*look) (vorbis_dsp_state *,vorbis_info_mode *, | ||
37 | vorbis_info_floor *); | ||
38 | void (*free_info) (vorbis_info_floor *); | ||
39 | void (*free_look) (vorbis_look_floor *); | ||
40 | void *(*inverse1) (struct vorbis_block *,vorbis_look_floor *); | ||
41 | int (*inverse2) (struct vorbis_block *,vorbis_look_floor *, | ||
42 | void *buffer,ogg_int32_t *); | ||
43 | } vorbis_func_floor; | ||
44 | |||
45 | typedef struct{ | ||
46 | int order; | ||
47 | long rate; | ||
48 | long barkmap; | ||
49 | |||
50 | int ampbits; | ||
51 | int ampdB; | ||
52 | |||
53 | int numbooks; /* <= 16 */ | ||
54 | int books[16]; | ||
55 | |||
56 | } vorbis_info_floor0; | ||
57 | |||
58 | #define VIF_POSIT 63 | ||
59 | #define VIF_CLASS 16 | ||
60 | #define VIF_PARTS 31 | ||
61 | typedef struct{ | ||
62 | int partitions; /* 0 to 31 */ | ||
63 | int partitionclass[VIF_PARTS]; /* 0 to 15 */ | ||
64 | |||
65 | int class_dim[VIF_CLASS]; /* 1 to 8 */ | ||
66 | int class_subs[VIF_CLASS]; /* 0,1,2,3 (bits: 1<<n poss) */ | ||
67 | int class_book[VIF_CLASS]; /* subs ^ dim entries */ | ||
68 | int class_subbook[VIF_CLASS][8]; /* [VIF_CLASS][subs] */ | ||
69 | |||
70 | |||
71 | int mult; /* 1 2 3 or 4 */ | ||
72 | int postlist[VIF_POSIT+2]; /* first two implicit */ | ||
73 | |||
74 | } vorbis_info_floor1; | ||
75 | |||
76 | /* Residue backend generic *****************************************/ | ||
77 | typedef struct{ | ||
78 | vorbis_info_residue *(*unpack)(vorbis_info *,oggpack_buffer *); | ||
79 | vorbis_look_residue *(*look) (vorbis_dsp_state *,vorbis_info_mode *, | ||
80 | vorbis_info_residue *); | ||
81 | void (*free_info) (vorbis_info_residue *); | ||
82 | void (*free_look) (vorbis_look_residue *); | ||
83 | int (*inverse) (struct vorbis_block *,vorbis_look_residue *, | ||
84 | ogg_int32_t **,int *,int); | ||
85 | } vorbis_func_residue; | ||
86 | |||
87 | typedef struct vorbis_info_residue0{ | ||
88 | /* block-partitioned VQ coded straight residue */ | ||
89 | long begin; | ||
90 | long end; | ||
91 | |||
92 | /* first stage (lossless partitioning) */ | ||
93 | int grouping; /* group n vectors per partition */ | ||
94 | int partitions; /* possible codebooks for a partition */ | ||
95 | int partvals; /* partitions ^ groupbook dim */ | ||
96 | int groupbook; /* huffbook for partitioning */ | ||
97 | int secondstages[64]; /* expanded out to pointers in lookup */ | ||
98 | int booklist[512]; /* list of second stage books */ | ||
99 | } vorbis_info_residue0; | ||
100 | |||
101 | /* Mapping backend generic *****************************************/ | ||
102 | typedef struct{ | ||
103 | vorbis_info_mapping *(*unpack)(vorbis_info *,oggpack_buffer *); | ||
104 | vorbis_look_mapping *(*look) (vorbis_dsp_state *,vorbis_info_mode *, | ||
105 | vorbis_info_mapping *); | ||
106 | void (*free_info) (vorbis_info_mapping *); | ||
107 | void (*free_look) (vorbis_look_mapping *); | ||
108 | int (*inverse) (struct vorbis_block *vb,vorbis_look_mapping *); | ||
109 | } vorbis_func_mapping; | ||
110 | |||
111 | typedef struct vorbis_info_mapping0{ | ||
112 | int submaps; /* <= 16 */ | ||
113 | int chmuxlist[CHANNELS]; /* up to 256 channels in a Vorbis stream */ | ||
114 | |||
115 | int floorsubmap[16]; /* [mux] submap to floors */ | ||
116 | int residuesubmap[16]; /* [mux] submap to residue */ | ||
117 | |||
118 | #if 0 | ||
119 | int psy[2]; /* by blocktype; impulse/padding for short, | ||
120 | transition/normal for long */ | ||
121 | #endif | ||
122 | |||
123 | int coupling_steps; | ||
124 | unsigned char coupling_mag[256]; | ||
125 | unsigned char coupling_ang[256]; | ||
126 | } vorbis_info_mapping0; | ||
127 | |||
128 | #endif | ||
129 | |||
130 | |||
131 | |||
132 | |||
133 | |||
diff --git a/lib/rbcodec/codecs/libtremor/bitwise.c b/lib/rbcodec/codecs/libtremor/bitwise.c new file mode 100644 index 0000000000..040384abc6 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/bitwise.c | |||
@@ -0,0 +1,867 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE. * | ||
4 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
5 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
6 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
7 | * * | ||
8 | * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 * | ||
9 | * by the Xiph.Org Foundation http://www.xiph.org/ * | ||
10 | * * | ||
11 | ******************************************************************** | ||
12 | |||
13 | function: packing variable sized words into an octet stream | ||
14 | last mod: $Id$ | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | /* We're 'LSb' endian; if we write a word but read individual bits, | ||
19 | then we'll read the lsb first */ | ||
20 | |||
21 | #include <string.h> | ||
22 | #include <stdlib.h> | ||
23 | #include <limits.h> | ||
24 | #include "ogg.h" | ||
25 | |||
26 | #define BUFFER_INCREMENT 256 | ||
27 | |||
28 | const unsigned long mask[] ICONST_ATTR = | ||
29 | {0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f, | ||
30 | 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff, | ||
31 | 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff, | ||
32 | 0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff, | ||
33 | 0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff, | ||
34 | 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff, | ||
35 | 0x3fffffff,0x7fffffff,0xffffffff }; | ||
36 | |||
37 | #if 0 | ||
38 | static const unsigned int mask8B[]= | ||
39 | {0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff}; | ||
40 | |||
41 | void oggpack_writeinit(oggpack_buffer *b){ | ||
42 | memset(b,0,sizeof(*b)); | ||
43 | b->ptr=b->buffer=_ogg_malloc(BUFFER_INCREMENT); | ||
44 | b->buffer[0]='\0'; | ||
45 | b->storage=BUFFER_INCREMENT; | ||
46 | } | ||
47 | |||
48 | void oggpackB_writeinit(oggpack_buffer *b){ | ||
49 | oggpack_writeinit(b); | ||
50 | } | ||
51 | |||
52 | int oggpack_writecheck(oggpack_buffer *b){ | ||
53 | if(!b->ptr || !b->storage)return -1; | ||
54 | return 0; | ||
55 | } | ||
56 | |||
57 | int oggpackB_writecheck(oggpack_buffer *b){ | ||
58 | return oggpack_writecheck(b); | ||
59 | } | ||
60 | |||
61 | void oggpack_writetrunc(oggpack_buffer *b,long bits){ | ||
62 | long bytes=bits>>3; | ||
63 | if(b->ptr){ | ||
64 | bits-=bytes*8; | ||
65 | b->ptr=b->buffer+bytes; | ||
66 | b->endbit=bits; | ||
67 | b->endbyte=bytes; | ||
68 | *b->ptr&=mask[bits]; | ||
69 | } | ||
70 | } | ||
71 | |||
72 | void oggpackB_writetrunc(oggpack_buffer *b,long bits){ | ||
73 | long bytes=bits>>3; | ||
74 | if(b->ptr){ | ||
75 | bits-=bytes*8; | ||
76 | b->ptr=b->buffer+bytes; | ||
77 | b->endbit=bits; | ||
78 | b->endbyte=bytes; | ||
79 | *b->ptr&=mask8B[bits]; | ||
80 | } | ||
81 | } | ||
82 | |||
83 | /* Takes only up to 32 bits. */ | ||
84 | void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){ | ||
85 | if(bits<0 || bits>32) goto err; | ||
86 | if(b->endbyte>=b->storage-4){ | ||
87 | void *ret; | ||
88 | if(!b->ptr)return; | ||
89 | if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err; | ||
90 | ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT); | ||
91 | if(!ret) goto err; | ||
92 | b->buffer=ret; | ||
93 | b->storage+=BUFFER_INCREMENT; | ||
94 | b->ptr=b->buffer+b->endbyte; | ||
95 | } | ||
96 | |||
97 | value&=mask[bits]; | ||
98 | bits+=b->endbit; | ||
99 | |||
100 | b->ptr[0]|=value<<b->endbit; | ||
101 | |||
102 | if(bits>=8){ | ||
103 | b->ptr[1]=(unsigned char)(value>>(8-b->endbit)); | ||
104 | if(bits>=16){ | ||
105 | b->ptr[2]=(unsigned char)(value>>(16-b->endbit)); | ||
106 | if(bits>=24){ | ||
107 | b->ptr[3]=(unsigned char)(value>>(24-b->endbit)); | ||
108 | if(bits>=32){ | ||
109 | if(b->endbit) | ||
110 | b->ptr[4]=(unsigned char)(value>>(32-b->endbit)); | ||
111 | else | ||
112 | b->ptr[4]=0; | ||
113 | } | ||
114 | } | ||
115 | } | ||
116 | } | ||
117 | |||
118 | b->endbyte+=bits/8; | ||
119 | b->ptr+=bits/8; | ||
120 | b->endbit=bits&7; | ||
121 | return; | ||
122 | err: | ||
123 | oggpack_writeclear(b); | ||
124 | } | ||
125 | |||
126 | /* Takes only up to 32 bits. */ | ||
127 | void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){ | ||
128 | if(bits<0 || bits>32) goto err; | ||
129 | if(b->endbyte>=b->storage-4){ | ||
130 | void *ret; | ||
131 | if(!b->ptr)return; | ||
132 | if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err; | ||
133 | ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT); | ||
134 | if(!ret) goto err; | ||
135 | b->buffer=ret; | ||
136 | b->storage+=BUFFER_INCREMENT; | ||
137 | b->ptr=b->buffer+b->endbyte; | ||
138 | } | ||
139 | |||
140 | value=(value&mask[bits])<<(32-bits); | ||
141 | bits+=b->endbit; | ||
142 | |||
143 | b->ptr[0]|=value>>(24+b->endbit); | ||
144 | |||
145 | if(bits>=8){ | ||
146 | b->ptr[1]=(unsigned char)(value>>(16+b->endbit)); | ||
147 | if(bits>=16){ | ||
148 | b->ptr[2]=(unsigned char)(value>>(8+b->endbit)); | ||
149 | if(bits>=24){ | ||
150 | b->ptr[3]=(unsigned char)(value>>(b->endbit)); | ||
151 | if(bits>=32){ | ||
152 | if(b->endbit) | ||
153 | b->ptr[4]=(unsigned char)(value<<(8-b->endbit)); | ||
154 | else | ||
155 | b->ptr[4]=0; | ||
156 | } | ||
157 | } | ||
158 | } | ||
159 | } | ||
160 | |||
161 | b->endbyte+=bits/8; | ||
162 | b->ptr+=bits/8; | ||
163 | b->endbit=bits&7; | ||
164 | return; | ||
165 | err: | ||
166 | oggpack_writeclear(b); | ||
167 | } | ||
168 | |||
169 | void oggpack_writealign(oggpack_buffer *b){ | ||
170 | int bits=8-b->endbit; | ||
171 | if(bits<8) | ||
172 | oggpack_write(b,0,bits); | ||
173 | } | ||
174 | |||
175 | void oggpackB_writealign(oggpack_buffer *b){ | ||
176 | int bits=8-b->endbit; | ||
177 | if(bits<8) | ||
178 | oggpackB_write(b,0,bits); | ||
179 | } | ||
180 | |||
181 | static void oggpack_writecopy_helper(oggpack_buffer *b, | ||
182 | void *source, | ||
183 | long bits, | ||
184 | void (*w)(oggpack_buffer *, | ||
185 | unsigned long, | ||
186 | int), | ||
187 | int msb){ | ||
188 | unsigned char *ptr=(unsigned char *)source; | ||
189 | |||
190 | long bytes=bits/8; | ||
191 | bits-=bytes*8; | ||
192 | |||
193 | if(b->endbit){ | ||
194 | int i; | ||
195 | /* unaligned copy. Do it the hard way. */ | ||
196 | for(i=0;i<bytes;i++) | ||
197 | w(b,(unsigned long)(ptr[i]),8); | ||
198 | }else{ | ||
199 | /* aligned block copy */ | ||
200 | if(b->endbyte+bytes+1>=b->storage){ | ||
201 | void *ret; | ||
202 | if(!b->ptr) goto err; | ||
203 | if(b->endbyte+bytes+BUFFER_INCREMENT>b->storage) goto err; | ||
204 | b->storage=b->endbyte+bytes+BUFFER_INCREMENT; | ||
205 | ret=_ogg_realloc(b->buffer,b->storage); | ||
206 | if(!ret) goto err; | ||
207 | b->buffer=ret; | ||
208 | b->ptr=b->buffer+b->endbyte; | ||
209 | } | ||
210 | |||
211 | memmove(b->ptr,source,bytes); | ||
212 | b->ptr+=bytes; | ||
213 | b->endbyte+=bytes; | ||
214 | *b->ptr=0; | ||
215 | |||
216 | } | ||
217 | if(bits){ | ||
218 | if(msb) | ||
219 | w(b,(unsigned long)(ptr[bytes]>>(8-bits)),bits); | ||
220 | else | ||
221 | w(b,(unsigned long)(ptr[bytes]),bits); | ||
222 | } | ||
223 | return; | ||
224 | err: | ||
225 | oggpack_writeclear(b); | ||
226 | } | ||
227 | |||
228 | void oggpack_writecopy(oggpack_buffer *b,void *source,long bits){ | ||
229 | oggpack_writecopy_helper(b,source,bits,oggpack_write,0); | ||
230 | } | ||
231 | |||
232 | void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){ | ||
233 | oggpack_writecopy_helper(b,source,bits,oggpackB_write,1); | ||
234 | } | ||
235 | |||
236 | void oggpack_reset(oggpack_buffer *b){ | ||
237 | if(!b->ptr)return; | ||
238 | b->ptr=b->buffer; | ||
239 | b->buffer[0]=0; | ||
240 | b->endbit=b->endbyte=0; | ||
241 | } | ||
242 | |||
243 | void oggpackB_reset(oggpack_buffer *b){ | ||
244 | oggpack_reset(b); | ||
245 | } | ||
246 | |||
247 | void oggpack_writeclear(oggpack_buffer *b){ | ||
248 | if(b->buffer)_ogg_free(b->buffer); | ||
249 | memset(b,0,sizeof(*b)); | ||
250 | } | ||
251 | |||
252 | void oggpackB_writeclear(oggpack_buffer *b){ | ||
253 | oggpack_writeclear(b); | ||
254 | } | ||
255 | #endif | ||
256 | void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){ | ||
257 | memset(b,0,sizeof(*b)); | ||
258 | b->buffer=b->ptr=buf; | ||
259 | b->storage=bytes; | ||
260 | } | ||
261 | #if 0 | ||
262 | void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){ | ||
263 | oggpack_readinit(b,buf,bytes); | ||
264 | } | ||
265 | #endif | ||
266 | /* Read in bits without advancing the bitptr; bits <= 32 */ | ||
267 | /* moved to ogg.h for inlining */ | ||
268 | #if 0 | ||
269 | long oggpack_look(oggpack_buffer *b,int bits){ | ||
270 | unsigned long ret; | ||
271 | unsigned long m; | ||
272 | |||
273 | if(bits<0 || bits>32) return -1; | ||
274 | m=mask[bits]; | ||
275 | bits+=b->endbit; | ||
276 | |||
277 | if(b->endbyte >= b->storage-4){ | ||
278 | /* not the main path */ | ||
279 | if(b->endbyte > b->storage-((bits+7)>>3)) return -1; | ||
280 | /* special case to avoid reading b->ptr[0], which might be past the end of | ||
281 | the buffer; also skips some useless accounting */ | ||
282 | else if(!bits)return(0L); | ||
283 | } | ||
284 | |||
285 | ret=b->ptr[0]>>b->endbit; | ||
286 | if(bits>8){ | ||
287 | ret|=b->ptr[1]<<(8-b->endbit); | ||
288 | if(bits>16){ | ||
289 | ret|=b->ptr[2]<<(16-b->endbit); | ||
290 | if(bits>24){ | ||
291 | ret|=b->ptr[3]<<(24-b->endbit); | ||
292 | if(bits>32 && b->endbit) | ||
293 | ret|=b->ptr[4]<<(32-b->endbit); | ||
294 | } | ||
295 | } | ||
296 | } | ||
297 | return(m&ret); | ||
298 | } | ||
299 | #endif | ||
300 | |||
301 | #if 0 | ||
302 | /* Read in bits without advancing the bitptr; bits <= 32 */ | ||
303 | long oggpackB_look(oggpack_buffer *b,int bits){ | ||
304 | unsigned long ret; | ||
305 | int m=32-bits; | ||
306 | |||
307 | if(m<0 || m>32) return -1; | ||
308 | bits+=b->endbit; | ||
309 | |||
310 | if(b->endbyte >= b->storage-4){ | ||
311 | /* not the main path */ | ||
312 | if(b->endbyte > b->storage-((bits+7)>>3)) return -1; | ||
313 | /* special case to avoid reading b->ptr[0], which might be past the end of | ||
314 | the buffer; also skips some useless accounting */ | ||
315 | else if(!bits)return(0L); | ||
316 | } | ||
317 | |||
318 | ret=b->ptr[0]<<(24+b->endbit); | ||
319 | if(bits>8){ | ||
320 | ret|=b->ptr[1]<<(16+b->endbit); | ||
321 | if(bits>16){ | ||
322 | ret|=b->ptr[2]<<(8+b->endbit); | ||
323 | if(bits>24){ | ||
324 | ret|=b->ptr[3]<<(b->endbit); | ||
325 | if(bits>32 && b->endbit) | ||
326 | ret|=b->ptr[4]>>(8-b->endbit); | ||
327 | } | ||
328 | } | ||
329 | } | ||
330 | return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1); | ||
331 | } | ||
332 | |||
333 | long oggpack_look1(oggpack_buffer *b){ | ||
334 | if(b->endbyte>=b->storage)return(-1); | ||
335 | return((b->ptr[0]>>b->endbit)&1); | ||
336 | } | ||
337 | |||
338 | long oggpackB_look1(oggpack_buffer *b){ | ||
339 | if(b->endbyte>=b->storage)return(-1); | ||
340 | return((b->ptr[0]>>(7-b->endbit))&1); | ||
341 | } | ||
342 | #endif | ||
343 | /* moved to ogg.h for inlining | ||
344 | void oggpack_adv(oggpack_buffer *b,int bits){ | ||
345 | bits+=b->endbit; | ||
346 | |||
347 | if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow; | ||
348 | |||
349 | b->ptr+=bits/8; | ||
350 | b->endbyte+=bits/8; | ||
351 | b->endbit=bits&7; | ||
352 | return; | ||
353 | |||
354 | overflow: | ||
355 | b->ptr=NULL; | ||
356 | b->endbyte=b->storage; | ||
357 | b->endbit=1; | ||
358 | } | ||
359 | */ | ||
360 | #if 0 | ||
361 | void oggpackB_adv(oggpack_buffer *b,int bits){ | ||
362 | oggpack_adv(b,bits); | ||
363 | } | ||
364 | |||
365 | void oggpack_adv1(oggpack_buffer *b){ | ||
366 | if(++(b->endbit)>7){ | ||
367 | b->endbit=0; | ||
368 | b->ptr++; | ||
369 | b->endbyte++; | ||
370 | } | ||
371 | } | ||
372 | |||
373 | void oggpackB_adv1(oggpack_buffer *b){ | ||
374 | oggpack_adv1(b); | ||
375 | } | ||
376 | #endif | ||
377 | /* bits <= 32 */ | ||
378 | long oggpack_read(oggpack_buffer *b,int bits) ICODE_ATTR_TREMOR_NOT_MDCT; | ||
379 | long oggpack_read(oggpack_buffer *b,int bits){ | ||
380 | long ret; | ||
381 | unsigned long m; | ||
382 | |||
383 | if(bits<0 || bits>32) goto err; | ||
384 | m=mask[bits]; | ||
385 | bits+=b->endbit; | ||
386 | |||
387 | if(b->endbyte >= b->storage-4){ | ||
388 | /* not the main path */ | ||
389 | if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow; | ||
390 | /* special case to avoid reading b->ptr[0], which might be past the end of | ||
391 | the buffer; also skips some useless accounting */ | ||
392 | else if(!bits)return(0L); | ||
393 | } | ||
394 | |||
395 | ret=b->ptr[0]>>b->endbit; | ||
396 | if(bits>8){ | ||
397 | ret|=b->ptr[1]<<(8-b->endbit); | ||
398 | if(bits>16){ | ||
399 | ret|=b->ptr[2]<<(16-b->endbit); | ||
400 | if(bits>24){ | ||
401 | ret|=b->ptr[3]<<(24-b->endbit); | ||
402 | if(bits>32 && b->endbit){ | ||
403 | ret|=b->ptr[4]<<(32-b->endbit); | ||
404 | } | ||
405 | } | ||
406 | } | ||
407 | } | ||
408 | ret&=m; | ||
409 | b->ptr+=bits/8; | ||
410 | b->endbyte+=bits/8; | ||
411 | b->endbit=bits&7; | ||
412 | return ret; | ||
413 | |||
414 | overflow: | ||
415 | err: | ||
416 | b->ptr=NULL; | ||
417 | b->endbyte=b->storage; | ||
418 | b->endbit=1; | ||
419 | return -1L; | ||
420 | } | ||
421 | #if 0 | ||
422 | /* bits <= 32 */ | ||
423 | long oggpackB_read(oggpack_buffer *b,int bits){ | ||
424 | long ret; | ||
425 | long m=32-bits; | ||
426 | |||
427 | if(m<0 || m>32) goto err; | ||
428 | bits+=b->endbit; | ||
429 | |||
430 | if(b->endbyte+4>=b->storage){ | ||
431 | /* not the main path */ | ||
432 | if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow; | ||
433 | /* special case to avoid reading b->ptr[0], which might be past the end of | ||
434 | the buffer; also skips some useless accounting */ | ||
435 | else if(!bits)return(0L); | ||
436 | } | ||
437 | |||
438 | ret=b->ptr[0]<<(24+b->endbit); | ||
439 | if(bits>8){ | ||
440 | ret|=b->ptr[1]<<(16+b->endbit); | ||
441 | if(bits>16){ | ||
442 | ret|=b->ptr[2]<<(8+b->endbit); | ||
443 | if(bits>24){ | ||
444 | ret|=b->ptr[3]<<(b->endbit); | ||
445 | if(bits>32 && b->endbit) | ||
446 | ret|=b->ptr[4]>>(8-b->endbit); | ||
447 | } | ||
448 | } | ||
449 | } | ||
450 | ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1); | ||
451 | |||
452 | b->ptr+=bits/8; | ||
453 | b->endbyte+=bits/8; | ||
454 | b->endbit=bits&7; | ||
455 | return ret; | ||
456 | |||
457 | overflow: | ||
458 | err: | ||
459 | b->ptr=NULL; | ||
460 | b->endbyte=b->storage; | ||
461 | b->endbit=1; | ||
462 | return -1L; | ||
463 | } | ||
464 | |||
465 | long oggpack_read1(oggpack_buffer *b){ | ||
466 | long ret; | ||
467 | |||
468 | if(b->endbyte >= b->storage) goto overflow; | ||
469 | ret=(b->ptr[0]>>b->endbit)&1; | ||
470 | |||
471 | b->endbit++; | ||
472 | if(b->endbit>7){ | ||
473 | b->endbit=0; | ||
474 | b->ptr++; | ||
475 | b->endbyte++; | ||
476 | } | ||
477 | return ret; | ||
478 | |||
479 | overflow: | ||
480 | b->ptr=NULL; | ||
481 | b->endbyte=b->storage; | ||
482 | b->endbit=1; | ||
483 | return -1L; | ||
484 | } | ||
485 | |||
486 | long oggpackB_read1(oggpack_buffer *b){ | ||
487 | long ret; | ||
488 | |||
489 | if(b->endbyte >= b->storage) goto overflow; | ||
490 | ret=(b->ptr[0]>>(7-b->endbit))&1; | ||
491 | |||
492 | b->endbit++; | ||
493 | if(b->endbit>7){ | ||
494 | b->endbit=0; | ||
495 | b->ptr++; | ||
496 | b->endbyte++; | ||
497 | } | ||
498 | return ret; | ||
499 | |||
500 | overflow: | ||
501 | b->ptr=NULL; | ||
502 | b->endbyte=b->storage; | ||
503 | b->endbit=1; | ||
504 | return -1L; | ||
505 | } | ||
506 | #endif | ||
507 | /* moved to ogg.h for inlining | ||
508 | long oggpack_bytes(oggpack_buffer *b){ | ||
509 | return(b->endbyte+(b->endbit+7)/8); | ||
510 | } | ||
511 | */ | ||
512 | #if 0 | ||
513 | long oggpack_bits(oggpack_buffer *b){ | ||
514 | return(b->endbyte*8+b->endbit); | ||
515 | } | ||
516 | |||
517 | long oggpackB_bytes(oggpack_buffer *b){ | ||
518 | return oggpack_bytes(b); | ||
519 | } | ||
520 | |||
521 | long oggpackB_bits(oggpack_buffer *b){ | ||
522 | return oggpack_bits(b); | ||
523 | } | ||
524 | |||
525 | unsigned char *oggpack_get_buffer(oggpack_buffer *b){ | ||
526 | return(b->buffer); | ||
527 | } | ||
528 | |||
529 | unsigned char *oggpackB_get_buffer(oggpack_buffer *b){ | ||
530 | return oggpack_get_buffer(b); | ||
531 | } | ||
532 | #endif | ||
533 | /* Self test of the bitwise routines; everything else is based on | ||
534 | them, so they damned well better be solid. */ | ||
535 | |||
536 | #ifdef _V_SELFTEST | ||
537 | #include <stdio.h> | ||
538 | |||
539 | static int ilog(unsigned int v){ | ||
540 | int ret=0; | ||
541 | while(v){ | ||
542 | ret++; | ||
543 | v>>=1; | ||
544 | } | ||
545 | return(ret); | ||
546 | } | ||
547 | |||
548 | oggpack_buffer o; | ||
549 | oggpack_buffer r; | ||
550 | |||
551 | void report(char *in){ | ||
552 | fprintf(stderr,"%s",in); | ||
553 | exit(1); | ||
554 | } | ||
555 | |||
556 | void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){ | ||
557 | long bytes,i; | ||
558 | unsigned char *buffer; | ||
559 | |||
560 | oggpack_reset(&o); | ||
561 | for(i=0;i<vals;i++) | ||
562 | oggpack_write(&o,b[i],bits?bits:ilog(b[i])); | ||
563 | buffer=oggpack_get_buffer(&o); | ||
564 | bytes=oggpack_bytes(&o); | ||
565 | if(bytes!=compsize)report("wrong number of bytes!\n"); | ||
566 | for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){ | ||
567 | for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]); | ||
568 | report("wrote incorrect value!\n"); | ||
569 | } | ||
570 | oggpack_readinit(&r,buffer,bytes); | ||
571 | for(i=0;i<vals;i++){ | ||
572 | int tbit=bits?bits:ilog(b[i]); | ||
573 | if(oggpack_look(&r,tbit)==-1) | ||
574 | report("out of data!\n"); | ||
575 | if(oggpack_look(&r,tbit)!=(b[i]&mask[tbit])) | ||
576 | report("looked at incorrect value!\n"); | ||
577 | if(tbit==1) | ||
578 | if(oggpack_look1(&r)!=(b[i]&mask[tbit])) | ||
579 | report("looked at single bit incorrect value!\n"); | ||
580 | if(tbit==1){ | ||
581 | if(oggpack_read1(&r)!=(b[i]&mask[tbit])) | ||
582 | report("read incorrect single bit value!\n"); | ||
583 | }else{ | ||
584 | if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit])) | ||
585 | report("read incorrect value!\n"); | ||
586 | } | ||
587 | } | ||
588 | if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n"); | ||
589 | } | ||
590 | |||
591 | void cliptestB(unsigned long *b,int vals,int bits,int *comp,int compsize){ | ||
592 | long bytes,i; | ||
593 | unsigned char *buffer; | ||
594 | |||
595 | oggpackB_reset(&o); | ||
596 | for(i=0;i<vals;i++) | ||
597 | oggpackB_write(&o,b[i],bits?bits:ilog(b[i])); | ||
598 | buffer=oggpackB_get_buffer(&o); | ||
599 | bytes=oggpackB_bytes(&o); | ||
600 | if(bytes!=compsize)report("wrong number of bytes!\n"); | ||
601 | for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){ | ||
602 | for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]); | ||
603 | report("wrote incorrect value!\n"); | ||
604 | } | ||
605 | oggpackB_readinit(&r,buffer,bytes); | ||
606 | for(i=0;i<vals;i++){ | ||
607 | int tbit=bits?bits:ilog(b[i]); | ||
608 | if(oggpackB_look(&r,tbit)==-1) | ||
609 | report("out of data!\n"); | ||
610 | if(oggpackB_look(&r,tbit)!=(b[i]&mask[tbit])) | ||
611 | report("looked at incorrect value!\n"); | ||
612 | if(tbit==1) | ||
613 | if(oggpackB_look1(&r)!=(b[i]&mask[tbit])) | ||
614 | report("looked at single bit incorrect value!\n"); | ||
615 | if(tbit==1){ | ||
616 | if(oggpackB_read1(&r)!=(b[i]&mask[tbit])) | ||
617 | report("read incorrect single bit value!\n"); | ||
618 | }else{ | ||
619 | if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit])) | ||
620 | report("read incorrect value!\n"); | ||
621 | } | ||
622 | } | ||
623 | if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n"); | ||
624 | } | ||
625 | |||
626 | int main(void){ | ||
627 | unsigned char *buffer; | ||
628 | long bytes,i; | ||
629 | static unsigned long testbuffer1[]= | ||
630 | {18,12,103948,4325,543,76,432,52,3,65,4,56,32,42,34,21,1,23,32,546,456,7, | ||
631 | 567,56,8,8,55,3,52,342,341,4,265,7,67,86,2199,21,7,1,5,1,4}; | ||
632 | int test1size=43; | ||
633 | |||
634 | static unsigned long testbuffer2[]= | ||
635 | {216531625L,1237861823,56732452,131,3212421,12325343,34547562,12313212, | ||
636 | 1233432,534,5,346435231,14436467,7869299,76326614,167548585, | ||
637 | 85525151,0,12321,1,349528352}; | ||
638 | int test2size=21; | ||
639 | |||
640 | static unsigned long testbuffer3[]= | ||
641 | {1,0,14,0,1,0,12,0,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,1,1,1,1,0,0,1, | ||
642 | 0,1,30,1,1,1,0,0,1,0,0,0,12,0,11,0,1,0,0,1}; | ||
643 | int test3size=56; | ||
644 | |||
645 | static unsigned long large[]= | ||
646 | {2136531625L,2137861823,56732452,131,3212421,12325343,34547562,12313212, | ||
647 | 1233432,534,5,2146435231,14436467,7869299,76326614,167548585, | ||
648 | 85525151,0,12321,1,2146528352}; | ||
649 | |||
650 | int onesize=33; | ||
651 | static int one[33]={146,25,44,151,195,15,153,176,233,131,196,65,85,172,47,40, | ||
652 | 34,242,223,136,35,222,211,86,171,50,225,135,214,75,172, | ||
653 | 223,4}; | ||
654 | static int oneB[33]={150,101,131,33,203,15,204,216,105,193,156,65,84,85,222, | ||
655 | 8,139,145,227,126,34,55,244,171,85,100,39,195,173,18, | ||
656 | 245,251,128}; | ||
657 | |||
658 | int twosize=6; | ||
659 | static int two[6]={61,255,255,251,231,29}; | ||
660 | static int twoB[6]={247,63,255,253,249,120}; | ||
661 | |||
662 | int threesize=54; | ||
663 | static int three[54]={169,2,232,252,91,132,156,36,89,13,123,176,144,32,254, | ||
664 | 142,224,85,59,121,144,79,124,23,67,90,90,216,79,23,83, | ||
665 | 58,135,196,61,55,129,183,54,101,100,170,37,127,126,10, | ||
666 | 100,52,4,14,18,86,77,1}; | ||
667 | static int threeB[54]={206,128,42,153,57,8,183,251,13,89,36,30,32,144,183, | ||
668 | 130,59,240,121,59,85,223,19,228,180,134,33,107,74,98, | ||
669 | 233,253,196,135,63,2,110,114,50,155,90,127,37,170,104, | ||
670 | 200,20,254,4,58,106,176,144,0}; | ||
671 | |||
672 | int foursize=38; | ||
673 | static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72, | ||
674 | 132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169, | ||
675 | 28,2,133,0,1}; | ||
676 | static int fourB[38]={36,48,102,83,243,24,52,7,4,35,132,10,145,21,2,93,2,41, | ||
677 | 1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67, | ||
678 | 129,10,4,32}; | ||
679 | |||
680 | int fivesize=45; | ||
681 | static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62, | ||
682 | 241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169, | ||
683 | 84,75,159,2,1,0,132,192,8,0,0,18,22}; | ||
684 | static int fiveB[45]={1,84,145,111,245,100,128,8,56,36,40,71,126,78,213,226, | ||
685 | 124,105,12,0,133,128,0,162,233,242,67,152,77,205,77, | ||
686 | 172,150,169,129,79,128,0,6,4,32,0,27,9,0}; | ||
687 | |||
688 | int sixsize=7; | ||
689 | static int six[7]={17,177,170,242,169,19,148}; | ||
690 | static int sixB[7]={136,141,85,79,149,200,41}; | ||
691 | |||
692 | /* Test read/write together */ | ||
693 | /* Later we test against pregenerated bitstreams */ | ||
694 | oggpack_writeinit(&o); | ||
695 | |||
696 | fprintf(stderr,"\nSmall preclipped packing (LSb): "); | ||
697 | cliptest(testbuffer1,test1size,0,one,onesize); | ||
698 | fprintf(stderr,"ok."); | ||
699 | |||
700 | fprintf(stderr,"\nNull bit call (LSb): "); | ||
701 | cliptest(testbuffer3,test3size,0,two,twosize); | ||
702 | fprintf(stderr,"ok."); | ||
703 | |||
704 | fprintf(stderr,"\nLarge preclipped packing (LSb): "); | ||
705 | cliptest(testbuffer2,test2size,0,three,threesize); | ||
706 | fprintf(stderr,"ok."); | ||
707 | |||
708 | fprintf(stderr,"\n32 bit preclipped packing (LSb): "); | ||
709 | oggpack_reset(&o); | ||
710 | for(i=0;i<test2size;i++) | ||
711 | oggpack_write(&o,large[i],32); | ||
712 | buffer=oggpack_get_buffer(&o); | ||
713 | bytes=oggpack_bytes(&o); | ||
714 | oggpack_readinit(&r,buffer,bytes); | ||
715 | for(i=0;i<test2size;i++){ | ||
716 | if(oggpack_look(&r,32)==-1)report("out of data. failed!"); | ||
717 | if(oggpack_look(&r,32)!=large[i]){ | ||
718 | fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpack_look(&r,32),large[i], | ||
719 | oggpack_look(&r,32),large[i]); | ||
720 | report("read incorrect value!\n"); | ||
721 | } | ||
722 | oggpack_adv(&r,32); | ||
723 | } | ||
724 | if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n"); | ||
725 | fprintf(stderr,"ok."); | ||
726 | |||
727 | fprintf(stderr,"\nSmall unclipped packing (LSb): "); | ||
728 | cliptest(testbuffer1,test1size,7,four,foursize); | ||
729 | fprintf(stderr,"ok."); | ||
730 | |||
731 | fprintf(stderr,"\nLarge unclipped packing (LSb): "); | ||
732 | cliptest(testbuffer2,test2size,17,five,fivesize); | ||
733 | fprintf(stderr,"ok."); | ||
734 | |||
735 | fprintf(stderr,"\nSingle bit unclipped packing (LSb): "); | ||
736 | cliptest(testbuffer3,test3size,1,six,sixsize); | ||
737 | fprintf(stderr,"ok."); | ||
738 | |||
739 | fprintf(stderr,"\nTesting read past end (LSb): "); | ||
740 | oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8); | ||
741 | for(i=0;i<64;i++){ | ||
742 | if(oggpack_read(&r,1)!=0){ | ||
743 | fprintf(stderr,"failed; got -1 prematurely.\n"); | ||
744 | exit(1); | ||
745 | } | ||
746 | } | ||
747 | if(oggpack_look(&r,1)!=-1 || | ||
748 | oggpack_read(&r,1)!=-1){ | ||
749 | fprintf(stderr,"failed; read past end without -1.\n"); | ||
750 | exit(1); | ||
751 | } | ||
752 | oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8); | ||
753 | if(oggpack_read(&r,30)!=0 || oggpack_read(&r,16)!=0){ | ||
754 | fprintf(stderr,"failed 2; got -1 prematurely.\n"); | ||
755 | exit(1); | ||
756 | } | ||
757 | |||
758 | if(oggpack_look(&r,18)!=0 || | ||
759 | oggpack_look(&r,18)!=0){ | ||
760 | fprintf(stderr,"failed 3; got -1 prematurely.\n"); | ||
761 | exit(1); | ||
762 | } | ||
763 | if(oggpack_look(&r,19)!=-1 || | ||
764 | oggpack_look(&r,19)!=-1){ | ||
765 | fprintf(stderr,"failed; read past end without -1.\n"); | ||
766 | exit(1); | ||
767 | } | ||
768 | if(oggpack_look(&r,32)!=-1 || | ||
769 | oggpack_look(&r,32)!=-1){ | ||
770 | fprintf(stderr,"failed; read past end without -1.\n"); | ||
771 | exit(1); | ||
772 | } | ||
773 | oggpack_writeclear(&o); | ||
774 | fprintf(stderr,"ok.\n"); | ||
775 | |||
776 | /********** lazy, cut-n-paste retest with MSb packing ***********/ | ||
777 | |||
778 | /* Test read/write together */ | ||
779 | /* Later we test against pregenerated bitstreams */ | ||
780 | oggpackB_writeinit(&o); | ||
781 | |||
782 | fprintf(stderr,"\nSmall preclipped packing (MSb): "); | ||
783 | cliptestB(testbuffer1,test1size,0,oneB,onesize); | ||
784 | fprintf(stderr,"ok."); | ||
785 | |||
786 | fprintf(stderr,"\nNull bit call (MSb): "); | ||
787 | cliptestB(testbuffer3,test3size,0,twoB,twosize); | ||
788 | fprintf(stderr,"ok."); | ||
789 | |||
790 | fprintf(stderr,"\nLarge preclipped packing (MSb): "); | ||
791 | cliptestB(testbuffer2,test2size,0,threeB,threesize); | ||
792 | fprintf(stderr,"ok."); | ||
793 | |||
794 | fprintf(stderr,"\n32 bit preclipped packing (MSb): "); | ||
795 | oggpackB_reset(&o); | ||
796 | for(i=0;i<test2size;i++) | ||
797 | oggpackB_write(&o,large[i],32); | ||
798 | buffer=oggpackB_get_buffer(&o); | ||
799 | bytes=oggpackB_bytes(&o); | ||
800 | oggpackB_readinit(&r,buffer,bytes); | ||
801 | for(i=0;i<test2size;i++){ | ||
802 | if(oggpackB_look(&r,32)==-1)report("out of data. failed!"); | ||
803 | if(oggpackB_look(&r,32)!=large[i]){ | ||
804 | fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpackB_look(&r,32),large[i], | ||
805 | oggpackB_look(&r,32),large[i]); | ||
806 | report("read incorrect value!\n"); | ||
807 | } | ||
808 | oggpackB_adv(&r,32); | ||
809 | } | ||
810 | if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n"); | ||
811 | fprintf(stderr,"ok."); | ||
812 | |||
813 | fprintf(stderr,"\nSmall unclipped packing (MSb): "); | ||
814 | cliptestB(testbuffer1,test1size,7,fourB,foursize); | ||
815 | fprintf(stderr,"ok."); | ||
816 | |||
817 | fprintf(stderr,"\nLarge unclipped packing (MSb): "); | ||
818 | cliptestB(testbuffer2,test2size,17,fiveB,fivesize); | ||
819 | fprintf(stderr,"ok."); | ||
820 | |||
821 | fprintf(stderr,"\nSingle bit unclipped packing (MSb): "); | ||
822 | cliptestB(testbuffer3,test3size,1,sixB,sixsize); | ||
823 | fprintf(stderr,"ok."); | ||
824 | |||
825 | fprintf(stderr,"\nTesting read past end (MSb): "); | ||
826 | oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8); | ||
827 | for(i=0;i<64;i++){ | ||
828 | if(oggpackB_read(&r,1)!=0){ | ||
829 | fprintf(stderr,"failed; got -1 prematurely.\n"); | ||
830 | exit(1); | ||
831 | } | ||
832 | } | ||
833 | if(oggpackB_look(&r,1)!=-1 || | ||
834 | oggpackB_read(&r,1)!=-1){ | ||
835 | fprintf(stderr,"failed; read past end without -1.\n"); | ||
836 | exit(1); | ||
837 | } | ||
838 | oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8); | ||
839 | if(oggpackB_read(&r,30)!=0 || oggpackB_read(&r,16)!=0){ | ||
840 | fprintf(stderr,"failed 2; got -1 prematurely.\n"); | ||
841 | exit(1); | ||
842 | } | ||
843 | |||
844 | if(oggpackB_look(&r,18)!=0 || | ||
845 | oggpackB_look(&r,18)!=0){ | ||
846 | fprintf(stderr,"failed 3; got -1 prematurely.\n"); | ||
847 | exit(1); | ||
848 | } | ||
849 | if(oggpackB_look(&r,19)!=-1 || | ||
850 | oggpackB_look(&r,19)!=-1){ | ||
851 | fprintf(stderr,"failed; read past end without -1.\n"); | ||
852 | exit(1); | ||
853 | } | ||
854 | if(oggpackB_look(&r,32)!=-1 || | ||
855 | oggpackB_look(&r,32)!=-1){ | ||
856 | fprintf(stderr,"failed; read past end without -1.\n"); | ||
857 | exit(1); | ||
858 | } | ||
859 | oggpackB_writeclear(&o); | ||
860 | fprintf(stderr,"ok.\n\n"); | ||
861 | |||
862 | |||
863 | return(0); | ||
864 | } | ||
865 | #endif /* _V_SELFTEST */ | ||
866 | |||
867 | #undef BUFFER_INCREMENT | ||
diff --git a/lib/rbcodec/codecs/libtremor/block.c b/lib/rbcodec/codecs/libtremor/block.c new file mode 100644 index 0000000000..b820f1cbc2 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/block.c | |||
@@ -0,0 +1,471 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: PCM data vector blocking, windowing and dis/reassembly | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <stdio.h> | ||
20 | #include <string.h> | ||
21 | #include "ogg.h" | ||
22 | #include "ivorbiscodec.h" | ||
23 | #include "codec_internal.h" | ||
24 | |||
25 | #include "window.h" | ||
26 | #include "registry.h" | ||
27 | #include "misc.h" | ||
28 | #include "ffmpeg_stuff.h" | ||
29 | //#include <codecs/lib/codeclib.h> | ||
30 | |||
31 | static int ilog(unsigned int v){ | ||
32 | int ret=0; | ||
33 | if(v)--v; | ||
34 | while(v){ | ||
35 | ret++; | ||
36 | v>>=1; | ||
37 | } | ||
38 | return(ret); | ||
39 | } | ||
40 | |||
41 | static ogg_int32_t* _pcmbp[CHANNELS] IBSS_ATTR; | ||
42 | static ogg_int32_t* _pcmret[CHANNELS] IBSS_ATTR; | ||
43 | /* save original pointers returned by malloc so we can free it easily */ | ||
44 | static ogg_int32_t* malloc_pointers[3] = {NULL}; | ||
45 | |||
46 | /* pcm accumulator examples (not exhaustive): | ||
47 | |||
48 | <-------------- lW ----------------> | ||
49 | <--------------- W ----------------> | ||
50 | : .....|..... _______________ | | ||
51 | : .''' | '''_--- | |\ | | ||
52 | :.....''' |_____--- '''......| | \_______| | ||
53 | :.................|__________________|_______|__|______| | ||
54 | |<------ Sl ------>| > Sr < |endW | ||
55 | |beginSl |endSl | |endSr | ||
56 | |beginW |endlW |beginSr | ||
57 | |||
58 | |||
59 | |< lW >| | ||
60 | <--------------- W ----------------> | ||
61 | | | .. ______________ | | ||
62 | | | ' `/ | ---_ | | ||
63 | |___.'___/`. | ---_____| | ||
64 | |_______|__|_______|_________________| | ||
65 | | >|Sl|< |<------ Sr ----->|endW | ||
66 | | | |endSl |beginSr |endSr | ||
67 | |beginW | |endlW | ||
68 | mult[0] |beginSl mult[n] | ||
69 | |||
70 | <-------------- lW -----------------> | ||
71 | |<--W-->| | ||
72 | : .............. ___ | | | ||
73 | : .''' |`/ \ | | | ||
74 | :.....''' |/`....\|...| | ||
75 | :.........................|___|___|___| | ||
76 | |Sl |Sr |endW | ||
77 | | | |endSr | ||
78 | | |beginSr | ||
79 | | |endSl | ||
80 | |beginSl | ||
81 | |beginW | ||
82 | */ | ||
83 | |||
84 | /* block abstraction setup *********************************************/ | ||
85 | |||
86 | #ifndef WORD_ALIGN | ||
87 | #define WORD_ALIGN 8 | ||
88 | #endif | ||
89 | |||
90 | int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){ | ||
91 | memset(vb,0,sizeof(*vb)); | ||
92 | vb->vd=v; | ||
93 | vb->localalloc=0; | ||
94 | vb->localstore=NULL; | ||
95 | |||
96 | return(0); | ||
97 | } | ||
98 | |||
99 | void *_vorbis_block_alloc(vorbis_block *vb,long bytes){ | ||
100 | bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1); | ||
101 | if(bytes+vb->localtop>vb->localalloc){ | ||
102 | /* can't just _ogg_realloc... there are outstanding pointers */ | ||
103 | if(vb->localstore){ | ||
104 | struct alloc_chain *link=(struct alloc_chain *)_ogg_malloc(sizeof(*link)); | ||
105 | vb->totaluse+=vb->localtop; | ||
106 | link->next=vb->reap; | ||
107 | link->ptr=vb->localstore; | ||
108 | vb->reap=link; | ||
109 | } | ||
110 | /* highly conservative */ | ||
111 | vb->localalloc=bytes; | ||
112 | vb->localstore=_ogg_malloc(vb->localalloc); | ||
113 | vb->localtop=0; | ||
114 | } | ||
115 | { | ||
116 | void *ret=(void *)(((char *)vb->localstore)+vb->localtop); | ||
117 | vb->localtop+=bytes; | ||
118 | return ret; | ||
119 | } | ||
120 | } | ||
121 | |||
122 | /* reap the chain, pull the ripcord */ | ||
123 | void _vorbis_block_ripcord(vorbis_block *vb){ | ||
124 | /* reap the chain */ | ||
125 | struct alloc_chain *reap=vb->reap; | ||
126 | while(reap){ | ||
127 | struct alloc_chain *next=reap->next; | ||
128 | _ogg_free(reap->ptr); | ||
129 | memset(reap,0,sizeof(*reap)); | ||
130 | _ogg_free(reap); | ||
131 | reap=next; | ||
132 | } | ||
133 | /* consolidate storage */ | ||
134 | if(vb->totaluse){ | ||
135 | vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc); | ||
136 | vb->localalloc+=vb->totaluse; | ||
137 | vb->totaluse=0; | ||
138 | } | ||
139 | |||
140 | /* pull the ripcord */ | ||
141 | vb->localtop=0; | ||
142 | vb->reap=NULL; | ||
143 | } | ||
144 | |||
145 | int vorbis_block_clear(vorbis_block *vb){ | ||
146 | _vorbis_block_ripcord(vb); | ||
147 | if(vb->localstore)_ogg_free(vb->localstore); | ||
148 | |||
149 | memset(vb,0,sizeof(*vb)); | ||
150 | return(0); | ||
151 | } | ||
152 | |||
153 | static int _vds_init(vorbis_dsp_state *v,vorbis_info *vi){ | ||
154 | int i; | ||
155 | long b_size[2]; | ||
156 | |||
157 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
158 | private_state *b=NULL; | ||
159 | |||
160 | if(ci==NULL) return 1; | ||
161 | |||
162 | memset(v,0,sizeof(*v)); | ||
163 | b=(private_state *)(v->backend_state=_ogg_calloc(1,sizeof(*b))); | ||
164 | |||
165 | v->vi=vi; | ||
166 | b->modebits=ilog(ci->modes); | ||
167 | |||
168 | #ifdef TREMOR_USE_IRAM | ||
169 | /* allocate IRAM buffer for the PCM data generated by synthesis */ | ||
170 | iram_malloc_init(); | ||
171 | |||
172 | v->floors = iram_malloc(vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
173 | v->residues[0] = iram_malloc(vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
174 | /* if we can get away with it, put a double buffer into IRAM too, so that | ||
175 | overlap-add runs iram-to-iram and we avoid needing to memcpy */ | ||
176 | v->residues[1] = iram_malloc(vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
177 | if (v->residues[1] == NULL) | ||
178 | v->saved = iram_malloc(vi->channels*ci->blocksizes[1]/4*sizeof(ogg_int32_t)); | ||
179 | |||
180 | #endif | ||
181 | |||
182 | if (v->residues[0] == NULL) { | ||
183 | malloc_pointers[0] = _ogg_malloc(vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
184 | v->residues[0] = malloc_pointers[0]; | ||
185 | } | ||
186 | |||
187 | if (v->residues[1] == NULL && v->saved == NULL) { | ||
188 | malloc_pointers[1] = _ogg_malloc(vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
189 | v->residues[1] = malloc_pointers[1]; | ||
190 | } | ||
191 | |||
192 | if (v->floors == NULL) { | ||
193 | malloc_pointers[2] = _ogg_malloc(vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
194 | v->floors = malloc_pointers[2]; | ||
195 | } | ||
196 | |||
197 | /* needed for the first overlap/add */ | ||
198 | if (v->saved) { | ||
199 | memset(v->saved, 0, vi->channels*ci->blocksizes[1]/4*sizeof(ogg_int32_t)); | ||
200 | for (i = 0; i < vi->channels; i++) | ||
201 | v->saved_ptr[i] = v->saved + i*ci->blocksizes[1]/4; | ||
202 | } else { | ||
203 | memset(v->residues[1], 0, vi->channels*ci->blocksizes[1]/2*sizeof(ogg_int32_t)); | ||
204 | for (i = 0; i < vi->channels; i++) | ||
205 | v->saved_ptr[i] = v->residues[1] + i*ci->blocksizes[1]/2; | ||
206 | } | ||
207 | |||
208 | /* Vorbis I uses only window type 0 */ | ||
209 | b_size[0]=ci->blocksizes[0]/2; | ||
210 | b_size[1]=ci->blocksizes[1]/2; | ||
211 | b->window[0]=_vorbis_window(0,b_size[0]); | ||
212 | b->window[1]=_vorbis_window(0,b_size[1]); | ||
213 | |||
214 | #ifdef TREMOR_USE_IRAM | ||
215 | /* allocate IRAM buffer for window tables too, if sufficient iram available */ | ||
216 | /* give preference to the larger window over the smaller window | ||
217 | (on the assumption that both windows are equally likely used) */ | ||
218 | LOOKUP_TNC *iramposw; | ||
219 | for(i=1; i>=0; i--){ | ||
220 | iramposw=iram_malloc(b_size[i]*sizeof(LOOKUP_TNC)); | ||
221 | if(iramposw!=NULL) { | ||
222 | memcpy(iramposw, b->window[i], b_size[i]*sizeof(LOOKUP_TNC)); | ||
223 | b->window[i]=iramposw; | ||
224 | } | ||
225 | } | ||
226 | #endif | ||
227 | |||
228 | /* finish the codebooks */ | ||
229 | if(!ci->fullbooks){ | ||
230 | ci->fullbooks=(codebook *)_ogg_calloc(ci->books,sizeof(*ci->fullbooks)); | ||
231 | for(i=0;i<ci->books;i++){ | ||
232 | if(ci->book_param[i]==NULL) | ||
233 | goto abort_books; | ||
234 | if(vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i])) | ||
235 | goto abort_books; | ||
236 | /* decode codebooks are now standalone after init */ | ||
237 | vorbis_staticbook_destroy(ci->book_param[i]); | ||
238 | ci->book_param[i]=NULL; | ||
239 | } | ||
240 | } | ||
241 | |||
242 | v->pcm_storage=ci->blocksizes[1]; | ||
243 | v->pcmret=_pcmret; | ||
244 | v->pcmb=_pcmbp; | ||
245 | |||
246 | _pcmbp[0]=NULL; | ||
247 | _pcmbp[1]=NULL; | ||
248 | |||
249 | /* all 1 (large block) or 0 (small block) */ | ||
250 | /* explicitly set for the sake of clarity */ | ||
251 | v->lW=0; /* previous window size */ | ||
252 | v->W=0; /* current window size */ | ||
253 | |||
254 | /* initialize all the mapping/backend lookups */ | ||
255 | b->mode=(vorbis_look_mapping **)_ogg_calloc(ci->modes,sizeof(*b->mode)); | ||
256 | for(i=0;i<ci->modes;i++){ | ||
257 | int mapnum=ci->mode_param[i]->mapping; | ||
258 | int maptype=ci->map_type[mapnum]; | ||
259 | b->mode[i]=_mapping_P[maptype]->look(v,ci->mode_param[i], | ||
260 | ci->map_param[mapnum]); | ||
261 | } | ||
262 | |||
263 | return(0); | ||
264 | abort_books: | ||
265 | for(i=0;i<ci->books;i++){ | ||
266 | if(ci->book_param[i]!=NULL){ | ||
267 | vorbis_staticbook_destroy(ci->book_param[i]); | ||
268 | ci->book_param[i]=NULL; | ||
269 | } | ||
270 | } | ||
271 | vorbis_dsp_clear(v); | ||
272 | return -1; | ||
273 | } | ||
274 | |||
275 | int vorbis_synthesis_restart(vorbis_dsp_state *v){ | ||
276 | vorbis_info *vi=v->vi; | ||
277 | codec_setup_info *ci; | ||
278 | |||
279 | if(!v->backend_state)return -1; | ||
280 | if(!vi)return -1; | ||
281 | ci=vi->codec_setup; | ||
282 | if(!ci)return -1; | ||
283 | |||
284 | v->pcm_current=0; | ||
285 | |||
286 | v->pcm_returned=-1; | ||
287 | v->granulepos=-1; | ||
288 | v->sequence=-1; | ||
289 | ((private_state *)(v->backend_state))->sample_count=-1; | ||
290 | |||
291 | return(0); | ||
292 | } | ||
293 | |||
294 | int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){ | ||
295 | if(_vds_init(v,vi))return 1; | ||
296 | vorbis_synthesis_restart(v); | ||
297 | |||
298 | return 0; | ||
299 | } | ||
300 | |||
301 | void vorbis_dsp_clear(vorbis_dsp_state *v){ | ||
302 | int i; | ||
303 | if(v){ | ||
304 | vorbis_info *vi=v->vi; | ||
305 | codec_setup_info *ci=(codec_setup_info *)(vi?vi->codec_setup:NULL); | ||
306 | private_state *b=(private_state *)v->backend_state; | ||
307 | |||
308 | if(vi != NULL) | ||
309 | { | ||
310 | /* pcm buffer came from oggmalloc rather than iram */ | ||
311 | for(i=0;i<3;i++) | ||
312 | if(malloc_pointers[i]) { | ||
313 | _ogg_free(malloc_pointers[i]); | ||
314 | malloc_pointers[i] = NULL; | ||
315 | } | ||
316 | } | ||
317 | |||
318 | /* free mode lookups; these are actually vorbis_look_mapping structs */ | ||
319 | if(ci){ | ||
320 | for(i=0;i<ci->modes;i++){ | ||
321 | int mapnum=ci->mode_param[i]->mapping; | ||
322 | int maptype=ci->map_type[mapnum]; | ||
323 | if(b && b->mode)_mapping_P[maptype]->free_look(b->mode[i]); | ||
324 | } | ||
325 | } | ||
326 | |||
327 | if(b){ | ||
328 | if(b->mode)_ogg_free(b->mode); | ||
329 | _ogg_free(b); | ||
330 | } | ||
331 | |||
332 | memset(v,0,sizeof(*v)); | ||
333 | } | ||
334 | } | ||
335 | |||
336 | /* Unlike in analysis, the window is only partially applied for each | ||
337 | block. The time domain envelope is not yet handled at the point of | ||
338 | calling (as it relies on the previous block). */ | ||
339 | |||
340 | int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb) | ||
341 | ICODE_ATTR; | ||
342 | int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){ | ||
343 | vorbis_info *vi=v->vi; | ||
344 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
345 | private_state *b=v->backend_state; | ||
346 | |||
347 | if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL); | ||
348 | |||
349 | v->lW=v->W; | ||
350 | v->W=vb->W; | ||
351 | v->nW=-1; | ||
352 | |||
353 | if((v->sequence==-1)|| | ||
354 | (v->sequence+1 != vb->sequence)){ | ||
355 | v->granulepos=-1; /* out of sequence; lose count */ | ||
356 | b->sample_count=-1; | ||
357 | } | ||
358 | |||
359 | v->sequence=vb->sequence; | ||
360 | int n=ci->blocksizes[v->W]/2; | ||
361 | int ln=ci->blocksizes[v->lW]/2; | ||
362 | |||
363 | if(LIKELY(vb->pcmend != 0)){ /* no pcm to process if vorbis_synthesis_trackonly | ||
364 | was called on block */ | ||
365 | window_overlap_add(ci->blocksizes[v->W], ci->blocksizes[v->lW], | ||
366 | ci->blocksizes[0], ci->blocksizes[1], vi->channels, | ||
367 | b->window[v->W & v->lW], v); | ||
368 | /* deal with initial packet state; we do this using the explicit | ||
369 | pcm_returned==-1 flag otherwise we're sensitive to first block | ||
370 | being short or long */ | ||
371 | |||
372 | if(v->pcm_returned==-1){ | ||
373 | v->pcm_returned=0; | ||
374 | v->pcm_current=0; | ||
375 | }else{ | ||
376 | v->pcm_returned=0; | ||
377 | v->pcm_current=(n+ln)/2; | ||
378 | } | ||
379 | } | ||
380 | |||
381 | /* track the frame number... This is for convenience, but also | ||
382 | making sure our last packet doesn't end with added padding. If | ||
383 | the last packet is partial, the number of samples we'll have to | ||
384 | return will be past the vb->granulepos. | ||
385 | |||
386 | This is not foolproof! It will be confused if we begin | ||
387 | decoding at the last page after a seek or hole. In that case, | ||
388 | we don't have a starting point to judge where the last frame | ||
389 | is. For this reason, vorbisfile will always try to make sure | ||
390 | it reads the last two marked pages in proper sequence */ | ||
391 | |||
392 | if(b->sample_count==-1){ | ||
393 | b->sample_count=0; | ||
394 | }else{ | ||
395 | b->sample_count+=(n+ln)/2; | ||
396 | } | ||
397 | |||
398 | if(v->granulepos==-1){ | ||
399 | if(vb->granulepos!=-1){ /* only set if we have a position to set to */ | ||
400 | |||
401 | v->granulepos=vb->granulepos; | ||
402 | |||
403 | /* is this a short page? */ | ||
404 | if(b->sample_count>v->granulepos){ | ||
405 | /* corner case; if this is both the first and last audio page, | ||
406 | then spec says the end is cut, not beginning */ | ||
407 | if(vb->eofflag){ | ||
408 | /* trim the end */ | ||
409 | /* no preceeding granulepos; assume we started at zero (we'd | ||
410 | have to in a short single-page stream) */ | ||
411 | /* granulepos could be -1 due to a seek, but that would result | ||
412 | in a long coun`t, not short count */ | ||
413 | |||
414 | v->pcm_current-=(b->sample_count-v->granulepos); | ||
415 | }else{ | ||
416 | /* trim the beginning */ | ||
417 | v->pcm_returned+=(b->sample_count-v->granulepos); | ||
418 | if(v->pcm_returned>v->pcm_current) | ||
419 | v->pcm_returned=v->pcm_current; | ||
420 | } | ||
421 | |||
422 | } | ||
423 | |||
424 | } | ||
425 | }else{ | ||
426 | v->granulepos+=(n+ln)/2; | ||
427 | if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){ | ||
428 | |||
429 | if(v->granulepos>vb->granulepos){ | ||
430 | long extra=v->granulepos-vb->granulepos; | ||
431 | |||
432 | if(extra) | ||
433 | if(vb->eofflag){ | ||
434 | /* partial last frame. Strip the extra samples off */ | ||
435 | v->pcm_current-=extra; | ||
436 | } /* else {Shouldn't happen *unless* the bitstream is out of | ||
437 | spec. Either way, believe the bitstream } */ | ||
438 | } /* else {Shouldn't happen *unless* the bitstream is out of | ||
439 | spec. Either way, believe the bitstream } */ | ||
440 | v->granulepos=vb->granulepos; | ||
441 | } | ||
442 | } | ||
443 | |||
444 | /* Update, cleanup */ | ||
445 | |||
446 | if(vb->eofflag)v->eofflag=1; | ||
447 | return(0); | ||
448 | } | ||
449 | |||
450 | /* pcm==NULL indicates we just want the pending samples, no more */ | ||
451 | int vorbis_synthesis_pcmout(vorbis_dsp_state *v,ogg_int32_t ***pcm) ICODE_ATTR; | ||
452 | int vorbis_synthesis_pcmout(vorbis_dsp_state *v,ogg_int32_t ***pcm){ | ||
453 | vorbis_info *vi=v->vi; | ||
454 | if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){ | ||
455 | if(pcm){ | ||
456 | int i; | ||
457 | for(i=0;i<vi->channels;i++) | ||
458 | v->pcmret[i]=v->pcmb[i]+v->pcm_returned; | ||
459 | *pcm=v->pcmret; | ||
460 | } | ||
461 | return(v->pcm_current-v->pcm_returned); | ||
462 | } | ||
463 | return 0; | ||
464 | } | ||
465 | |||
466 | int vorbis_synthesis_read(vorbis_dsp_state *v,int bytes){ | ||
467 | if(bytes && v->pcm_returned+bytes>v->pcm_current)return(OV_EINVAL); | ||
468 | v->pcm_returned+=bytes; | ||
469 | return(0); | ||
470 | } | ||
471 | |||
diff --git a/lib/rbcodec/codecs/libtremor/codebook.c b/lib/rbcodec/codecs/libtremor/codebook.c new file mode 100644 index 0000000000..7087f0a323 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/codebook.c | |||
@@ -0,0 +1,587 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: basic codebook pack/unpack/code/decode operations | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <string.h> | ||
20 | #include <math.h> | ||
21 | #include "ogg.h" | ||
22 | #include "ivorbiscodec.h" | ||
23 | #include "codebook.h" | ||
24 | #include "misc.h" | ||
25 | #include "os.h" | ||
26 | |||
27 | /* unpacks a codebook from the packet buffer into the codebook struct, | ||
28 | readies the codebook auxiliary structures for decode *************/ | ||
29 | static_codebook *vorbis_staticbook_unpack(oggpack_buffer *opb){ | ||
30 | long i,j; | ||
31 | static_codebook *s=_ogg_calloc(1,sizeof(*s)); | ||
32 | |||
33 | /* make sure alignment is correct */ | ||
34 | if(oggpack_read(opb,24)!=0x564342)goto _eofout; | ||
35 | |||
36 | /* first the basic parameters */ | ||
37 | s->dim=oggpack_read(opb,16); | ||
38 | s->entries=oggpack_read(opb,24); | ||
39 | if(s->entries==-1)goto _eofout; | ||
40 | |||
41 | if(_ilog(s->dim)+_ilog(s->entries)>24)goto _eofout; | ||
42 | |||
43 | /* codeword ordering.... length ordered or unordered? */ | ||
44 | switch((int)oggpack_read(opb,1)){ | ||
45 | case 0:{ | ||
46 | long unused; | ||
47 | /* allocated but unused entries? */ | ||
48 | unused=oggpack_read(opb,1); | ||
49 | if((s->entries*(unused?1:5)+7)>>3>opb->storage-oggpack_bytes(opb)) | ||
50 | goto _eofout; | ||
51 | /* unordered */ | ||
52 | s->lengthlist=(long *)_ogg_malloc(sizeof(*s->lengthlist)*s->entries); | ||
53 | |||
54 | /* allocated but unused entries? */ | ||
55 | if(unused){ | ||
56 | /* yes, unused entries */ | ||
57 | |||
58 | for(i=0;i<s->entries;i++){ | ||
59 | if(oggpack_read(opb,1)){ | ||
60 | long num=oggpack_read(opb,5); | ||
61 | if(num==-1)goto _eofout; | ||
62 | s->lengthlist[i]=num+1; | ||
63 | }else | ||
64 | s->lengthlist[i]=0; | ||
65 | } | ||
66 | }else{ | ||
67 | /* all entries used; no tagging */ | ||
68 | for(i=0;i<s->entries;i++){ | ||
69 | long num=oggpack_read(opb,5); | ||
70 | if(num==-1)goto _eofout; | ||
71 | s->lengthlist[i]=num+1; | ||
72 | } | ||
73 | } | ||
74 | |||
75 | break; | ||
76 | } | ||
77 | case 1: | ||
78 | /* ordered */ | ||
79 | { | ||
80 | long length=oggpack_read(opb,5)+1; | ||
81 | if(length==0)goto _eofout; | ||
82 | s->lengthlist=(long *)_ogg_malloc(sizeof(*s->lengthlist)*s->entries); | ||
83 | |||
84 | for(i=0;i<s->entries;){ | ||
85 | long num=oggpack_read(opb,_ilog(s->entries-i)); | ||
86 | if(num==-1)goto _eofout; | ||
87 | if(length>32 || num>s->entries-i || | ||
88 | (num>0 && (num-1)>>(length>>1)>>((length+1)>>1))>0){ | ||
89 | goto _errout; | ||
90 | } | ||
91 | for(j=0;j<num;j++,i++) | ||
92 | s->lengthlist[i]=length; | ||
93 | length++; | ||
94 | } | ||
95 | } | ||
96 | break; | ||
97 | default: | ||
98 | /* EOF */ | ||
99 | goto _eofout; | ||
100 | } | ||
101 | |||
102 | /* Do we have a mapping to unpack? */ | ||
103 | switch((s->maptype=oggpack_read(opb,4))){ | ||
104 | case 0: | ||
105 | /* no mapping */ | ||
106 | break; | ||
107 | case 1: case 2: | ||
108 | /* implicitly populated value mapping */ | ||
109 | /* explicitly populated value mapping */ | ||
110 | |||
111 | s->q_min=oggpack_read(opb,32); | ||
112 | s->q_delta=oggpack_read(opb,32); | ||
113 | s->q_quant=oggpack_read(opb,4)+1; | ||
114 | s->q_sequencep=oggpack_read(opb,1); | ||
115 | if(s->q_sequencep==-1)goto _eofout; | ||
116 | |||
117 | { | ||
118 | int quantvals=0; | ||
119 | switch(s->maptype){ | ||
120 | case 1: | ||
121 | quantvals=(s->dim==0?0:_book_maptype1_quantvals(s)); | ||
122 | break; | ||
123 | case 2: | ||
124 | quantvals=s->entries*s->dim; | ||
125 | break; | ||
126 | } | ||
127 | |||
128 | /* quantized values */ | ||
129 | if((quantvals*s->q_quant+7)>>3>opb->storage-oggpack_bytes(opb)) | ||
130 | goto _eofout; | ||
131 | s->quantlist=(long *)_ogg_malloc(sizeof(*s->quantlist)*quantvals); | ||
132 | for(i=0;i<quantvals;i++) | ||
133 | s->quantlist[i]=oggpack_read(opb,s->q_quant); | ||
134 | |||
135 | if(quantvals&&s->quantlist[quantvals-1]==-1)goto _eofout; | ||
136 | } | ||
137 | break; | ||
138 | default: | ||
139 | goto _errout; | ||
140 | } | ||
141 | |||
142 | /* all set */ | ||
143 | return(s); | ||
144 | |||
145 | _errout: | ||
146 | _eofout: | ||
147 | vorbis_staticbook_destroy(s); | ||
148 | return(NULL); | ||
149 | } | ||
150 | |||
151 | /* the 'eliminate the decode tree' optimization actually requires the | ||
152 | codewords to be MSb first, not LSb. This is an annoying inelegancy | ||
153 | (and one of the first places where carefully thought out design | ||
154 | turned out to be wrong; Vorbis II and future Ogg codecs should go | ||
155 | to an MSb bitpacker), but not actually the huge hit it appears to | ||
156 | be. The first-stage decode table catches most words so that | ||
157 | bitreverse is not in the main execution path. */ | ||
158 | |||
159 | static inline ogg_uint32_t bitreverse(register ogg_uint32_t x) | ||
160 | { | ||
161 | unsigned tmp, ret; | ||
162 | #ifdef _ARM_ASSEM_ | ||
163 | #if ARM_ARCH >= 6 | ||
164 | unsigned mask = 0x0f0f0f0f; | ||
165 | #else | ||
166 | unsigned mask = 0x00ff00ff; | ||
167 | #endif | ||
168 | asm ( | ||
169 | #if ARM_ARCH >= 6 | ||
170 | "rev %[r], %[x] \n" /* swap halfwords and bytes */ | ||
171 | "and %[t], %[m], %[r] \n" /* Sequence is one instruction */ | ||
172 | "eor %[r], %[t], %[r] \n" /* longer than on <= ARMv5, but */ | ||
173 | "mov %[t], %[t], lsl #4 \n" /* interlock free */ | ||
174 | "orr %[r], %[t], %[r], lsr #4\n" /* nibbles swapped */ | ||
175 | "eor %[m], %[m], %[m], lsl #2\n" /* mask = 0x33333333 */ | ||
176 | "and %[t], %[m], %[r] \n" | ||
177 | "eor %[r], %[t], %[r] \n" | ||
178 | "mov %[t], %[t], lsl #2 \n" | ||
179 | "orr %[r], %[t], %[r], lsr #2\n" /* dibits swapped */ | ||
180 | "eor %[m], %[m], %[m], lsl #1\n" /* mask = 0x55555555 */ | ||
181 | "and %[t], %[m], %[r] \n" | ||
182 | "eor %[r], %[t], %[r] \n" | ||
183 | "mov %[t], %[t], lsl #1 \n" | ||
184 | "orr %[r], %[t], %[r], lsr #1\n" /* bits swapped */ | ||
185 | #else /* ARM_ARCH <= 5 */ | ||
186 | "mov %[r], %[x], ror #16 \n" /* swap halfwords */ | ||
187 | "and %[t], %[m], %[r], lsr #8\n" | ||
188 | "eor %[r], %[r], %[t], lsl #8\n" | ||
189 | "orr %[r], %[t], %[r], lsl #8\n" /* bytes swapped */ | ||
190 | "eor %[m], %[m], %[m], lsl #4\n" /* mask = 0x0f0f0f0f */ | ||
191 | "and %[t], %[m], %[r], lsr #4\n" | ||
192 | "eor %[r], %[r], %[t], lsl #4\n" | ||
193 | "orr %[r], %[t], %[r], lsl #4\n" /* nibbles swapped */ | ||
194 | "eor %[m], %[m], %[m], lsl #2\n" /* mask = 0x33333333 */ | ||
195 | "and %[t], %[m], %[r], lsr #2\n" | ||
196 | "eor %[r], %[r], %[t], lsl #2\n" | ||
197 | "orr %[r], %[t], %[r], lsl #2\n" /* dibits swapped */ | ||
198 | "eor %[m], %[m], %[m], lsl #1\n" /* mask = 0x55555555 */ | ||
199 | "and %[t], %[m], %[r], lsr #1\n" | ||
200 | "eor %[r], %[r], %[t], lsl #1\n" | ||
201 | "orr %[r], %[t], %[r], lsl #1\n" /* bits swapped */ | ||
202 | #endif /* ARM_ARCH */ | ||
203 | : /* outputs */ | ||
204 | [m]"+r"(mask), | ||
205 | [r]"=r"(ret), | ||
206 | [t]"=r"(tmp) | ||
207 | : /* inputs */ | ||
208 | [x]"r"(x) | ||
209 | ); | ||
210 | #else /* !_ARM_ASSEM_ */ | ||
211 | |||
212 | ret = (x>>16) | (x<<16); | ||
213 | tmp = ret & 0x00ff00ff; | ||
214 | ret ^= tmp; | ||
215 | ret = (ret >> 8) | (tmp << 8); /* bytes swapped */ | ||
216 | tmp = ret & 0x0f0f0f0f; | ||
217 | ret ^= tmp; | ||
218 | ret = (ret >> 4) | (tmp << 4); /* 4-bit units swapped */ | ||
219 | tmp = ret & 0x33333333; | ||
220 | ret ^= tmp; | ||
221 | ret = (ret >> 2) | (tmp << 2); /* 2-bit units swapped */ | ||
222 | tmp = ret & 0x55555555; | ||
223 | ret ^= tmp; | ||
224 | ret = (ret >> 1) | (tmp << 1); /* done */ | ||
225 | #endif /* !_ARM_ASSEM_ */ | ||
226 | return ret; | ||
227 | } | ||
228 | |||
229 | static inline long bisect_codelist(long lo, long hi, ogg_uint32_t cache, | ||
230 | const ogg_uint32_t *codelist) | ||
231 | { | ||
232 | ogg_uint32_t testword=bitreverse(cache); | ||
233 | long p; | ||
234 | while(LIKELY(p = (hi-lo) >> 1) > 0){ | ||
235 | if(codelist[lo+p] > testword) | ||
236 | hi -= p; | ||
237 | else | ||
238 | lo += p; | ||
239 | } | ||
240 | return lo; | ||
241 | } | ||
242 | |||
243 | STIN long decode_packed_entry_number(codebook *book, | ||
244 | oggpack_buffer *b){ | ||
245 | int read=book->dec_maxlength; | ||
246 | long lo,hi; | ||
247 | long lok = oggpack_look(b,book->dec_firsttablen); | ||
248 | |||
249 | if (LIKELY(lok >= 0)) { | ||
250 | ogg_int32_t entry = book->dec_firsttable[lok]; | ||
251 | if(UNLIKELY(entry < 0)){ | ||
252 | lo=(entry>>15)&0x7fff; | ||
253 | hi=book->used_entries-(entry&0x7fff); | ||
254 | }else{ | ||
255 | oggpack_adv(b, book->dec_codelengths[entry-1]); | ||
256 | return(entry-1); | ||
257 | } | ||
258 | }else{ | ||
259 | lo=0; | ||
260 | hi=book->used_entries; | ||
261 | } | ||
262 | |||
263 | lok = oggpack_look(b, read); | ||
264 | |||
265 | while(lok<0 && read>1) | ||
266 | lok = oggpack_look(b, --read); | ||
267 | |||
268 | if(lok<0){ | ||
269 | oggpack_adv(b,1); /* force eop */ | ||
270 | return -1; | ||
271 | } | ||
272 | |||
273 | /* bisect search for the codeword in the ordered list */ | ||
274 | { | ||
275 | lo = bisect_codelist(lo, hi, lok, book->codelist); | ||
276 | |||
277 | if(book->dec_codelengths[lo]<=read){ | ||
278 | oggpack_adv(b, book->dec_codelengths[lo]); | ||
279 | return(lo); | ||
280 | } | ||
281 | } | ||
282 | |||
283 | oggpack_adv(b, read+1); | ||
284 | return(-1); | ||
285 | } | ||
286 | |||
287 | static long decode_packed_block(codebook *book, oggpack_buffer *b, | ||
288 | long *buf, int n){ | ||
289 | long *bufptr = buf; | ||
290 | long *bufend = buf + n; | ||
291 | |||
292 | while (bufptr<bufend) { | ||
293 | if(b->endbyte < b->storage - 8) { | ||
294 | ogg_uint32_t *ptr; | ||
295 | unsigned long bit, bitend; | ||
296 | unsigned long adr; | ||
297 | ogg_uint32_t cache = 0; | ||
298 | int cachesize = 0; | ||
299 | const unsigned int cachemask = (1<<book->dec_firsttablen)-1; | ||
300 | const int book_dec_maxlength = book->dec_maxlength; | ||
301 | const ogg_uint32_t *book_dec_firsttable = book->dec_firsttable; | ||
302 | const long book_used_entries = book->used_entries; | ||
303 | const ogg_uint32_t *book_codelist = book->codelist; | ||
304 | const char *book_dec_codelengths = book->dec_codelengths; | ||
305 | |||
306 | adr = (unsigned long)b->ptr; | ||
307 | bit = (adr&3)*8+b->endbit; | ||
308 | ptr = (ogg_uint32_t*)(adr&~3); | ||
309 | bitend = ((adr&3)+(b->storage-b->endbyte))*8; | ||
310 | while (bufptr<bufend){ | ||
311 | if (UNLIKELY(cachesize<book_dec_maxlength)) { | ||
312 | if (bit-cachesize+32>=bitend) | ||
313 | break; | ||
314 | bit-=cachesize; | ||
315 | cache = letoh32(ptr[bit>>5]); | ||
316 | if (bit&31) { | ||
317 | cache >>= (bit&31); | ||
318 | cache |= letoh32(ptr[(bit>>5)+1]) << (32-(bit&31)); | ||
319 | } | ||
320 | cachesize=32; | ||
321 | bit+=32; | ||
322 | } | ||
323 | |||
324 | ogg_int32_t entry = book_dec_firsttable[cache&cachemask]; | ||
325 | if(UNLIKELY(entry < 0)){ | ||
326 | const long lo = (entry>>15)&0x7fff, hi = book_used_entries-(entry&0x7fff); | ||
327 | entry = bisect_codelist(lo, hi, cache, book_codelist); | ||
328 | }else | ||
329 | entry--; | ||
330 | |||
331 | *bufptr++ = entry; | ||
332 | int l = book_dec_codelengths[entry]; | ||
333 | cachesize -= l; | ||
334 | cache >>= l; | ||
335 | } | ||
336 | |||
337 | adr=(unsigned long)b->ptr; | ||
338 | bit-=(adr&3)*8+cachesize; | ||
339 | b->endbyte+=bit/8; | ||
340 | b->ptr+=bit/8; | ||
341 | b->endbit=bit&7; | ||
342 | } else { | ||
343 | long r = decode_packed_entry_number(book, b); | ||
344 | if (r == -1) return bufptr-buf; | ||
345 | *bufptr++ = r; | ||
346 | } | ||
347 | } | ||
348 | return n; | ||
349 | } | ||
350 | |||
351 | /* Decode side is specced and easier, because we don't need to find | ||
352 | matches using different criteria; we simply read and map. There are | ||
353 | two things we need to do 'depending': | ||
354 | |||
355 | We may need to support interleave. We don't really, but it's | ||
356 | convenient to do it here rather than rebuild the vector later. | ||
357 | |||
358 | Cascades may be additive or multiplicitive; this is not inherent in | ||
359 | the codebook, but set in the code using the codebook. Like | ||
360 | interleaving, it's easiest to do it here. | ||
361 | addmul==0 -> declarative (set the value) | ||
362 | addmul==1 -> additive | ||
363 | addmul==2 -> multiplicitive */ | ||
364 | |||
365 | /* returns the [original, not compacted] entry number or -1 on eof *********/ | ||
366 | long vorbis_book_decode(codebook *book, oggpack_buffer *b){ | ||
367 | if(book->used_entries>0){ | ||
368 | long packed_entry=decode_packed_entry_number(book,b); | ||
369 | if(packed_entry>=0) | ||
370 | return(book->dec_index[packed_entry]); | ||
371 | } | ||
372 | |||
373 | /* if there's no dec_index, the codebook unpacking isn't collapsed */ | ||
374 | return(-1); | ||
375 | } | ||
376 | |||
377 | /* returns 0 on OK or -1 on eof *************************************/ | ||
378 | /* decode vector / dim granularity gaurding is done in the upper layer */ | ||
379 | long vorbis_book_decodevs_add(codebook *book,ogg_int32_t *a, | ||
380 | oggpack_buffer *b,int n,int point){ | ||
381 | if(book->used_entries>0){ | ||
382 | int step=n/book->dim; | ||
383 | long *entry = (long *)alloca(sizeof(*entry)*step); | ||
384 | ogg_int32_t **t = (ogg_int32_t **)alloca(sizeof(*t)*step); | ||
385 | int i,j,o; | ||
386 | int shift=point-book->binarypoint; | ||
387 | |||
388 | if(shift>=0){ | ||
389 | for (i = 0; i < step; i++) { | ||
390 | entry[i]=decode_packed_entry_number(book,b); | ||
391 | if(entry[i]==-1)return(-1); | ||
392 | t[i] = book->valuelist+entry[i]*book->dim; | ||
393 | } | ||
394 | for(i=0,o=0;i<book->dim;i++,o+=step) | ||
395 | for (j=0;j<step;j++) | ||
396 | a[o+j]+=t[j][i]>>shift; | ||
397 | }else{ | ||
398 | for (i = 0; i < step; i++) { | ||
399 | entry[i]=decode_packed_entry_number(book,b); | ||
400 | if(entry[i]==-1)return(-1); | ||
401 | t[i] = book->valuelist+entry[i]*book->dim; | ||
402 | } | ||
403 | for(i=0,o=0;i<book->dim;i++,o+=step) | ||
404 | for (j=0;j<step;j++) | ||
405 | a[o+j]+=t[j][i]<<-shift; | ||
406 | } | ||
407 | } | ||
408 | return(0); | ||
409 | } | ||
410 | |||
411 | /* decode vector / dim granularity gaurding is done in the upper layer */ | ||
412 | long vorbis_book_decodev_add(codebook *book,ogg_int32_t *a, | ||
413 | oggpack_buffer *b,int n,int point){ | ||
414 | if(book->used_entries>0){ | ||
415 | int i,j,entry; | ||
416 | ogg_int32_t *t; | ||
417 | int shift=point-book->binarypoint; | ||
418 | |||
419 | if(shift>=0){ | ||
420 | for(i=0;i<n;){ | ||
421 | entry = decode_packed_entry_number(book,b); | ||
422 | if(entry==-1)return(-1); | ||
423 | t = book->valuelist+entry*book->dim; | ||
424 | for (j=0;j<book->dim;) | ||
425 | a[i++]+=t[j++]>>shift; | ||
426 | } | ||
427 | }else{ | ||
428 | shift = -shift; | ||
429 | for(i=0;i<n;){ | ||
430 | entry = decode_packed_entry_number(book,b); | ||
431 | if(entry==-1)return(-1); | ||
432 | t = book->valuelist+entry*book->dim; | ||
433 | for (j=0;j<book->dim;) | ||
434 | a[i++]+=t[j++]<<shift; | ||
435 | } | ||
436 | } | ||
437 | } | ||
438 | return(0); | ||
439 | } | ||
440 | |||
441 | /* unlike the others, we guard against n not being an integer number | ||
442 | of <dim> internally rather than in the upper layer (called only by | ||
443 | floor0) */ | ||
444 | long vorbis_book_decodev_set(codebook *book,ogg_int32_t *a, | ||
445 | oggpack_buffer *b,int n,int point){ | ||
446 | if(book->used_entries>0){ | ||
447 | int i,j,entry; | ||
448 | ogg_int32_t *t; | ||
449 | int shift=point-book->binarypoint; | ||
450 | |||
451 | if(shift>=0){ | ||
452 | |||
453 | for(i=0;i<n;){ | ||
454 | entry = decode_packed_entry_number(book,b); | ||
455 | if(entry==-1)return(-1); | ||
456 | t = book->valuelist+entry*book->dim; | ||
457 | for (j=0;i<n && j<book->dim;){ | ||
458 | a[i++]=t[j++]>>shift; | ||
459 | } | ||
460 | } | ||
461 | }else{ | ||
462 | shift = -shift; | ||
463 | for(i=0;i<n;){ | ||
464 | entry = decode_packed_entry_number(book,b); | ||
465 | if(entry==-1)return(-1); | ||
466 | t = book->valuelist+entry*book->dim; | ||
467 | for (j=0;i<n && j<book->dim;){ | ||
468 | a[i++]=t[j++]<<shift; | ||
469 | } | ||
470 | } | ||
471 | } | ||
472 | }else{ | ||
473 | |||
474 | int i; | ||
475 | for(i=0;i<n;){ | ||
476 | a[i++]=0; | ||
477 | } | ||
478 | } | ||
479 | return(0); | ||
480 | } | ||
481 | |||
482 | /* decode vector / dim granularity gaurding is done in the upper layer */ | ||
483 | static long vorbis_book_decodevv_add_2ch_even(codebook *book,ogg_int32_t **a, | ||
484 | long offset,oggpack_buffer *b, | ||
485 | unsigned int n,int point){ | ||
486 | long k,chunk,read; | ||
487 | int shift=point-book->binarypoint; | ||
488 | long entries[32]; | ||
489 | ogg_int32_t *p0 = &(a[0][offset]); | ||
490 | ogg_int32_t *p1 = &(a[1][offset]); | ||
491 | const unsigned long dim = book->dim; | ||
492 | const ogg_int32_t * const vlist = book->valuelist; | ||
493 | |||
494 | if(shift>=0){ | ||
495 | while(n>0){ | ||
496 | chunk=32; | ||
497 | if (16*dim>n) | ||
498 | chunk=(n*2-1)/dim + 1; | ||
499 | read = decode_packed_block(book,b,entries,chunk); | ||
500 | for(k=0;k<read;k++){ | ||
501 | const ogg_int32_t *t = vlist+entries[k]*dim; | ||
502 | const ogg_int32_t *u = t+dim; | ||
503 | do{ | ||
504 | *p0++ += *t++>>shift; | ||
505 | *p1++ += *t++>>shift; | ||
506 | }while(t<u); | ||
507 | } | ||
508 | if (read<chunk)return-1; | ||
509 | n -= read*dim/2; | ||
510 | } | ||
511 | }else{ | ||
512 | shift = -shift; | ||
513 | while(n>0){ | ||
514 | chunk=32; | ||
515 | if (16*dim>n) | ||
516 | chunk=(n*2-1)/dim + 1; | ||
517 | read = decode_packed_block(book,b,entries,chunk); | ||
518 | for(k=0;k<read;k++){ | ||
519 | const ogg_int32_t *t = vlist+entries[k]*dim; | ||
520 | const ogg_int32_t *u = t+dim; | ||
521 | do{ | ||
522 | *p0++ += *t++<<shift; | ||
523 | *p1++ += *t++<<shift; | ||
524 | }while(t<u); | ||
525 | } | ||
526 | if (read<chunk)return-1; | ||
527 | n -= read*dim/2; | ||
528 | } | ||
529 | } | ||
530 | return(0); | ||
531 | } | ||
532 | |||
533 | long vorbis_book_decodevv_add(codebook *book,ogg_int32_t **a, | ||
534 | long offset,int ch, | ||
535 | oggpack_buffer *b,int n,int point){ | ||
536 | if(LIKELY(book->used_entries>0)){ | ||
537 | long i,j,k,chunk,read; | ||
538 | int chptr=0; | ||
539 | int shift=point-book->binarypoint; | ||
540 | long entries[32]; | ||
541 | |||
542 | if (!(book->dim&1) && ch==2) | ||
543 | return vorbis_book_decodevv_add_2ch_even(book,a,offset,b,n,point); | ||
544 | |||
545 | if(shift>=0){ | ||
546 | |||
547 | for(i=offset;i<offset+n;){ | ||
548 | chunk=32; | ||
549 | if (chunk*book->dim>(offset+n-i)*ch) | ||
550 | chunk=((offset+n-i)*ch+book->dim-1)/book->dim; | ||
551 | read = decode_packed_block(book,b,entries,chunk); | ||
552 | for(k=0;k<read;k++){ | ||
553 | const ogg_int32_t *t = book->valuelist+entries[k]*book->dim; | ||
554 | for (j=0;j<book->dim;j++){ | ||
555 | a[chptr++][i]+=t[j]>>shift; | ||
556 | if(chptr==ch){ | ||
557 | chptr=0; | ||
558 | i++; | ||
559 | } | ||
560 | } | ||
561 | } | ||
562 | if (read<chunk)return-1; | ||
563 | } | ||
564 | }else{ | ||
565 | shift = -shift; | ||
566 | for(i=offset;i<offset+n;){ | ||
567 | chunk=32; | ||
568 | if (chunk*book->dim>(offset+n-i)*ch) | ||
569 | chunk=((offset+n-i)*ch+book->dim-1)/book->dim; | ||
570 | read = decode_packed_block(book,b,entries,chunk); | ||
571 | for(k=0;k<read;k++){ | ||
572 | const ogg_int32_t *t = book->valuelist+entries[k]*book->dim; | ||
573 | for (j=0;j<book->dim;j++){ | ||
574 | a[chptr++][i]+=t[j]<<shift; | ||
575 | if(chptr==ch){ | ||
576 | chptr=0; | ||
577 | i++; | ||
578 | } | ||
579 | } | ||
580 | } | ||
581 | if (read<chunk)return-1; | ||
582 | } | ||
583 | } | ||
584 | } | ||
585 | return(0); | ||
586 | } | ||
587 | |||
diff --git a/lib/rbcodec/codecs/libtremor/codebook.h b/lib/rbcodec/codecs/libtremor/codebook.h new file mode 100644 index 0000000000..29ac9fd923 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/codebook.h | |||
@@ -0,0 +1,101 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: basic shared codebook operations | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _V_CODEBOOK_H_ | ||
19 | #define _V_CODEBOOK_H_ | ||
20 | |||
21 | #include "ogg.h" | ||
22 | |||
23 | /* This structure encapsulates huffman and VQ style encoding books; it | ||
24 | doesn't do anything specific to either. | ||
25 | |||
26 | valuelist/quantlist are nonNULL (and q_* significant) only if | ||
27 | there's entry->value mapping to be done. | ||
28 | |||
29 | If encode-side mapping must be done (and thus the entry needs to be | ||
30 | hunted), the auxiliary encode pointer will point to a decision | ||
31 | tree. This is true of both VQ and huffman, but is mostly useful | ||
32 | with VQ. | ||
33 | |||
34 | */ | ||
35 | |||
36 | typedef struct static_codebook{ | ||
37 | long dim; /* codebook dimensions (elements per vector) */ | ||
38 | long entries; /* codebook entries */ | ||
39 | long *lengthlist; /* codeword lengths in bits */ | ||
40 | |||
41 | /* mapping ***************************************************************/ | ||
42 | int maptype; /* 0=none | ||
43 | 1=implicitly populated values from map column | ||
44 | 2=listed arbitrary values */ | ||
45 | |||
46 | /* The below does a linear, single monotonic sequence mapping. */ | ||
47 | long q_min; /* packed 32 bit float; quant value 0 maps to minval */ | ||
48 | long q_delta; /* packed 32 bit float; val 1 - val 0 == delta */ | ||
49 | int q_quant; /* bits: 0 < quant <= 16 */ | ||
50 | int q_sequencep; /* bitflag */ | ||
51 | |||
52 | long *quantlist; /* map == 1: (int)(entries^(1/dim)) element column map | ||
53 | map == 2: list of dim*entries quantized entry vals | ||
54 | */ | ||
55 | } static_codebook; | ||
56 | |||
57 | typedef struct codebook{ | ||
58 | long dim; /* codebook dimensions (elements per vector) */ | ||
59 | long entries; /* codebook entries */ | ||
60 | long used_entries; /* populated codebook entries */ | ||
61 | |||
62 | /* the below are ordered by bitreversed codeword and only used | ||
63 | entries are populated */ | ||
64 | int binarypoint; | ||
65 | ogg_int32_t *valuelist; /* list of dim*entries actual entry values */ | ||
66 | ogg_uint32_t *codelist; /* list of bitstream codewords for each entry */ | ||
67 | |||
68 | int *dec_index; | ||
69 | char *dec_codelengths; | ||
70 | ogg_uint32_t *dec_firsttable; | ||
71 | int dec_firsttablen; | ||
72 | int dec_maxlength; | ||
73 | |||
74 | long q_min; /* packed 32 bit float; quant value 0 maps to minval */ | ||
75 | long q_delta; /* packed 32 bit float; val 1 - val 0 == delta */ | ||
76 | |||
77 | } codebook; | ||
78 | |||
79 | extern void vorbis_staticbook_destroy(static_codebook *b); | ||
80 | extern int vorbis_book_init_decode(codebook *dest,const static_codebook *source); | ||
81 | |||
82 | extern void vorbis_book_clear(codebook *b); | ||
83 | extern long _book_maptype1_quantvals(const static_codebook *b); | ||
84 | |||
85 | extern static_codebook *vorbis_staticbook_unpack(oggpack_buffer *b); | ||
86 | |||
87 | extern long vorbis_book_decode(codebook *book, oggpack_buffer *b); | ||
88 | extern long vorbis_book_decodevs_add(codebook *book, ogg_int32_t *a, | ||
89 | oggpack_buffer *b,int n,int point); | ||
90 | extern long vorbis_book_decodev_set(codebook *book, ogg_int32_t *a, | ||
91 | oggpack_buffer *b,int n,int point); | ||
92 | extern long vorbis_book_decodev_add(codebook *book, ogg_int32_t *a, | ||
93 | oggpack_buffer *b,int n,int point); | ||
94 | extern long vorbis_book_decodevv_add(codebook *book, ogg_int32_t **a, | ||
95 | long off,int ch, | ||
96 | oggpack_buffer *b,int n,int point); | ||
97 | |||
98 | extern int _ilog(unsigned int v); | ||
99 | |||
100 | |||
101 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/codec_internal.h b/lib/rbcodec/codecs/libtremor/codec_internal.h new file mode 100644 index 0000000000..3cbd7cde89 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/codec_internal.h | |||
@@ -0,0 +1,93 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: libvorbis codec headers | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _V_CODECI_H_ | ||
19 | #define _V_CODECI_H_ | ||
20 | |||
21 | #include "codebook.h" | ||
22 | |||
23 | typedef void vorbis_look_mapping; | ||
24 | typedef void vorbis_look_floor; | ||
25 | typedef void vorbis_look_residue; | ||
26 | typedef void vorbis_look_transform; | ||
27 | |||
28 | /* mode ************************************************************/ | ||
29 | typedef struct { | ||
30 | int blockflag; | ||
31 | int windowtype; | ||
32 | int transformtype; | ||
33 | int mapping; | ||
34 | } vorbis_info_mode; | ||
35 | |||
36 | typedef void vorbis_info_floor; | ||
37 | typedef void vorbis_info_residue; | ||
38 | typedef void vorbis_info_mapping; | ||
39 | |||
40 | typedef struct private_state { | ||
41 | /* local lookup storage */ | ||
42 | const void *window[2]; | ||
43 | |||
44 | /* backend lookups are tied to the mode, not the backend or naked mapping */ | ||
45 | int modebits; | ||
46 | vorbis_look_mapping **mode; | ||
47 | |||
48 | ogg_int64_t sample_count; | ||
49 | |||
50 | } private_state; | ||
51 | |||
52 | /* codec_setup_info contains all the setup information specific to the | ||
53 | specific compression/decompression mode in progress (eg, | ||
54 | psychoacoustic settings, channel setup, options, codebook | ||
55 | etc). | ||
56 | *********************************************************************/ | ||
57 | |||
58 | typedef struct codec_setup_info { | ||
59 | |||
60 | /* Vorbis supports only short and long blocks, but allows the | ||
61 | encoder to choose the sizes */ | ||
62 | |||
63 | int blocksizes_nbits[2]; | ||
64 | long blocksizes[2]; /* = 1<<nbits */ | ||
65 | |||
66 | /* modes are the primary means of supporting on-the-fly different | ||
67 | blocksizes, different channel mappings (LR or M/A), | ||
68 | different residue backends, etc. Each mode consists of a | ||
69 | blocksize flag and a mapping (along with the mapping setup */ | ||
70 | |||
71 | int modes; | ||
72 | int maps; | ||
73 | int times; | ||
74 | int floors; | ||
75 | int residues; | ||
76 | int books; | ||
77 | |||
78 | vorbis_info_mode *mode_param[64]; | ||
79 | int map_type[64]; | ||
80 | vorbis_info_mapping *map_param[64]; | ||
81 | int time_type[64]; | ||
82 | int floor_type[64]; | ||
83 | vorbis_info_floor *floor_param[64]; | ||
84 | int residue_type[64]; | ||
85 | vorbis_info_residue *residue_param[64]; | ||
86 | static_codebook *book_param[256]; | ||
87 | codebook *fullbooks; | ||
88 | |||
89 | int passlimit[32]; /* iteration limit per couple/quant pass */ | ||
90 | int coupling_passes; | ||
91 | } codec_setup_info; | ||
92 | |||
93 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/config-tremor.h b/lib/rbcodec/codecs/libtremor/config-tremor.h new file mode 100644 index 0000000000..cf2dbe977d --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/config-tremor.h | |||
@@ -0,0 +1,55 @@ | |||
1 | #ifndef _CONFIG_TREMOR_H | ||
2 | #define _CONFIG_TREMOR_H | ||
3 | |||
4 | #include "codeclib.h" | ||
5 | |||
6 | #ifdef CPU_ARM | ||
7 | #define _ARM_ASSEM_ | ||
8 | #endif | ||
9 | |||
10 | #ifndef BYTE_ORDER | ||
11 | #ifdef ROCKBOX_BIG_ENDIAN | ||
12 | #define BIG_ENDIAN 1 | ||
13 | #define LITTLE_ENDIAN 0 | ||
14 | #define BYTE_ORDER BIG_ENDIAN | ||
15 | #else | ||
16 | #define BYTE_ORDER LITTLE_ENDIAN | ||
17 | #define LITTLE_ENDIAN 1 | ||
18 | #define BIG_ENDIAN 0 | ||
19 | #endif | ||
20 | #endif | ||
21 | |||
22 | #ifndef ICODE_ATTR_TREMOR_NOT_MDCT | ||
23 | #define ICODE_ATTR_TREMOR_NOT_MDCT ICODE_ATTR | ||
24 | #endif | ||
25 | |||
26 | /* Enable special handling of buffers in faster ram, not usefull when no | ||
27 | such different ram is available. There are 3 different memory configurations | ||
28 | * No special iram, uses double buffers to avoid copying data | ||
29 | * Small special iram, copies buffers to run hottest processing in iram | ||
30 | * Large iram, uses double buffers in iram */ | ||
31 | #ifdef USE_IRAM | ||
32 | #define TREMOR_USE_IRAM | ||
33 | |||
34 | /* Define CPU of large IRAM (PP5022/5024, MCF5250) */ | ||
35 | #if (CONFIG_CPU == PP5022) || (CONFIG_CPU == PP5024) || defined(CPU_S5L870X) || (CONFIG_CPU == MCF5250) | ||
36 | /* PCM_BUFFER : 32768 byte (4096*2*4 or 2048*4*4) * | ||
37 | * WINDOW_LOOKUP : 9216 Byte (256*4 + 2048*4) * | ||
38 | * TOTAL : 41984 */ | ||
39 | #define IRAM_IBSS_SIZE 41984 | ||
40 | |||
41 | /* Define CPU of Normal IRAM (96KB) */ | ||
42 | #else | ||
43 | /* floor and double residue buffer : 24576 Byte (2048/2*4*2*3) * | ||
44 | * WINDOW_LOOKUP : 4608 Byte (128*4 + 1024*4) * | ||
45 | * TOTAL : 29184 */ | ||
46 | #define IRAM_IBSS_SIZE 29184 | ||
47 | #endif | ||
48 | #endif | ||
49 | |||
50 | /* max 2 channels */ | ||
51 | #define CHANNELS 2 | ||
52 | |||
53 | // #define _LOW_ACCURACY_ | ||
54 | |||
55 | #endif /* _CONFIG_TREMOR_H */ | ||
diff --git a/lib/rbcodec/codecs/libtremor/config_types.h b/lib/rbcodec/codecs/libtremor/config_types.h new file mode 100644 index 0000000000..1fdcb27fe7 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/config_types.h | |||
@@ -0,0 +1,25 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: #ifdef jail to whip a few platforms into the UNIX ideal. | ||
15 | |||
16 | ********************************************************************/ | ||
17 | #ifndef _OS_CVTYPES_H | ||
18 | #define _OS_CVTYPES_H | ||
19 | |||
20 | typedef long long ogg_int64_t; | ||
21 | typedef int ogg_int32_t; | ||
22 | typedef unsigned int ogg_uint32_t; | ||
23 | typedef short ogg_int16_t; | ||
24 | |||
25 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/ctype.c b/lib/rbcodec/codecs/libtremor/ctype.c new file mode 100644 index 0000000000..9f22047675 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/ctype.c | |||
@@ -0,0 +1,4 @@ | |||
1 | #include "config.h" | ||
2 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
3 | #include "libc/ctype.c" | ||
4 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/ffmpeg_stuff.h b/lib/rbcodec/codecs/libtremor/ffmpeg_stuff.h new file mode 100644 index 0000000000..d7fa846507 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/ffmpeg_stuff.h | |||
@@ -0,0 +1,140 @@ | |||
1 | /** | ||
2 | * @file | ||
3 | * Common code for Vorbis I encoder and decoder | ||
4 | * @author Denes Balatoni ( dbalatoni programozo hu ) | ||
5 | * | ||
6 | * This file is part of FFmpeg. | ||
7 | * | ||
8 | * FFmpeg is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * License as published by the Free Software Foundation; either | ||
11 | * version 2.1 of the License, or (at your option) any later version. | ||
12 | * | ||
13 | * FFmpeg is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU Lesser General Public | ||
19 | * License along with FFmpeg; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
21 | */ | ||
22 | |||
23 | /* render_line and friend taken from ffmpeg (libavcodec/vorbis.c) */ | ||
24 | |||
25 | #include "misc.h" | ||
26 | |||
27 | static inline void render_line_unrolled(int x, int y, int x1, | ||
28 | int sy, int ady, int adx, | ||
29 | const ogg_int32_t *lookup, ogg_int32_t *buf) | ||
30 | { | ||
31 | int err = -adx; | ||
32 | x -= x1 - 1; | ||
33 | buf += x1 - 1; | ||
34 | while (++x < 0) { | ||
35 | err += ady; | ||
36 | if (err >= 0) { | ||
37 | err += ady - adx; | ||
38 | y += sy; | ||
39 | buf[x] = MULT31_SHIFT15(buf[x],lookup[y]); | ||
40 | x++; | ||
41 | } | ||
42 | buf[x] = MULT31_SHIFT15(buf[x],lookup[y]); | ||
43 | } | ||
44 | if (x <= 0) { | ||
45 | if (err + ady >= 0) | ||
46 | y += sy; | ||
47 | buf[x] = MULT31_SHIFT15(buf[x],lookup[y]); | ||
48 | } | ||
49 | } | ||
50 | |||
51 | static inline void render_line(int x0, int y0, int x1, int y1, | ||
52 | const ogg_int32_t *lookup, ogg_int32_t *buf) | ||
53 | { | ||
54 | int dy = y1 - y0; | ||
55 | int adx = x1 - x0; | ||
56 | int ady = abs(dy); | ||
57 | int sy = dy < 0 ? -1 : 1; | ||
58 | buf[x0] = MULT31_SHIFT15(buf[x0],lookup[y0]); | ||
59 | if (ady*2 <= adx) { // optimized common case | ||
60 | render_line_unrolled(x0, y0, x1, sy, ady, adx, lookup, buf); | ||
61 | } else { | ||
62 | int base = dy / adx; | ||
63 | int x = x0; | ||
64 | int y = y0; | ||
65 | int err = -adx; | ||
66 | ady -= abs(base) * adx; | ||
67 | while (++x < x1) { | ||
68 | y += base; | ||
69 | err += ady; | ||
70 | if (err >= 0) { | ||
71 | err -= adx; | ||
72 | y += sy; | ||
73 | } | ||
74 | buf[x] = MULT31_SHIFT15(buf[x],lookup[y]); | ||
75 | } | ||
76 | } | ||
77 | } | ||
78 | |||
79 | #ifndef INCL_OPTIMIZED_VECTOR_FMUL_WINDOW | ||
80 | #define INCL_OPTIMIZED_VECTOR_FMUL_WINDOW | ||
81 | static inline void ff_vector_fmul_window_c(ogg_int32_t *dst, const ogg_int32_t *src0, | ||
82 | const ogg_int32_t *src1, const ogg_int32_t *win, int len){ | ||
83 | int i,j; | ||
84 | dst += len; | ||
85 | win += len; | ||
86 | src0+= len; | ||
87 | for(i=-len, j=len-1; i<0; i++, j--) { | ||
88 | ogg_int32_t s0 = src0[i]; | ||
89 | ogg_int32_t s1 = src1[j]; | ||
90 | ogg_int32_t wi = win[i]; | ||
91 | ogg_int32_t wj = win[j]; | ||
92 | XNPROD31(s0, s1, wj, wi, &dst[i], &dst[j]); | ||
93 | /* | ||
94 | dst[i] = MULT31(s0,wj) - MULT31(s1,wi); | ||
95 | dst[j] = MULT31(s0,wi) + MULT31(s1,wj); | ||
96 | */ | ||
97 | } | ||
98 | } | ||
99 | #endif | ||
100 | |||
101 | static inline void copy_normalize(ogg_int32_t *dst, ogg_int32_t *src, int len) | ||
102 | { | ||
103 | memcpy(dst, src, len * sizeof(ogg_int32_t)); | ||
104 | } | ||
105 | |||
106 | static inline void window_overlap_add(unsigned int blocksize, unsigned int lastblock, | ||
107 | unsigned int bs0, unsigned int bs1, int ch, | ||
108 | const ogg_int32_t *win, vorbis_dsp_state *v) | ||
109 | { | ||
110 | unsigned retlen = (blocksize + lastblock) / 4; | ||
111 | int j; | ||
112 | for (j = 0; j < ch; j++) { | ||
113 | ogg_int32_t *residue = v->residues[v->ri] + j * blocksize / 2; | ||
114 | ogg_int32_t *saved = v->saved_ptr[j]; | ||
115 | ogg_int32_t *ret = v->floors + j * retlen; | ||
116 | ogg_int32_t *buf = residue; | ||
117 | |||
118 | if (v->W == v->lW) { | ||
119 | ff_vector_fmul_window_c(ret, saved, buf, win, blocksize / 4); | ||
120 | } else if (v->W > v->lW) { | ||
121 | ff_vector_fmul_window_c(ret, saved, buf, win, bs0 / 4); | ||
122 | copy_normalize(ret+bs0/2, buf+bs0/4, (bs1-bs0)/4); | ||
123 | } else { | ||
124 | copy_normalize(ret, saved, (bs1 - bs0) / 4); | ||
125 | ff_vector_fmul_window_c(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4); | ||
126 | } | ||
127 | if (v->residues[1] == NULL) { | ||
128 | memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(ogg_int32_t)); | ||
129 | v->saved_ptr[j] = v->saved + j * bs1 / 4; | ||
130 | } else { | ||
131 | v->saved_ptr[j] = buf + blocksize / 4; | ||
132 | } | ||
133 | |||
134 | v->pcmb[j] = ret; | ||
135 | } | ||
136 | |||
137 | if (v->residues[1] != NULL) { | ||
138 | v->ri ^= 1; | ||
139 | } | ||
140 | } | ||
diff --git a/lib/rbcodec/codecs/libtremor/floor0.c b/lib/rbcodec/codecs/libtremor/floor0.c new file mode 100644 index 0000000000..cd0a9f89f6 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/floor0.c | |||
@@ -0,0 +1,444 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: floor backend 0 implementation | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <string.h> | ||
20 | #include <math.h> | ||
21 | #include "ogg.h" | ||
22 | #include "ivorbiscodec.h" | ||
23 | #include "codec_internal.h" | ||
24 | #include "registry.h" | ||
25 | #include "codebook.h" | ||
26 | #include "misc.h" | ||
27 | #include "os.h" | ||
28 | |||
29 | #define LSP_FRACBITS 14 | ||
30 | |||
31 | typedef struct { | ||
32 | long n; | ||
33 | int ln; | ||
34 | int m; | ||
35 | int *linearmap; | ||
36 | |||
37 | vorbis_info_floor0 *vi; | ||
38 | ogg_int32_t *lsp_look; | ||
39 | |||
40 | } vorbis_look_floor0; | ||
41 | |||
42 | /*************** LSP decode ********************/ | ||
43 | |||
44 | #include "lsp_lookup.h" | ||
45 | |||
46 | /* interpolated 1./sqrt(p) where .5 <= a < 1. (.100000... to .111111...) in | ||
47 | 16.16 format | ||
48 | returns in m.8 format */ | ||
49 | |||
50 | static const long ADJUST_SQRT2[2] ={8192,5792}; | ||
51 | static inline ogg_int32_t vorbis_invsqlook_i(long a,long e){ | ||
52 | long i=(a&0x7fff)>>(INVSQ_LOOKUP_I_SHIFT-1); | ||
53 | long d=a&INVSQ_LOOKUP_I_MASK; /* 0.10 */ | ||
54 | long val=INVSQ_LOOKUP_I[i]- /* 1.16 */ | ||
55 | ((INVSQ_LOOKUP_IDel[i]*d)>>INVSQ_LOOKUP_I_SHIFT); /* result 1.16 */ | ||
56 | val*=ADJUST_SQRT2[e&1]; | ||
57 | e=(e>>1)+21; | ||
58 | return(val>>e); | ||
59 | } | ||
60 | |||
61 | /* interpolated lookup based fromdB function, domain -140dB to 0dB only */ | ||
62 | /* a is in n.12 format */ | ||
63 | static inline ogg_int32_t vorbis_fromdBlook_i(long a){ | ||
64 | int i=(-a)>>(12-FROMdB2_SHIFT); | ||
65 | if(i<0) return 0x7fffffff; | ||
66 | if(i>=(FROMdB_LOOKUP_SZ<<FROMdB_SHIFT))return 0; | ||
67 | |||
68 | return FROMdB_LOOKUP[i>>FROMdB_SHIFT] * FROMdB2_LOOKUP[i&FROMdB2_MASK]; | ||
69 | } | ||
70 | |||
71 | /* interpolated lookup based cos function, domain 0 to PI only */ | ||
72 | /* a is in 0.16 format, where 0==0, 2^^16-1==PI, return 0.14 */ | ||
73 | static inline ogg_int32_t vorbis_coslook_i(long a){ | ||
74 | int i=a>>COS_LOOKUP_I_SHIFT; | ||
75 | int d=a&COS_LOOKUP_I_MASK; | ||
76 | return COS_LOOKUP_I[i]- ((d*(COS_LOOKUP_I[i]-COS_LOOKUP_I[i+1]))>> | ||
77 | COS_LOOKUP_I_SHIFT); | ||
78 | } | ||
79 | |||
80 | /* interpolated lookup based cos function */ | ||
81 | /* a is in 0.16 format, where 0==0, 2^^16==PI, return .LSP_FRACBITS */ | ||
82 | static inline ogg_int32_t vorbis_coslook2_i(long a){ | ||
83 | a=a&0x1ffff; | ||
84 | |||
85 | if(a>0x10000)a=0x20000-a; | ||
86 | { | ||
87 | int i=a>>COS_LOOKUP_I_SHIFT; | ||
88 | int d=a&COS_LOOKUP_I_MASK; | ||
89 | a=((COS_LOOKUP_I[i]<<COS_LOOKUP_I_SHIFT)- | ||
90 | d*(COS_LOOKUP_I[i]-COS_LOOKUP_I[i+1]))>> | ||
91 | (COS_LOOKUP_I_SHIFT-LSP_FRACBITS+14); | ||
92 | } | ||
93 | |||
94 | return(a); | ||
95 | } | ||
96 | |||
97 | static const int barklook[28] ={ | ||
98 | 0,100,200,301, 405,516,635,766, | ||
99 | 912,1077,1263,1476, 1720,2003,2333,2721, | ||
100 | 3184,3742,4428,5285, 6376,7791,9662,12181, | ||
101 | 15624,20397,27087,36554 | ||
102 | }; | ||
103 | |||
104 | /* used in init only; interpolate the long way */ | ||
105 | static inline ogg_int32_t toBARK(int n){ | ||
106 | int i; | ||
107 | for(i=0;i<27;i++) | ||
108 | if(n>=barklook[i] && n<barklook[i+1])break; | ||
109 | |||
110 | if(i==27){ | ||
111 | return 27<<15; | ||
112 | }else{ | ||
113 | int gap=barklook[i+1]-barklook[i]; | ||
114 | int del=n-barklook[i]; | ||
115 | |||
116 | return((i<<15)+((del<<15)/gap)); | ||
117 | } | ||
118 | } | ||
119 | |||
120 | static const unsigned char MLOOP_1[64] ={ | ||
121 | 0,10,11,11, 12,12,12,12, 13,13,13,13, 13,13,13,13, | ||
122 | 14,14,14,14, 14,14,14,14, 14,14,14,14, 14,14,14,14, | ||
123 | 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, | ||
124 | 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, | ||
125 | }; | ||
126 | |||
127 | static const unsigned char MLOOP_2[64] ={ | ||
128 | 0,4,5,5, 6,6,6,6, 7,7,7,7, 7,7,7,7, | ||
129 | 8,8,8,8, 8,8,8,8, 8,8,8,8, 8,8,8,8, | ||
130 | 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9, | ||
131 | 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9, | ||
132 | }; | ||
133 | |||
134 | static const unsigned char MLOOP_3[8] ={0,1,2,2,3,3,3,3}; | ||
135 | |||
136 | static void vorbis_lsp_to_curve(ogg_int32_t *curve,int *map,int n,int ln, | ||
137 | ogg_int32_t *lsp,int m, | ||
138 | ogg_int32_t amp, | ||
139 | ogg_int32_t ampoffset, | ||
140 | ogg_int32_t *icos){ | ||
141 | |||
142 | (void)ln; | ||
143 | /* 0 <= m < 256 */ | ||
144 | |||
145 | /* set up for using all int later */ | ||
146 | int i; | ||
147 | int ampoffseti=ampoffset*4096; | ||
148 | int ampi=amp; | ||
149 | ogg_int32_t *ilsp=(ogg_int32_t *)alloca(m*sizeof(*ilsp)); | ||
150 | /* lsp is in 8.24, range 0 to PI; coslook wants it in .16 0 to 1*/ | ||
151 | for(i=0;i<m;i++){ | ||
152 | #ifndef _LOW_ACCURACY_ | ||
153 | ogg_int32_t val=MULT32(lsp[i],0x517cc2); | ||
154 | #else | ||
155 | ogg_int32_t val=((lsp[i]>>10)*0x517d)>>14; | ||
156 | #endif | ||
157 | |||
158 | /* safeguard against a malicious stream */ | ||
159 | if(val<0 || (val>>COS_LOOKUP_I_SHIFT)>=COS_LOOKUP_I_SZ){ | ||
160 | memset(curve,0,sizeof(*curve)*n); | ||
161 | return; | ||
162 | } | ||
163 | |||
164 | ilsp[i]=vorbis_coslook_i(val); | ||
165 | } | ||
166 | |||
167 | i=0; | ||
168 | while(i<n){ | ||
169 | int j,k=map[i]; | ||
170 | ogg_uint32_t pi=46341; /* 2**-.5 in 0.16 */ | ||
171 | ogg_uint32_t qi=46341; | ||
172 | ogg_int32_t qexp=0,shift; | ||
173 | ogg_int32_t wi=icos[k]; | ||
174 | |||
175 | #ifdef _V_LSP_MATH_ASM | ||
176 | (void)shift; /* kill warnings */ | ||
177 | (void)j; | ||
178 | lsp_loop_asm(&qi,&pi,&qexp,ilsp,wi,m); | ||
179 | |||
180 | pi=((pi*pi)>>16); | ||
181 | qi=((qi*qi)>>16); | ||
182 | |||
183 | if(m&1){ | ||
184 | qexp= qexp*2-28*((m+1)>>1)+m; | ||
185 | pi*=(1<<14)-((wi*wi)>>14); | ||
186 | qi+=pi>>14; | ||
187 | }else{ | ||
188 | qexp= qexp*2-13*m; | ||
189 | |||
190 | pi*=(1<<14)-wi; | ||
191 | qi*=(1<<14)+wi; | ||
192 | |||
193 | qi=(qi+pi)>>14; | ||
194 | } | ||
195 | |||
196 | if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */ | ||
197 | qi>>=1; qexp++; | ||
198 | }else | ||
199 | lsp_norm_asm(&qi,&qexp); | ||
200 | |||
201 | #else | ||
202 | |||
203 | j=1; | ||
204 | if(m>1){ | ||
205 | qi*=labs(ilsp[0]-wi); | ||
206 | pi*=labs(ilsp[1]-wi); | ||
207 | |||
208 | for(j+=2;j<m;j+=2){ | ||
209 | if(!(shift=MLOOP_1[(pi|qi)>>25])) | ||
210 | if(!(shift=MLOOP_2[(pi|qi)>>19])) | ||
211 | shift=MLOOP_3[(pi|qi)>>16]; | ||
212 | qi=(qi>>shift)*labs(ilsp[j-1]-wi); | ||
213 | pi=(pi>>shift)*labs(ilsp[j]-wi); | ||
214 | qexp+=shift; | ||
215 | } | ||
216 | } | ||
217 | if(!(shift=MLOOP_1[(pi|qi)>>25])) | ||
218 | if(!(shift=MLOOP_2[(pi|qi)>>19])) | ||
219 | shift=MLOOP_3[(pi|qi)>>16]; | ||
220 | |||
221 | /* pi,qi normalized collectively, both tracked using qexp */ | ||
222 | |||
223 | if(m&1){ | ||
224 | /* odd order filter; slightly assymetric */ | ||
225 | /* the last coefficient */ | ||
226 | qi=(qi>>shift)*labs(ilsp[j-1]-wi); | ||
227 | pi=(pi>>shift)<<14; | ||
228 | qexp+=shift; | ||
229 | |||
230 | if(!(shift=MLOOP_1[(pi|qi)>>25])) | ||
231 | if(!(shift=MLOOP_2[(pi|qi)>>19])) | ||
232 | shift=MLOOP_3[(pi|qi)>>16]; | ||
233 | |||
234 | pi>>=shift; | ||
235 | qi>>=shift; | ||
236 | qexp+=shift-14*((m+1)>>1); | ||
237 | |||
238 | pi=((pi*pi)>>16); | ||
239 | qi=((qi*qi)>>16); | ||
240 | qexp=qexp*2+m; | ||
241 | |||
242 | pi*=(1<<14)-((wi*wi)>>14); | ||
243 | qi+=pi>>14; | ||
244 | |||
245 | }else{ | ||
246 | /* even order filter; still symmetric */ | ||
247 | |||
248 | /* p*=p(1-w), q*=q(1+w), let normalization drift because it isn't | ||
249 | worth tracking step by step */ | ||
250 | |||
251 | pi>>=shift; | ||
252 | qi>>=shift; | ||
253 | qexp+=shift-7*m; | ||
254 | |||
255 | pi=((pi*pi)>>16); | ||
256 | qi=((qi*qi)>>16); | ||
257 | qexp=qexp*2+m; | ||
258 | |||
259 | pi*=(1<<14)-wi; | ||
260 | qi*=(1<<14)+wi; | ||
261 | qi=(qi+pi)>>14; | ||
262 | |||
263 | } | ||
264 | |||
265 | |||
266 | /* we've let the normalization drift because it wasn't important; | ||
267 | however, for the lookup, things must be normalized again. We | ||
268 | need at most one right shift or a number of left shifts */ | ||
269 | |||
270 | if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */ | ||
271 | qi>>=1; qexp++; | ||
272 | }else | ||
273 | while(qi && !(qi&0x8000)){ /* checks for 0.0xxxxxxxxxxxxxxx or less*/ | ||
274 | qi<<=1; qexp--; | ||
275 | } | ||
276 | |||
277 | #endif | ||
278 | |||
279 | amp=vorbis_fromdBlook_i(ampi* /* n.4 */ | ||
280 | vorbis_invsqlook_i(qi,qexp)- | ||
281 | /* m.8, m+n<=8 */ | ||
282 | ampoffseti); /* 8.12[0] */ | ||
283 | |||
284 | #ifdef _LOW_ACCURACY_ | ||
285 | amp>>=9; | ||
286 | #endif | ||
287 | curve[i]= MULT31_SHIFT15(curve[i],amp); | ||
288 | while(map[++i]==k) curve[i]= MULT31_SHIFT15(curve[i],amp); | ||
289 | } | ||
290 | } | ||
291 | |||
292 | /*************** vorbis decode glue ************/ | ||
293 | |||
294 | static void floor0_free_info(vorbis_info_floor *i){ | ||
295 | vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; | ||
296 | if(info){ | ||
297 | memset(info,0,sizeof(*info)); | ||
298 | _ogg_free(info); | ||
299 | } | ||
300 | } | ||
301 | |||
302 | static void floor0_free_look(vorbis_look_floor *i){ | ||
303 | vorbis_look_floor0 *look=(vorbis_look_floor0 *)i; | ||
304 | if(look){ | ||
305 | |||
306 | if(look->linearmap)_ogg_free(look->linearmap); | ||
307 | if(look->lsp_look)_ogg_free(look->lsp_look); | ||
308 | memset(look,0,sizeof(*look)); | ||
309 | _ogg_free(look); | ||
310 | } | ||
311 | } | ||
312 | |||
313 | static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){ | ||
314 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
315 | int j; | ||
316 | |||
317 | vorbis_info_floor0 *info=(vorbis_info_floor0 *)_ogg_malloc(sizeof(*info)); | ||
318 | info->order=oggpack_read(opb,8); | ||
319 | info->rate=oggpack_read(opb,16); | ||
320 | info->barkmap=oggpack_read(opb,16); | ||
321 | info->ampbits=oggpack_read(opb,6); | ||
322 | info->ampdB=oggpack_read(opb,8); | ||
323 | info->numbooks=oggpack_read(opb,4)+1; | ||
324 | |||
325 | if(info->order<1)goto err_out; | ||
326 | if(info->rate<1)goto err_out; | ||
327 | if(info->barkmap<1)goto err_out; | ||
328 | if(info->numbooks<1)goto err_out; | ||
329 | |||
330 | for(j=0;j<info->numbooks;j++){ | ||
331 | info->books[j]=oggpack_read(opb,8); | ||
332 | if(info->books[j]<0 || info->books[j]>=ci->books)goto err_out; | ||
333 | if(ci->book_param[info->books[j]]->maptype==0)goto err_out; | ||
334 | if(ci->book_param[info->books[j]]->dim<1)goto err_out; | ||
335 | } | ||
336 | return(info); | ||
337 | |||
338 | err_out: | ||
339 | floor0_free_info(info); | ||
340 | return(NULL); | ||
341 | } | ||
342 | |||
343 | /* initialize Bark scale and normalization lookups. We could do this | ||
344 | with static tables, but Vorbis allows a number of possible | ||
345 | combinations, so it's best to do it computationally. | ||
346 | |||
347 | The below is authoritative in terms of defining scale mapping. | ||
348 | Note that the scale depends on the sampling rate as well as the | ||
349 | linear block and mapping sizes */ | ||
350 | |||
351 | static vorbis_look_floor *floor0_look (vorbis_dsp_state *vd,vorbis_info_mode *mi, | ||
352 | vorbis_info_floor *i){ | ||
353 | int j; | ||
354 | // ogg_int32_t scale; | ||
355 | vorbis_info *vi=vd->vi; | ||
356 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
357 | vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; | ||
358 | vorbis_look_floor0 *look=(vorbis_look_floor0 *)_ogg_calloc(1,sizeof(*look)); | ||
359 | look->m=info->order; | ||
360 | look->n=ci->blocksizes[mi->blockflag]/2; | ||
361 | look->ln=info->barkmap; | ||
362 | look->vi=info; | ||
363 | |||
364 | /* the mapping from a linear scale to a smaller bark scale is | ||
365 | straightforward. We do *not* make sure that the linear mapping | ||
366 | does not skip bark-scale bins; the decoder simply skips them and | ||
367 | the encoder may do what it wishes in filling them. They're | ||
368 | necessary in some mapping combinations to keep the scale spacing | ||
369 | accurate */ | ||
370 | look->linearmap=(int *)_ogg_malloc((look->n+1)*sizeof(*look->linearmap)); | ||
371 | for(j=0;j<look->n;j++){ | ||
372 | |||
373 | int val=(look->ln* | ||
374 | ((toBARK(info->rate/2*j/look->n)<<11)/toBARK(info->rate/2)))>>11; | ||
375 | |||
376 | if(val>=look->ln)val=look->ln-1; /* guard against the approximation */ | ||
377 | look->linearmap[j]=val; | ||
378 | } | ||
379 | look->linearmap[j]=-1; | ||
380 | |||
381 | look->lsp_look=(ogg_int32_t *)_ogg_malloc(look->ln*sizeof(*look->lsp_look)); | ||
382 | for(j=0;j<look->ln;j++) | ||
383 | look->lsp_look[j]=vorbis_coslook2_i(0x10000*j/look->ln); | ||
384 | |||
385 | return look; | ||
386 | } | ||
387 | |||
388 | static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){ | ||
389 | vorbis_look_floor0 *look=(vorbis_look_floor0 *)i; | ||
390 | vorbis_info_floor0 *info=look->vi; | ||
391 | int j,k; | ||
392 | |||
393 | int ampraw=oggpack_read(&vb->opb,info->ampbits); | ||
394 | if(ampraw>0){ /* also handles the -1 out of data case */ | ||
395 | long maxval=(1<<info->ampbits)-1; | ||
396 | int amp=((ampraw*info->ampdB)<<4)/maxval; | ||
397 | int booknum=oggpack_read(&vb->opb,_ilog(info->numbooks)); | ||
398 | |||
399 | if(booknum!=-1 && booknum<info->numbooks){ /* be paranoid */ | ||
400 | codec_setup_info *ci=(codec_setup_info *)vb->vd->vi->codec_setup; | ||
401 | codebook *b=ci->fullbooks+info->books[booknum]; | ||
402 | ogg_int32_t last=0; | ||
403 | ogg_int32_t *lsp=(ogg_int32_t *)_vorbis_block_alloc(vb,sizeof(*lsp)*(look->m+1)); | ||
404 | |||
405 | if(vorbis_book_decodev_set(b,lsp,&vb->opb,look->m,-24)==-1)goto eop; | ||
406 | for(j=0;j<look->m;){ | ||
407 | for(k=0;j<look->m && k<b->dim;k++,j++)lsp[j]+=last; | ||
408 | last=lsp[j-1]; | ||
409 | } | ||
410 | |||
411 | lsp[look->m]=amp; | ||
412 | return(lsp); | ||
413 | } | ||
414 | } | ||
415 | eop: | ||
416 | return(NULL); | ||
417 | } | ||
418 | |||
419 | static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i, | ||
420 | void *memo,ogg_int32_t *out){ | ||
421 | vorbis_look_floor0 *look=(vorbis_look_floor0 *)i; | ||
422 | vorbis_info_floor0 *info=look->vi; | ||
423 | (void)vb; | ||
424 | |||
425 | if(memo){ | ||
426 | ogg_int32_t *lsp=(ogg_int32_t *)memo; | ||
427 | ogg_int32_t amp=lsp[look->m]; | ||
428 | |||
429 | /* take the coefficients back to a spectral envelope curve */ | ||
430 | vorbis_lsp_to_curve(out,look->linearmap,look->n,look->ln, | ||
431 | lsp,look->m,amp,info->ampdB,look->lsp_look); | ||
432 | return(1); | ||
433 | } | ||
434 | memset(out,0,sizeof(*out)*look->n); | ||
435 | return(0); | ||
436 | } | ||
437 | |||
438 | /* export hooks */ | ||
439 | const vorbis_func_floor floor0_exportbundle ICONST_ATTR ={ | ||
440 | &floor0_unpack,&floor0_look,&floor0_free_info, | ||
441 | &floor0_free_look,&floor0_inverse1,&floor0_inverse2 | ||
442 | }; | ||
443 | |||
444 | |||
diff --git a/lib/rbcodec/codecs/libtremor/floor1.c b/lib/rbcodec/codecs/libtremor/floor1.c new file mode 100644 index 0000000000..d2268db121 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/floor1.c | |||
@@ -0,0 +1,426 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: floor backend 1 implementation | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <string.h> | ||
20 | #include <math.h> | ||
21 | #include "ogg.h" | ||
22 | #include "ivorbiscodec.h" | ||
23 | #include "codec_internal.h" | ||
24 | #include "registry.h" | ||
25 | #include "codebook.h" | ||
26 | #include "misc.h" | ||
27 | #include "ffmpeg_stuff.h" | ||
28 | |||
29 | #define floor1_rangedB 140 /* floor 1 fixed at -140dB to 0dB range */ | ||
30 | |||
31 | typedef struct { | ||
32 | int forward_index[VIF_POSIT+2]; | ||
33 | |||
34 | int hineighbor[VIF_POSIT]; | ||
35 | int loneighbor[VIF_POSIT]; | ||
36 | int posts; | ||
37 | |||
38 | int n; | ||
39 | int quant_q; | ||
40 | vorbis_info_floor1 *vi; | ||
41 | |||
42 | } vorbis_look_floor1; | ||
43 | |||
44 | /***********************************************/ | ||
45 | |||
46 | static void floor1_free_info(vorbis_info_floor *i){ | ||
47 | vorbis_info_floor1 *info=(vorbis_info_floor1 *)i; | ||
48 | if(info){ | ||
49 | //memset(info,0,sizeof(*info)); | ||
50 | _ogg_free(info); | ||
51 | } | ||
52 | } | ||
53 | |||
54 | static void floor1_free_look(vorbis_look_floor *i){ | ||
55 | vorbis_look_floor1 *look=(vorbis_look_floor1 *)i; | ||
56 | if(look){ | ||
57 | //memset(look,0,sizeof(*look)); | ||
58 | _ogg_free(look); | ||
59 | } | ||
60 | } | ||
61 | |||
62 | static inline int ilog(register unsigned int v){ | ||
63 | register int ret=0; | ||
64 | while(v){ | ||
65 | ret++; | ||
66 | v>>=1; | ||
67 | } | ||
68 | return(ret); | ||
69 | } | ||
70 | |||
71 | static int icomp(const void *a,const void *b){ | ||
72 | return(**(int **)a-**(int **)b); | ||
73 | } | ||
74 | |||
75 | static vorbis_info_floor *floor1_unpack (vorbis_info *vi,oggpack_buffer *opb){ | ||
76 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
77 | int j,k,count=0,maxclass=-1,rangebits; | ||
78 | |||
79 | vorbis_info_floor1 *info=(vorbis_info_floor1 *)_ogg_calloc(1,sizeof(*info)); | ||
80 | /* read partitions */ | ||
81 | info->partitions=oggpack_read(opb,5); /* only 0 to 31 legal */ | ||
82 | for(j=0;j<info->partitions;j++){ | ||
83 | info->partitionclass[j]=oggpack_read(opb,4); /* only 0 to 15 legal */ | ||
84 | if(info->partitionclass[j]<0)goto err_out; | ||
85 | if(maxclass<info->partitionclass[j])maxclass=info->partitionclass[j]; | ||
86 | } | ||
87 | |||
88 | /* read partition classes */ | ||
89 | for(j=0;j<maxclass+1;j++){ | ||
90 | info->class_dim[j]=oggpack_read(opb,3)+1; /* 1 to 8 */ | ||
91 | info->class_subs[j]=oggpack_read(opb,2); /* 0,1,2,3 bits */ | ||
92 | if(info->class_subs[j]<0) | ||
93 | goto err_out; | ||
94 | if(info->class_subs[j])info->class_book[j]=oggpack_read(opb,8); | ||
95 | if(info->class_book[j]<0 || info->class_book[j]>=ci->books) | ||
96 | goto err_out; | ||
97 | for(k=0;k<(1<<info->class_subs[j]);k++){ | ||
98 | info->class_subbook[j][k]=oggpack_read(opb,8)-1; | ||
99 | if(info->class_subbook[j][k]<-1 || info->class_subbook[j][k]>=ci->books) | ||
100 | goto err_out; | ||
101 | } | ||
102 | } | ||
103 | |||
104 | /* read the post list */ | ||
105 | info->mult=oggpack_read(opb,2)+1; /* only 1,2,3,4 legal now */ | ||
106 | rangebits=oggpack_read(opb,4); | ||
107 | if(rangebits<0)goto err_out; | ||
108 | |||
109 | for(j=0,k=0;j<info->partitions;j++){ | ||
110 | count+=info->class_dim[info->partitionclass[j]]; | ||
111 | for(;k<count;k++){ | ||
112 | int t=info->postlist[k+2]=oggpack_read(opb,rangebits); | ||
113 | if(t<0 || t>=(1<<rangebits)) | ||
114 | goto err_out; | ||
115 | } | ||
116 | } | ||
117 | info->postlist[0]=0; | ||
118 | info->postlist[1]=1<<rangebits; | ||
119 | |||
120 | /* don't allow repeated values in post list as they'd result in | ||
121 | zero-length segments */ | ||
122 | { | ||
123 | int *sortpointer[VIF_POSIT+2]; | ||
124 | for(j=0;j<count+2;j++)sortpointer[j]=info->postlist+j; | ||
125 | qsort(sortpointer,count+2,sizeof(*sortpointer),icomp); | ||
126 | |||
127 | for(j=1;j<count+2;j++) | ||
128 | if(*sortpointer[j-1]==*sortpointer[j])goto err_out; | ||
129 | } | ||
130 | |||
131 | return(info); | ||
132 | |||
133 | err_out: | ||
134 | floor1_free_info(info); | ||
135 | return(NULL); | ||
136 | } | ||
137 | |||
138 | static vorbis_look_floor *floor1_look(vorbis_dsp_state *vd,vorbis_info_mode *mi, | ||
139 | vorbis_info_floor *in){ | ||
140 | |||
141 | int *sortpointer[VIF_POSIT+2]; | ||
142 | vorbis_info_floor1 *info=(vorbis_info_floor1 *)in; | ||
143 | vorbis_look_floor1 *look=(vorbis_look_floor1 *)_ogg_calloc(1,sizeof(*look)); | ||
144 | int i,j,n=0; | ||
145 | |||
146 | (void)vd; | ||
147 | (void)mi; | ||
148 | look->vi=info; | ||
149 | look->n=info->postlist[1]; | ||
150 | |||
151 | /* we drop each position value in-between already decoded values, | ||
152 | and use linear interpolation to predict each new value past the | ||
153 | edges. The positions are read in the order of the position | ||
154 | list... we precompute the bounding positions in the lookup. Of | ||
155 | course, the neighbors can change (if a position is declined), but | ||
156 | this is an initial mapping */ | ||
157 | |||
158 | for(i=0;i<info->partitions;i++)n+=info->class_dim[info->partitionclass[i]]; | ||
159 | n+=2; | ||
160 | look->posts=n; | ||
161 | |||
162 | /* also store a sorted position index */ | ||
163 | for(i=0;i<n;i++)sortpointer[i]=info->postlist+i; | ||
164 | qsort(sortpointer,n,sizeof(*sortpointer),icomp); | ||
165 | |||
166 | /* points from sort order back to range number */ | ||
167 | for(i=0;i<n;i++)look->forward_index[i]=sortpointer[i]-info->postlist; | ||
168 | |||
169 | /* quantize values to multiplier spec */ | ||
170 | switch(info->mult){ | ||
171 | case 1: /* 1024 -> 256 */ | ||
172 | look->quant_q=256; | ||
173 | break; | ||
174 | case 2: /* 1024 -> 128 */ | ||
175 | look->quant_q=128; | ||
176 | break; | ||
177 | case 3: /* 1024 -> 86 */ | ||
178 | look->quant_q=86; | ||
179 | break; | ||
180 | case 4: /* 1024 -> 64 */ | ||
181 | look->quant_q=64; | ||
182 | break; | ||
183 | } | ||
184 | |||
185 | /* discover our neighbors for decode where we don't use fit flags | ||
186 | (that would push the neighbors outward) */ | ||
187 | for(i=0;i<n-2;i++){ | ||
188 | int lo=0; | ||
189 | int hi=1; | ||
190 | int lx=0; | ||
191 | int hx=look->n; | ||
192 | int currentx=info->postlist[i+2]; | ||
193 | for(j=0;j<i+2;j++){ | ||
194 | int x=info->postlist[j]; | ||
195 | if(x>lx && x<currentx){ | ||
196 | lo=j; | ||
197 | lx=x; | ||
198 | } | ||
199 | if(x<hx && x>currentx){ | ||
200 | hi=j; | ||
201 | hx=x; | ||
202 | } | ||
203 | } | ||
204 | look->loneighbor[i]=lo; | ||
205 | look->hineighbor[i]=hi; | ||
206 | } | ||
207 | |||
208 | return(look); | ||
209 | } | ||
210 | |||
211 | static int render_point(int x0,int x1,int y0,int y1,int x){ | ||
212 | y0&=0x7fff; /* mask off flag */ | ||
213 | y1&=0x7fff; | ||
214 | return y0+((y1-y0)*(x-x0))/(x1-x0); | ||
215 | } | ||
216 | |||
217 | #ifdef _LOW_ACCURACY_ | ||
218 | # define XdB(n) ((((n)>>8)+1)>>1) | ||
219 | #else | ||
220 | # define XdB(n) (n) | ||
221 | #endif | ||
222 | |||
223 | /* keep the floor lookup table in fast IRAM */ | ||
224 | static const ogg_int32_t FLOOR_fromdB_LOOKUP[256] ICONST_ATTR = { | ||
225 | XdB(0x000000e5), XdB(0x000000f4), XdB(0x00000103), XdB(0x00000114), | ||
226 | XdB(0x00000126), XdB(0x00000139), XdB(0x0000014e), XdB(0x00000163), | ||
227 | XdB(0x0000017a), XdB(0x00000193), XdB(0x000001ad), XdB(0x000001c9), | ||
228 | XdB(0x000001e7), XdB(0x00000206), XdB(0x00000228), XdB(0x0000024c), | ||
229 | XdB(0x00000272), XdB(0x0000029b), XdB(0x000002c6), XdB(0x000002f4), | ||
230 | XdB(0x00000326), XdB(0x0000035a), XdB(0x00000392), XdB(0x000003cd), | ||
231 | XdB(0x0000040c), XdB(0x00000450), XdB(0x00000497), XdB(0x000004e4), | ||
232 | XdB(0x00000535), XdB(0x0000058c), XdB(0x000005e8), XdB(0x0000064a), | ||
233 | XdB(0x000006b3), XdB(0x00000722), XdB(0x00000799), XdB(0x00000818), | ||
234 | XdB(0x0000089e), XdB(0x0000092e), XdB(0x000009c6), XdB(0x00000a69), | ||
235 | XdB(0x00000b16), XdB(0x00000bcf), XdB(0x00000c93), XdB(0x00000d64), | ||
236 | XdB(0x00000e43), XdB(0x00000f30), XdB(0x0000102d), XdB(0x0000113a), | ||
237 | XdB(0x00001258), XdB(0x0000138a), XdB(0x000014cf), XdB(0x00001629), | ||
238 | XdB(0x0000179a), XdB(0x00001922), XdB(0x00001ac4), XdB(0x00001c82), | ||
239 | XdB(0x00001e5c), XdB(0x00002055), XdB(0x0000226f), XdB(0x000024ac), | ||
240 | XdB(0x0000270e), XdB(0x00002997), XdB(0x00002c4b), XdB(0x00002f2c), | ||
241 | XdB(0x0000323d), XdB(0x00003581), XdB(0x000038fb), XdB(0x00003caf), | ||
242 | XdB(0x000040a0), XdB(0x000044d3), XdB(0x0000494c), XdB(0x00004e10), | ||
243 | XdB(0x00005323), XdB(0x0000588a), XdB(0x00005e4b), XdB(0x0000646b), | ||
244 | XdB(0x00006af2), XdB(0x000071e5), XdB(0x0000794c), XdB(0x0000812e), | ||
245 | XdB(0x00008993), XdB(0x00009283), XdB(0x00009c09), XdB(0x0000a62d), | ||
246 | XdB(0x0000b0f9), XdB(0x0000bc79), XdB(0x0000c8b9), XdB(0x0000d5c4), | ||
247 | XdB(0x0000e3a9), XdB(0x0000f274), XdB(0x00010235), XdB(0x000112fd), | ||
248 | XdB(0x000124dc), XdB(0x000137e4), XdB(0x00014c29), XdB(0x000161bf), | ||
249 | XdB(0x000178bc), XdB(0x00019137), XdB(0x0001ab4a), XdB(0x0001c70e), | ||
250 | XdB(0x0001e4a1), XdB(0x0002041f), XdB(0x000225aa), XdB(0x00024962), | ||
251 | XdB(0x00026f6d), XdB(0x000297f0), XdB(0x0002c316), XdB(0x0002f109), | ||
252 | XdB(0x000321f9), XdB(0x00035616), XdB(0x00038d97), XdB(0x0003c8b4), | ||
253 | XdB(0x000407a7), XdB(0x00044ab2), XdB(0x00049218), XdB(0x0004de23), | ||
254 | XdB(0x00052f1e), XdB(0x0005855c), XdB(0x0005e135), XdB(0x00064306), | ||
255 | XdB(0x0006ab33), XdB(0x00071a24), XdB(0x0007904b), XdB(0x00080e20), | ||
256 | XdB(0x00089422), XdB(0x000922da), XdB(0x0009bad8), XdB(0x000a5cb6), | ||
257 | XdB(0x000b091a), XdB(0x000bc0b1), XdB(0x000c8436), XdB(0x000d5471), | ||
258 | XdB(0x000e3233), XdB(0x000f1e5f), XdB(0x001019e4), XdB(0x001125c1), | ||
259 | XdB(0x00124306), XdB(0x001372d5), XdB(0x0014b663), XdB(0x00160ef7), | ||
260 | XdB(0x00177df0), XdB(0x001904c1), XdB(0x001aa4f9), XdB(0x001c603d), | ||
261 | XdB(0x001e384f), XdB(0x00202f0f), XdB(0x0022467a), XdB(0x002480b1), | ||
262 | XdB(0x0026dff7), XdB(0x002966b3), XdB(0x002c1776), XdB(0x002ef4fc), | ||
263 | XdB(0x0032022d), XdB(0x00354222), XdB(0x0038b828), XdB(0x003c67c2), | ||
264 | XdB(0x004054ae), XdB(0x004482e8), XdB(0x0048f6af), XdB(0x004db488), | ||
265 | XdB(0x0052c142), XdB(0x005821ff), XdB(0x005ddc33), XdB(0x0063f5b0), | ||
266 | XdB(0x006a74a7), XdB(0x00715faf), XdB(0x0078bdce), XdB(0x0080967f), | ||
267 | XdB(0x0088f1ba), XdB(0x0091d7f9), XdB(0x009b5247), XdB(0x00a56a41), | ||
268 | XdB(0x00b02a27), XdB(0x00bb9ce2), XdB(0x00c7ce12), XdB(0x00d4ca17), | ||
269 | XdB(0x00e29e20), XdB(0x00f15835), XdB(0x0101074b), XdB(0x0111bb4e), | ||
270 | XdB(0x01238531), XdB(0x01367704), XdB(0x014aa402), XdB(0x016020a7), | ||
271 | XdB(0x017702c3), XdB(0x018f6190), XdB(0x01a955cb), XdB(0x01c4f9cf), | ||
272 | XdB(0x01e269a8), XdB(0x0201c33b), XdB(0x0223265a), XdB(0x0246b4ea), | ||
273 | XdB(0x026c9302), XdB(0x0294e716), XdB(0x02bfda13), XdB(0x02ed9793), | ||
274 | XdB(0x031e4e09), XdB(0x03522ee4), XdB(0x03896ed0), XdB(0x03c445e2), | ||
275 | XdB(0x0402efd6), XdB(0x0445ac4b), XdB(0x048cbefc), XdB(0x04d87013), | ||
276 | XdB(0x05290c67), XdB(0x057ee5ca), XdB(0x05da5364), XdB(0x063bb204), | ||
277 | XdB(0x06a36485), XdB(0x0711d42b), XdB(0x0787710e), XdB(0x0804b299), | ||
278 | XdB(0x088a17ef), XdB(0x0918287e), XdB(0x09af747c), XdB(0x0a50957e), | ||
279 | XdB(0x0afc2f19), XdB(0x0bb2ef7f), XdB(0x0c759034), XdB(0x0d44d6ca), | ||
280 | XdB(0x0e2195bc), XdB(0x0f0cad0d), XdB(0x10070b62), XdB(0x1111aeea), | ||
281 | XdB(0x122da66c), XdB(0x135c120f), XdB(0x149e24d9), XdB(0x15f525b1), | ||
282 | XdB(0x176270e3), XdB(0x18e7794b), XdB(0x1a85c9ae), XdB(0x1c3f06d1), | ||
283 | XdB(0x1e14f07d), XdB(0x200963d7), XdB(0x221e5ccd), XdB(0x2455f870), | ||
284 | XdB(0x26b2770b), XdB(0x29363e2b), XdB(0x2be3db5c), XdB(0x2ebe06b6), | ||
285 | XdB(0x31c7a55b), XdB(0x3503ccd4), XdB(0x3875c5aa), XdB(0x3c210f44), | ||
286 | XdB(0x4009632b), XdB(0x4432b8cf), XdB(0x48a149bc), XdB(0x4d59959e), | ||
287 | XdB(0x52606733), XdB(0x57bad899), XdB(0x5d6e593a), XdB(0x6380b298), | ||
288 | XdB(0x69f80e9a), XdB(0x70dafda8), XdB(0x78307d76), XdB(0x7fffffff), | ||
289 | }; | ||
290 | |||
291 | static void *floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in) | ||
292 | ICODE_ATTR_TREMOR_NOT_MDCT; | ||
293 | static void *floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in){ | ||
294 | vorbis_look_floor1 *look=(vorbis_look_floor1 *)in; | ||
295 | vorbis_info_floor1 *info=look->vi; | ||
296 | codec_setup_info *ci=(codec_setup_info *)vb->vd->vi->codec_setup; | ||
297 | int i,j,k; | ||
298 | codebook *books=ci->fullbooks; | ||
299 | |||
300 | /* unpack wrapped/predicted values from stream */ | ||
301 | if(oggpack_read(&vb->opb,1)==1){ | ||
302 | int *fit_value=(int *)_vorbis_block_alloc(vb,(look->posts)*sizeof(*fit_value)); | ||
303 | int ilg = ilog(look->quant_q-1); | ||
304 | fit_value[0]=oggpack_read(&vb->opb,ilg); | ||
305 | fit_value[1]=oggpack_read(&vb->opb,ilg); | ||
306 | |||
307 | /* partition by partition */ | ||
308 | /* partition by partition */ | ||
309 | for(i=0,j=2;i<info->partitions;i++){ | ||
310 | int classv=info->partitionclass[i]; | ||
311 | int cdim=info->class_dim[classv]; | ||
312 | int csubbits=info->class_subs[classv]; | ||
313 | int csub=1<<csubbits; | ||
314 | int cval=0; | ||
315 | |||
316 | /* decode the partition's first stage cascade value */ | ||
317 | if(csubbits){ | ||
318 | cval=vorbis_book_decode(books+info->class_book[classv],&vb->opb); | ||
319 | |||
320 | if(cval==-1)goto eop; | ||
321 | } | ||
322 | |||
323 | for(k=0;k<cdim;k++){ | ||
324 | int book=info->class_subbook[classv][cval&(csub-1)]; | ||
325 | cval>>=csubbits; | ||
326 | if(book>=0){ | ||
327 | if((fit_value[j+k]=vorbis_book_decode(books+book,&vb->opb))==-1) | ||
328 | goto eop; | ||
329 | }else{ | ||
330 | fit_value[j+k]=0; | ||
331 | } | ||
332 | } | ||
333 | j+=cdim; | ||
334 | } | ||
335 | |||
336 | /* unwrap positive values and reconsitute via linear interpolation */ | ||
337 | for(i=2;i<look->posts;i++){ | ||
338 | int predicted=render_point(info->postlist[look->loneighbor[i-2]], | ||
339 | info->postlist[look->hineighbor[i-2]], | ||
340 | fit_value[look->loneighbor[i-2]], | ||
341 | fit_value[look->hineighbor[i-2]], | ||
342 | info->postlist[i]); | ||
343 | int hiroom=look->quant_q-predicted; | ||
344 | int loroom=predicted; | ||
345 | int room=(hiroom<loroom?hiroom:loroom)<<1; | ||
346 | int val=fit_value[i]; | ||
347 | |||
348 | if(val){ | ||
349 | if(val>=room){ | ||
350 | if(hiroom>loroom){ | ||
351 | val = val-loroom; | ||
352 | }else{ | ||
353 | val = -1-(val-hiroom); | ||
354 | } | ||
355 | }else{ | ||
356 | if(val&1){ | ||
357 | val= -((val+1)>>1); | ||
358 | }else{ | ||
359 | val>>=1; | ||
360 | } | ||
361 | } | ||
362 | |||
363 | fit_value[i]=(val+predicted)&0x7fff;; | ||
364 | fit_value[look->loneighbor[i-2]]&=0x7fff; | ||
365 | fit_value[look->hineighbor[i-2]]&=0x7fff; | ||
366 | |||
367 | }else{ | ||
368 | fit_value[i]=predicted|0x8000; | ||
369 | } | ||
370 | } | ||
371 | |||
372 | return(fit_value); | ||
373 | } | ||
374 | eop: | ||
375 | return(NULL); | ||
376 | } | ||
377 | |||
378 | static int floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo, | ||
379 | ogg_int32_t *out) ICODE_ATTR_TREMOR_NOT_MDCT; | ||
380 | static int floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo, | ||
381 | ogg_int32_t *out){ | ||
382 | vorbis_look_floor1 *look=(vorbis_look_floor1 *)in; | ||
383 | vorbis_info_floor1 *info=look->vi; | ||
384 | |||
385 | codec_setup_info *ci=(codec_setup_info *)vb->vd->vi->codec_setup; | ||
386 | int n=ci->blocksizes[vb->W]/2; | ||
387 | int j; | ||
388 | |||
389 | if(memo){ | ||
390 | /* render the lines */ | ||
391 | int *fit_value=(int *)memo; | ||
392 | int hx=0; | ||
393 | int lx=0; | ||
394 | int ly=fit_value[0]*info->mult; | ||
395 | /* guard lookup against out-of-range values */ | ||
396 | ly=(ly<0?0:ly>255?255:ly); | ||
397 | |||
398 | for(j=1;j<look->posts;j++){ | ||
399 | int current=look->forward_index[j]; | ||
400 | int hy=fit_value[current]&0x7fff; | ||
401 | if(hy==fit_value[current]){ | ||
402 | |||
403 | hx=info->postlist[current]; | ||
404 | hy*=info->mult; | ||
405 | /* guard lookup against out-of-range values */ | ||
406 | hy=(hy<0?0:hy>255?255:hy); | ||
407 | |||
408 | render_line(lx, ly, hx, hy, FLOOR_fromdB_LOOKUP, out); | ||
409 | |||
410 | lx=hx; | ||
411 | ly=hy; | ||
412 | } | ||
413 | } | ||
414 | for(j=hx;j<n;j++)out[j]*=ly; /* be certain */ | ||
415 | return(1); | ||
416 | } | ||
417 | memset(out,0,sizeof(*out)*n); | ||
418 | return(0); | ||
419 | } | ||
420 | |||
421 | /* export hooks */ | ||
422 | const vorbis_func_floor floor1_exportbundle ICONST_ATTR = { | ||
423 | &floor1_unpack,&floor1_look,&floor1_free_info, | ||
424 | &floor1_free_look,&floor1_inverse1,&floor1_inverse2 | ||
425 | }; | ||
426 | |||
diff --git a/lib/rbcodec/codecs/libtremor/framing.c b/lib/rbcodec/codecs/libtremor/framing.c new file mode 100644 index 0000000000..582084853a --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/framing.c | |||
@@ -0,0 +1,2102 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE. * | ||
4 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
5 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
6 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
7 | * * | ||
8 | * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 * | ||
9 | * by the Xiph.Org Foundation http://www.xiph.org/ * | ||
10 | * * | ||
11 | ******************************************************************** | ||
12 | |||
13 | function: code raw packets into framed OggSquish stream and | ||
14 | decode Ogg streams back into raw packets | ||
15 | last mod: $Id$ | ||
16 | |||
17 | note: The CRC code is directly derived from public domain code by | ||
18 | Ross Williams (ross@guest.adelaide.edu.au). See docs/framing.html | ||
19 | for details. | ||
20 | |||
21 | ********************************************************************/ | ||
22 | |||
23 | #include <stdlib.h> | ||
24 | #include <string.h> | ||
25 | #include "ogg.h" | ||
26 | |||
27 | /* A complete description of Ogg framing exists in docs/framing.html */ | ||
28 | |||
29 | static int ogg_page_version(const ogg_page *og){ | ||
30 | return((int)(og->header[4])); | ||
31 | } | ||
32 | |||
33 | int ogg_page_continued(const ogg_page *og){ | ||
34 | return((int)(og->header[5]&0x01)); | ||
35 | } | ||
36 | |||
37 | int ogg_page_bos(const ogg_page *og){ | ||
38 | return((int)(og->header[5]&0x02)); | ||
39 | } | ||
40 | |||
41 | int ogg_page_eos(const ogg_page *og){ | ||
42 | return((int)(og->header[5]&0x04)); | ||
43 | } | ||
44 | |||
45 | ogg_int64_t ogg_page_granulepos(const ogg_page *og){ | ||
46 | unsigned char *page=og->header; | ||
47 | ogg_int64_t granulepos=page[13]&(0xff); | ||
48 | granulepos= (granulepos<<8)|(page[12]&0xff); | ||
49 | granulepos= (granulepos<<8)|(page[11]&0xff); | ||
50 | granulepos= (granulepos<<8)|(page[10]&0xff); | ||
51 | granulepos= (granulepos<<8)|(page[9]&0xff); | ||
52 | granulepos= (granulepos<<8)|(page[8]&0xff); | ||
53 | granulepos= (granulepos<<8)|(page[7]&0xff); | ||
54 | granulepos= (granulepos<<8)|(page[6]&0xff); | ||
55 | return(granulepos); | ||
56 | } | ||
57 | |||
58 | ogg_uint32_t ogg_page_serialno(const ogg_page *og){ | ||
59 | return(og->header[14] | | ||
60 | (og->header[15]<<8) | | ||
61 | (og->header[16]<<16) | | ||
62 | (og->header[17]<<24)); | ||
63 | } | ||
64 | |||
65 | static long ogg_page_pageno(const ogg_page *og){ | ||
66 | return(og->header[18] | | ||
67 | (og->header[19]<<8) | | ||
68 | (og->header[20]<<16) | | ||
69 | (og->header[21]<<24)); | ||
70 | } | ||
71 | |||
72 | |||
73 | |||
74 | /* returns the number of packets that are completed on this page (if | ||
75 | the leading packet is begun on a previous page, but ends on this | ||
76 | page, it's counted */ | ||
77 | |||
78 | /* NOTE: | ||
79 | If a page consists of a packet begun on a previous page, and a new | ||
80 | packet begun (but not completed) on this page, the return will be: | ||
81 | ogg_page_packets(page) ==1, | ||
82 | ogg_page_continued(page) !=0 | ||
83 | |||
84 | If a page happens to be a single packet that was begun on a | ||
85 | previous page, and spans to the next page (in the case of a three or | ||
86 | more page packet), the return will be: | ||
87 | ogg_page_packets(page) ==0, | ||
88 | ogg_page_continued(page) !=0 | ||
89 | */ | ||
90 | /* | ||
91 | int ogg_page_packets(const ogg_page *og){ | ||
92 | int i,n=og->header[26],count=0; | ||
93 | for(i=0;i<n;i++) | ||
94 | if(og->header[27+i]<255)count++; | ||
95 | return(count); | ||
96 | } | ||
97 | */ | ||
98 | |||
99 | #if 0 | ||
100 | /* helper to initialize lookup for direct-table CRC (illustrative; we | ||
101 | use the static init below) */ | ||
102 | |||
103 | static ogg_uint32_t _ogg_crc_entry(unsigned long index){ | ||
104 | int i; | ||
105 | unsigned long r; | ||
106 | |||
107 | r = index << 24; | ||
108 | for (i=0; i<8; i++) | ||
109 | if (r & 0x80000000UL) | ||
110 | r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator | ||
111 | polynomial, although we use an | ||
112 | unreflected alg and an init/final | ||
113 | of 0, not 0xffffffff */ | ||
114 | else | ||
115 | r<<=1; | ||
116 | return (r & 0xffffffffUL); | ||
117 | } | ||
118 | #endif | ||
119 | |||
120 | static const ogg_uint32_t crc_lookup[256] ICONST_ATTR = { | ||
121 | 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9, | ||
122 | 0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005, | ||
123 | 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61, | ||
124 | 0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd, | ||
125 | 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9, | ||
126 | 0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75, | ||
127 | 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011, | ||
128 | 0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd, | ||
129 | 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039, | ||
130 | 0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5, | ||
131 | 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81, | ||
132 | 0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d, | ||
133 | 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49, | ||
134 | 0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95, | ||
135 | 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1, | ||
136 | 0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d, | ||
137 | 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae, | ||
138 | 0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072, | ||
139 | 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16, | ||
140 | 0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca, | ||
141 | 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde, | ||
142 | 0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02, | ||
143 | 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066, | ||
144 | 0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba, | ||
145 | 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e, | ||
146 | 0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692, | ||
147 | 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6, | ||
148 | 0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a, | ||
149 | 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e, | ||
150 | 0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2, | ||
151 | 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686, | ||
152 | 0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a, | ||
153 | 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637, | ||
154 | 0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb, | ||
155 | 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f, | ||
156 | 0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53, | ||
157 | 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47, | ||
158 | 0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b, | ||
159 | 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff, | ||
160 | 0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623, | ||
161 | 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7, | ||
162 | 0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b, | ||
163 | 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f, | ||
164 | 0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3, | ||
165 | 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7, | ||
166 | 0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b, | ||
167 | 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f, | ||
168 | 0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3, | ||
169 | 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640, | ||
170 | 0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c, | ||
171 | 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8, | ||
172 | 0x68860bfd,0x6c47164a,0x61043093,0x65c52d24, | ||
173 | 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30, | ||
174 | 0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec, | ||
175 | 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088, | ||
176 | 0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654, | ||
177 | 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0, | ||
178 | 0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c, | ||
179 | 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18, | ||
180 | 0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4, | ||
181 | 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0, | ||
182 | 0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c, | ||
183 | 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668, | ||
184 | 0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4}; | ||
185 | |||
186 | /* init the encode/decode logical stream state */ | ||
187 | |||
188 | int ogg_stream_init(ogg_stream_state *os,int serialno){ | ||
189 | if(os){ | ||
190 | memset(os,0,sizeof(*os)); | ||
191 | os->body_storage=16*1024; | ||
192 | os->lacing_storage=1024; | ||
193 | |||
194 | os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data)); | ||
195 | os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals)); | ||
196 | os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals)); | ||
197 | |||
198 | if(!os->body_data || !os->lacing_vals || !os->granule_vals){ | ||
199 | ogg_stream_clear(os); | ||
200 | return -1; | ||
201 | } | ||
202 | |||
203 | os->serialno=serialno; | ||
204 | |||
205 | return(0); | ||
206 | } | ||
207 | return(-1); | ||
208 | } | ||
209 | |||
210 | /* async/delayed error detection for the ogg_stream_state */ | ||
211 | static int ogg_stream_check(ogg_stream_state *os){ | ||
212 | if(!os || !os->body_data) return -1; | ||
213 | return 0; | ||
214 | } | ||
215 | |||
216 | /* _clear does not free os, only the non-flat storage within */ | ||
217 | int ogg_stream_clear(ogg_stream_state *os){ | ||
218 | if(os){ | ||
219 | if(os->body_data)_ogg_free(os->body_data); | ||
220 | if(os->lacing_vals)_ogg_free(os->lacing_vals); | ||
221 | if(os->granule_vals)_ogg_free(os->granule_vals); | ||
222 | |||
223 | memset(os,0,sizeof(*os)); | ||
224 | } | ||
225 | return(0); | ||
226 | } | ||
227 | /* | ||
228 | int ogg_stream_destroy(ogg_stream_state *os){ | ||
229 | if(os){ | ||
230 | ogg_stream_clear(os); | ||
231 | _ogg_free(os); | ||
232 | } | ||
233 | return(0); | ||
234 | } | ||
235 | */ | ||
236 | /* Helpers for ogg_stream_encode; this keeps the structure and | ||
237 | what's happening fairly clear */ | ||
238 | |||
239 | int _os_body_expand(ogg_stream_state *os,int needed){ | ||
240 | if(os->body_storage<=os->body_fill+needed){ | ||
241 | void *ret; | ||
242 | ret=_ogg_realloc(os->body_data,(os->body_storage+needed+1024)* | ||
243 | sizeof(*os->body_data)); | ||
244 | if(!ret){ | ||
245 | ogg_stream_clear(os); | ||
246 | return -1; | ||
247 | } | ||
248 | os->body_storage+=(needed+1024); | ||
249 | os->body_data=ret; | ||
250 | } | ||
251 | return 0; | ||
252 | } | ||
253 | |||
254 | static int _os_lacing_expand(ogg_stream_state *os,int needed){ | ||
255 | if(os->lacing_storage<=os->lacing_fill+needed){ | ||
256 | void *ret; | ||
257 | ret=_ogg_realloc(os->lacing_vals,(os->lacing_storage+needed+32)* | ||
258 | sizeof(*os->lacing_vals)); | ||
259 | if(!ret){ | ||
260 | ogg_stream_clear(os); | ||
261 | return -1; | ||
262 | } | ||
263 | os->lacing_vals=ret; | ||
264 | ret=_ogg_realloc(os->granule_vals,(os->lacing_storage+needed+32)* | ||
265 | sizeof(*os->granule_vals)); | ||
266 | if(!ret){ | ||
267 | ogg_stream_clear(os); | ||
268 | return -1; | ||
269 | } | ||
270 | os->granule_vals=ret; | ||
271 | os->lacing_storage+=(needed+32); | ||
272 | } | ||
273 | return 0; | ||
274 | } | ||
275 | |||
276 | /* checksum the page */ | ||
277 | /* Direct table CRC; note that this will be faster in the future if we | ||
278 | perform the checksum simultaneously with other copies */ | ||
279 | |||
280 | static void ogg_page_checksum_set(ogg_page *og){ | ||
281 | if(og){ | ||
282 | ogg_uint32_t crc_reg=0; | ||
283 | int i; | ||
284 | |||
285 | /* safety; needed for API behavior, but not framing code */ | ||
286 | og->header[22]=0; | ||
287 | og->header[23]=0; | ||
288 | og->header[24]=0; | ||
289 | og->header[25]=0; | ||
290 | |||
291 | for(i=0;i<og->header_len;i++) | ||
292 | crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]]; | ||
293 | for(i=0;i<og->body_len;i++) | ||
294 | crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]]; | ||
295 | |||
296 | og->header[22]=(unsigned char)(crc_reg&0xff); | ||
297 | og->header[23]=(unsigned char)((crc_reg>>8)&0xff); | ||
298 | og->header[24]=(unsigned char)((crc_reg>>16)&0xff); | ||
299 | og->header[25]=(unsigned char)((crc_reg>>24)&0xff); | ||
300 | } | ||
301 | } | ||
302 | |||
303 | #if 0 | ||
304 | /* submit data to the internal buffer of the framing engine */ | ||
305 | int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, int count, | ||
306 | long e_o_s, ogg_int64_t granulepos){ | ||
307 | |||
308 | int bytes = 0, lacing_vals, i; | ||
309 | |||
310 | if(ogg_stream_check(os)) return -1; | ||
311 | if(!iov) return 0; | ||
312 | |||
313 | for (i = 0; i < count; ++i) bytes += (int)iov[i].iov_len; | ||
314 | lacing_vals=bytes/255+1; | ||
315 | |||
316 | if(os->body_returned){ | ||
317 | /* advance packet data according to the body_returned pointer. We | ||
318 | had to keep it around to return a pointer into the buffer last | ||
319 | call */ | ||
320 | |||
321 | os->body_fill-=os->body_returned; | ||
322 | if(os->body_fill) | ||
323 | memmove(os->body_data,os->body_data+os->body_returned, | ||
324 | os->body_fill); | ||
325 | os->body_returned=0; | ||
326 | } | ||
327 | |||
328 | /* make sure we have the buffer storage */ | ||
329 | if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals)) | ||
330 | return -1; | ||
331 | |||
332 | /* Copy in the submitted packet. Yes, the copy is a waste; this is | ||
333 | the liability of overly clean abstraction for the time being. It | ||
334 | will actually be fairly easy to eliminate the extra copy in the | ||
335 | future */ | ||
336 | |||
337 | for (i = 0; i < count; ++i) { | ||
338 | memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len); | ||
339 | os->body_fill += (int)iov[i].iov_len; | ||
340 | } | ||
341 | |||
342 | /* Store lacing vals for this packet */ | ||
343 | for(i=0;i<lacing_vals-1;i++){ | ||
344 | os->lacing_vals[os->lacing_fill+i]=255; | ||
345 | os->granule_vals[os->lacing_fill+i]=os->granulepos; | ||
346 | } | ||
347 | os->lacing_vals[os->lacing_fill+i]=bytes%255; | ||
348 | os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos; | ||
349 | |||
350 | /* flag the first segment as the beginning of the packet */ | ||
351 | os->lacing_vals[os->lacing_fill]|= 0x100; | ||
352 | |||
353 | os->lacing_fill+=lacing_vals; | ||
354 | |||
355 | /* for the sake of completeness */ | ||
356 | os->packetno++; | ||
357 | |||
358 | if(e_o_s)os->e_o_s=1; | ||
359 | |||
360 | return(0); | ||
361 | } | ||
362 | |||
363 | int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){ | ||
364 | ogg_iovec_t iov; | ||
365 | iov.iov_base = op->packet; | ||
366 | iov.iov_len = op->bytes; | ||
367 | return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos); | ||
368 | } | ||
369 | |||
370 | |||
371 | /* Conditionally flush a page; force==0 will only flush nominal-size | ||
372 | pages, force==1 forces us to flush a page regardless of page size | ||
373 | so long as there's any data available at all. */ | ||
374 | static int ogg_stream_flush_i(ogg_stream_state *os,ogg_page *og, int force, int nfill){ | ||
375 | int i; | ||
376 | int vals=0; | ||
377 | int maxvals=(os->lacing_fill>255?255:os->lacing_fill); | ||
378 | int bytes=0; | ||
379 | long acc=0; | ||
380 | ogg_int64_t granule_pos=-1; | ||
381 | |||
382 | if(ogg_stream_check(os)) return(0); | ||
383 | if(maxvals==0) return(0); | ||
384 | |||
385 | /* construct a page */ | ||
386 | /* decide how many segments to include */ | ||
387 | |||
388 | /* If this is the initial header case, the first page must only include | ||
389 | the initial header packet */ | ||
390 | if(os->b_o_s==0){ /* 'initial header page' case */ | ||
391 | granule_pos=0; | ||
392 | for(vals=0;vals<maxvals;vals++){ | ||
393 | if((os->lacing_vals[vals]&0x0ff)<255){ | ||
394 | vals++; | ||
395 | break; | ||
396 | } | ||
397 | } | ||
398 | }else{ | ||
399 | |||
400 | /* The extra packets_done, packet_just_done logic here attempts to do two things: | ||
401 | 1) Don't unneccessarily span pages. | ||
402 | 2) Unless necessary, don't flush pages if there are less than four packets on | ||
403 | them; this expands page size to reduce unneccessary overhead if incoming packets | ||
404 | are large. | ||
405 | These are not necessary behaviors, just 'always better than naive flushing' | ||
406 | without requiring an application to explicitly request a specific optimized | ||
407 | behavior. We'll want an explicit behavior setup pathway eventually as well. */ | ||
408 | |||
409 | int packets_done=0; | ||
410 | int packet_just_done=0; | ||
411 | for(vals=0;vals<maxvals;vals++){ | ||
412 | if(acc>nfill && packet_just_done>=4){ | ||
413 | force=1; | ||
414 | break; | ||
415 | } | ||
416 | acc+=os->lacing_vals[vals]&0x0ff; | ||
417 | if((os->lacing_vals[vals]&0xff)<255){ | ||
418 | granule_pos=os->granule_vals[vals]; | ||
419 | packet_just_done=++packets_done; | ||
420 | }else | ||
421 | packet_just_done=0; | ||
422 | } | ||
423 | if(vals==255)force=1; | ||
424 | } | ||
425 | |||
426 | if(!force) return(0); | ||
427 | |||
428 | /* construct the header in temp storage */ | ||
429 | memcpy(os->header,"OggS",4); | ||
430 | |||
431 | /* stream structure version */ | ||
432 | os->header[4]=0x00; | ||
433 | |||
434 | /* continued packet flag? */ | ||
435 | os->header[5]=0x00; | ||
436 | if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01; | ||
437 | /* first page flag? */ | ||
438 | if(os->b_o_s==0)os->header[5]|=0x02; | ||
439 | /* last page flag? */ | ||
440 | if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04; | ||
441 | os->b_o_s=1; | ||
442 | |||
443 | /* 64 bits of PCM position */ | ||
444 | for(i=6;i<14;i++){ | ||
445 | os->header[i]=(unsigned char)(granule_pos&0xff); | ||
446 | granule_pos>>=8; | ||
447 | } | ||
448 | |||
449 | /* 32 bits of stream serial number */ | ||
450 | { | ||
451 | long serialno=os->serialno; | ||
452 | for(i=14;i<18;i++){ | ||
453 | os->header[i]=(unsigned char)(serialno&0xff); | ||
454 | serialno>>=8; | ||
455 | } | ||
456 | } | ||
457 | |||
458 | /* 32 bits of page counter (we have both counter and page header | ||
459 | because this val can roll over) */ | ||
460 | if(os->pageno==-1)os->pageno=0; /* because someone called | ||
461 | stream_reset; this would be a | ||
462 | strange thing to do in an | ||
463 | encode stream, but it has | ||
464 | plausible uses */ | ||
465 | { | ||
466 | long pageno=os->pageno++; | ||
467 | for(i=18;i<22;i++){ | ||
468 | os->header[i]=(unsigned char)(pageno&0xff); | ||
469 | pageno>>=8; | ||
470 | } | ||
471 | } | ||
472 | |||
473 | /* zero for computation; filled in later */ | ||
474 | os->header[22]=0; | ||
475 | os->header[23]=0; | ||
476 | os->header[24]=0; | ||
477 | os->header[25]=0; | ||
478 | |||
479 | /* segment table */ | ||
480 | os->header[26]=(unsigned char)(vals&0xff); | ||
481 | for(i=0;i<vals;i++) | ||
482 | bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff); | ||
483 | |||
484 | /* set pointers in the ogg_page struct */ | ||
485 | og->header=os->header; | ||
486 | og->header_len=os->header_fill=vals+27; | ||
487 | og->body=os->body_data+os->body_returned; | ||
488 | og->body_len=bytes; | ||
489 | |||
490 | /* advance the lacing data and set the body_returned pointer */ | ||
491 | |||
492 | os->lacing_fill-=vals; | ||
493 | memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals)); | ||
494 | memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals)); | ||
495 | os->body_returned+=bytes; | ||
496 | |||
497 | /* calculate the checksum */ | ||
498 | |||
499 | ogg_page_checksum_set(og); | ||
500 | |||
501 | /* done */ | ||
502 | return(1); | ||
503 | } | ||
504 | |||
505 | /* This will flush remaining packets into a page (returning nonzero), | ||
506 | even if there is not enough data to trigger a flush normally | ||
507 | (undersized page). If there are no packets or partial packets to | ||
508 | flush, ogg_stream_flush returns 0. Note that ogg_stream_flush will | ||
509 | try to flush a normal sized page like ogg_stream_pageout; a call to | ||
510 | ogg_stream_flush does not guarantee that all packets have flushed. | ||
511 | Only a return value of 0 from ogg_stream_flush indicates all packet | ||
512 | data is flushed into pages. | ||
513 | |||
514 | since ogg_stream_flush will flush the last page in a stream even if | ||
515 | it's undersized, you almost certainly want to use ogg_stream_pageout | ||
516 | (and *not* ogg_stream_flush) unless you specifically need to flush | ||
517 | an page regardless of size in the middle of a stream. */ | ||
518 | |||
519 | int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){ | ||
520 | return ogg_stream_flush_i(os,og,1,4096); | ||
521 | } | ||
522 | |||
523 | /* This constructs pages from buffered packet segments. The pointers | ||
524 | returned are to static buffers; do not free. The returned buffers are | ||
525 | good only until the next call (using the same ogg_stream_state) */ | ||
526 | |||
527 | int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){ | ||
528 | int force=0; | ||
529 | if(ogg_stream_check(os)) return 0; | ||
530 | |||
531 | if((os->e_o_s&&os->lacing_fill) || /* 'were done, now flush' case */ | ||
532 | (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */ | ||
533 | force=1; | ||
534 | |||
535 | return(ogg_stream_flush_i(os,og,force,4096)); | ||
536 | } | ||
537 | |||
538 | /* Like the above, but an argument is provided to adjust the nominal | ||
539 | page size for applications which are smart enough to provide their | ||
540 | own delay based flushing */ | ||
541 | |||
542 | int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill){ | ||
543 | int force=0; | ||
544 | if(ogg_stream_check(os)) return 0; | ||
545 | |||
546 | if((os->e_o_s&&os->lacing_fill) || /* 'were done, now flush' case */ | ||
547 | (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */ | ||
548 | force=1; | ||
549 | |||
550 | return(ogg_stream_flush_i(os,og,force,nfill)); | ||
551 | } | ||
552 | |||
553 | int ogg_stream_eos(ogg_stream_state *os){ | ||
554 | if(ogg_stream_check(os)) return 1; | ||
555 | return os->e_o_s; | ||
556 | } | ||
557 | #endif | ||
558 | /* DECODING PRIMITIVES: packet streaming layer **********************/ | ||
559 | |||
560 | /* This has two layers to place more of the multi-serialno and paging | ||
561 | control in the application's hands. First, we expose a data buffer | ||
562 | using ogg_sync_buffer(). The app either copies into the | ||
563 | buffer, or passes it directly to read(), etc. We then call | ||
564 | ogg_sync_wrote() to tell how many bytes we just added. | ||
565 | |||
566 | Pages are returned (pointers into the buffer in ogg_sync_state) | ||
567 | by ogg_sync_pageout(). The page is then submitted to | ||
568 | ogg_stream_pagein() along with the appropriate | ||
569 | ogg_stream_state* (ie, matching serialno). We then get raw | ||
570 | packets out calling ogg_stream_packetout() with a | ||
571 | ogg_stream_state. */ | ||
572 | |||
573 | /* initialize the struct to a known state */ | ||
574 | int ogg_sync_init(ogg_sync_state *oy){ | ||
575 | if(oy){ | ||
576 | oy->storage = -1; /* used as a readiness flag */ | ||
577 | memset(oy,0,sizeof(*oy)); | ||
578 | } | ||
579 | return(0); | ||
580 | } | ||
581 | |||
582 | /* clear non-flat storage within */ | ||
583 | int ogg_sync_clear(ogg_sync_state *oy){ | ||
584 | if(oy){ | ||
585 | if(oy->data)_ogg_free(oy->data); | ||
586 | memset(oy,0,sizeof(*oy)); | ||
587 | } | ||
588 | return(0); | ||
589 | } | ||
590 | |||
591 | /* | ||
592 | int ogg_sync_destroy(ogg_sync_state *oy){ | ||
593 | if(oy){ | ||
594 | ogg_sync_clear(oy); | ||
595 | _ogg_free(oy); | ||
596 | } | ||
597 | return(0); | ||
598 | } | ||
599 | */ | ||
600 | static int ogg_sync_check(ogg_sync_state *oy){ | ||
601 | if(oy->storage<0) return -1; | ||
602 | return 0; | ||
603 | } | ||
604 | |||
605 | char *ogg_sync_buffer(ogg_sync_state *oy, long size){ | ||
606 | if(ogg_sync_check(oy)) return NULL; | ||
607 | |||
608 | /* first, clear out any space that has been previously returned */ | ||
609 | if(oy->returned){ | ||
610 | oy->fill-=oy->returned; | ||
611 | if(oy->fill>0) | ||
612 | memmove(oy->data,oy->data+oy->returned,oy->fill); | ||
613 | oy->returned=0; | ||
614 | } | ||
615 | |||
616 | if(size>oy->storage-oy->fill){ | ||
617 | /* We need to extend the internal buffer */ | ||
618 | long newsize=size+oy->fill+4096; /* an extra page to be nice */ | ||
619 | void *ret; | ||
620 | |||
621 | if(oy->data) | ||
622 | ret=_ogg_realloc(oy->data,newsize); | ||
623 | else | ||
624 | ret=_ogg_malloc(newsize); | ||
625 | if(!ret){ | ||
626 | ogg_sync_clear(oy); | ||
627 | return NULL; | ||
628 | } | ||
629 | oy->data=ret; | ||
630 | oy->storage=newsize; | ||
631 | } | ||
632 | |||
633 | /* expose a segment at least as large as requested at the fill mark */ | ||
634 | return((char *)oy->data+oy->fill); | ||
635 | } | ||
636 | |||
637 | int ogg_sync_wrote(ogg_sync_state *oy, long bytes){ | ||
638 | if(ogg_sync_check(oy))return -1; | ||
639 | if(oy->fill+bytes>oy->storage)return -1; | ||
640 | oy->fill+=bytes; | ||
641 | return(0); | ||
642 | } | ||
643 | |||
644 | /* sync the stream. This is meant to be useful for finding page | ||
645 | boundaries. | ||
646 | |||
647 | return values for this: | ||
648 | -n) skipped n bytes | ||
649 | 0) page not ready; more data (no bytes skipped) | ||
650 | n) page synced at current location; page length n bytes | ||
651 | |||
652 | */ | ||
653 | |||
654 | long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){ | ||
655 | unsigned char *page=oy->data+oy->returned; | ||
656 | unsigned char *next; | ||
657 | long bytes=oy->fill-oy->returned; | ||
658 | |||
659 | if(ogg_sync_check(oy))return 0; | ||
660 | |||
661 | if(oy->headerbytes==0){ | ||
662 | int headerbytes,i; | ||
663 | if(bytes<27)return(0); /* not enough for a header */ | ||
664 | |||
665 | /* verify capture pattern */ | ||
666 | if(memcmp(page,"OggS",4))goto sync_fail; | ||
667 | |||
668 | headerbytes=page[26]+27; | ||
669 | if(bytes<headerbytes)return(0); /* not enough for header + seg table */ | ||
670 | |||
671 | /* count up body length in the segment table */ | ||
672 | |||
673 | for(i=0;i<page[26];i++) | ||
674 | oy->bodybytes+=page[27+i]; | ||
675 | oy->headerbytes=headerbytes; | ||
676 | } | ||
677 | |||
678 | if(oy->bodybytes+oy->headerbytes>bytes)return(0); | ||
679 | |||
680 | /* The whole test page is buffered. Verify the checksum */ | ||
681 | { | ||
682 | /* Grab the checksum bytes, set the header field to zero */ | ||
683 | char chksum[4]; | ||
684 | ogg_page log; | ||
685 | |||
686 | memcpy(chksum,page+22,4); | ||
687 | memset(page+22,0,4); | ||
688 | |||
689 | /* set up a temp page struct and recompute the checksum */ | ||
690 | log.header=page; | ||
691 | log.header_len=oy->headerbytes; | ||
692 | log.body=page+oy->headerbytes; | ||
693 | log.body_len=oy->bodybytes; | ||
694 | ogg_page_checksum_set(&log); | ||
695 | |||
696 | /* Compare */ | ||
697 | if(memcmp(chksum,page+22,4)){ | ||
698 | /* D'oh. Mismatch! Corrupt page (or miscapture and not a page | ||
699 | at all) */ | ||
700 | /* replace the computed checksum with the one actually read in */ | ||
701 | memcpy(page+22,chksum,4); | ||
702 | |||
703 | /* Bad checksum. Lose sync */ | ||
704 | goto sync_fail; | ||
705 | } | ||
706 | } | ||
707 | |||
708 | /* yes, have a whole page all ready to go */ | ||
709 | { | ||
710 | unsigned char *page=oy->data+oy->returned; | ||
711 | long bytes; | ||
712 | |||
713 | if(og){ | ||
714 | og->header=page; | ||
715 | og->header_len=oy->headerbytes; | ||
716 | og->body=page+oy->headerbytes; | ||
717 | og->body_len=oy->bodybytes; | ||
718 | } | ||
719 | |||
720 | oy->unsynced=0; | ||
721 | oy->returned+=(bytes=oy->headerbytes+oy->bodybytes); | ||
722 | oy->headerbytes=0; | ||
723 | oy->bodybytes=0; | ||
724 | return(bytes); | ||
725 | } | ||
726 | |||
727 | sync_fail: | ||
728 | |||
729 | oy->headerbytes=0; | ||
730 | oy->bodybytes=0; | ||
731 | |||
732 | /* search for possible capture */ | ||
733 | next=memchr(page+1,'O',bytes-1); | ||
734 | if(!next) | ||
735 | next=oy->data+oy->fill; | ||
736 | |||
737 | oy->returned=(int)(next-oy->data); | ||
738 | return((long)-(next-page)); | ||
739 | } | ||
740 | |||
741 | /* sync the stream and get a page. Keep trying until we find a page. | ||
742 | Suppress 'sync errors' after reporting the first. | ||
743 | |||
744 | return values: | ||
745 | -1) recapture (hole in data) | ||
746 | 0) need more data | ||
747 | 1) page returned | ||
748 | |||
749 | Returns pointers into buffered data; invalidated by next call to | ||
750 | _stream, _clear, _init, or _buffer */ | ||
751 | |||
752 | #if 0 | ||
753 | int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){ | ||
754 | |||
755 | if(ogg_sync_check(oy))return 0; | ||
756 | |||
757 | /* all we need to do is verify a page at the head of the stream | ||
758 | buffer. If it doesn't verify, we look for the next potential | ||
759 | frame */ | ||
760 | |||
761 | for(;;){ | ||
762 | long ret=ogg_sync_pageseek(oy,og); | ||
763 | if(ret>0){ | ||
764 | /* have a page */ | ||
765 | return(1); | ||
766 | } | ||
767 | if(ret==0){ | ||
768 | /* need more data */ | ||
769 | return(0); | ||
770 | } | ||
771 | |||
772 | /* head did not start a synced page... skipped some bytes */ | ||
773 | if(!oy->unsynced){ | ||
774 | oy->unsynced=1; | ||
775 | return(-1); | ||
776 | } | ||
777 | |||
778 | /* loop. keep looking */ | ||
779 | |||
780 | } | ||
781 | } | ||
782 | #endif | ||
783 | /* add the incoming page to the stream state; we decompose the page | ||
784 | into packet segments here as well. */ | ||
785 | |||
786 | int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og, bool copy_body){ | ||
787 | unsigned char *header=og->header; | ||
788 | unsigned char *body=og->body; | ||
789 | long bodysize=og->body_len; | ||
790 | int segptr=0; | ||
791 | |||
792 | int version=ogg_page_version(og); | ||
793 | int continued=ogg_page_continued(og); | ||
794 | int bos=ogg_page_bos(og); | ||
795 | int eos=ogg_page_eos(og); | ||
796 | ogg_int64_t granulepos=ogg_page_granulepos(og); | ||
797 | ogg_uint32_t serialno=ogg_page_serialno(og); | ||
798 | long pageno=ogg_page_pageno(og); | ||
799 | int segments=header[26]; | ||
800 | |||
801 | if(ogg_stream_check(os)) return -1; | ||
802 | |||
803 | /* clean up 'returned data' */ | ||
804 | { | ||
805 | long lr=os->lacing_returned; | ||
806 | long br=os->body_returned; | ||
807 | |||
808 | /* body data */ | ||
809 | if(br){ | ||
810 | os->body_fill-=br; | ||
811 | if(os->body_fill) | ||
812 | memmove(os->body_data,os->body_data+br,os->body_fill); | ||
813 | os->body_returned=0; | ||
814 | } | ||
815 | |||
816 | if(lr){ | ||
817 | /* segment table */ | ||
818 | if(os->lacing_fill-lr){ | ||
819 | memmove(os->lacing_vals,os->lacing_vals+lr, | ||
820 | (os->lacing_fill-lr)*sizeof(*os->lacing_vals)); | ||
821 | memmove(os->granule_vals,os->granule_vals+lr, | ||
822 | (os->lacing_fill-lr)*sizeof(*os->granule_vals)); | ||
823 | } | ||
824 | os->lacing_fill-=lr; | ||
825 | os->lacing_packet-=lr; | ||
826 | os->lacing_returned=0; | ||
827 | } | ||
828 | } | ||
829 | |||
830 | /* check the serial number */ | ||
831 | if(serialno!=os->serialno)return(-1); | ||
832 | if(version>0)return(-1); | ||
833 | |||
834 | if(_os_lacing_expand(os,segments+1)) return -1; | ||
835 | |||
836 | /* are we in sequence? */ | ||
837 | if(pageno!=os->pageno){ | ||
838 | int i; | ||
839 | |||
840 | /* unroll previous partial packet (if any) */ | ||
841 | for(i=os->lacing_packet;i<os->lacing_fill;i++) | ||
842 | os->body_fill-=os->lacing_vals[i]&0xff; | ||
843 | os->lacing_fill=os->lacing_packet; | ||
844 | |||
845 | /* make a note of dropped data in segment table */ | ||
846 | if(os->pageno!=-1){ | ||
847 | os->lacing_vals[os->lacing_fill++]=0x400; | ||
848 | os->lacing_packet++; | ||
849 | } | ||
850 | } | ||
851 | |||
852 | /* are we a 'continued packet' page? If so, we may need to skip | ||
853 | some segments */ | ||
854 | if(continued){ | ||
855 | if(os->lacing_fill<1 || | ||
856 | os->lacing_vals[os->lacing_fill-1]==0x400){ | ||
857 | bos=0; | ||
858 | for(;segptr<segments;segptr++){ | ||
859 | int val=header[27+segptr]; | ||
860 | body+=val; | ||
861 | bodysize-=val; | ||
862 | if(val<255){ | ||
863 | segptr++; | ||
864 | break; | ||
865 | } | ||
866 | } | ||
867 | } | ||
868 | } | ||
869 | |||
870 | if(bodysize){ | ||
871 | if(copy_body){ | ||
872 | if(_os_body_expand(os,bodysize)) return -1; | ||
873 | memcpy(os->body_data+os->body_fill,body,bodysize); | ||
874 | } | ||
875 | os->body_fill+=bodysize; | ||
876 | } | ||
877 | |||
878 | { | ||
879 | int saved=-1; | ||
880 | while(segptr<segments){ | ||
881 | int val=header[27+segptr]; | ||
882 | os->lacing_vals[os->lacing_fill]=val; | ||
883 | os->granule_vals[os->lacing_fill]=-1; | ||
884 | |||
885 | if(bos){ | ||
886 | os->lacing_vals[os->lacing_fill]|=0x100; | ||
887 | bos=0; | ||
888 | } | ||
889 | |||
890 | if(val<255)saved=os->lacing_fill; | ||
891 | |||
892 | os->lacing_fill++; | ||
893 | segptr++; | ||
894 | |||
895 | if(val<255)os->lacing_packet=os->lacing_fill; | ||
896 | } | ||
897 | |||
898 | /* set the granulepos on the last granuleval of the last full packet */ | ||
899 | if(saved!=-1){ | ||
900 | os->granule_vals[saved]=granulepos; | ||
901 | } | ||
902 | |||
903 | } | ||
904 | |||
905 | if(eos){ | ||
906 | os->e_o_s=1; | ||
907 | if(os->lacing_fill>0) | ||
908 | os->lacing_vals[os->lacing_fill-1]|=0x200; | ||
909 | } | ||
910 | |||
911 | os->pageno=pageno+1; | ||
912 | |||
913 | return(0); | ||
914 | } | ||
915 | |||
916 | /* clear things to an initial state. Good to call, eg, before seeking */ | ||
917 | int ogg_sync_reset(ogg_sync_state *oy){ | ||
918 | if(ogg_sync_check(oy))return -1; | ||
919 | |||
920 | oy->fill=0; | ||
921 | oy->returned=0; | ||
922 | oy->unsynced=0; | ||
923 | oy->headerbytes=0; | ||
924 | oy->bodybytes=0; | ||
925 | return(0); | ||
926 | } | ||
927 | |||
928 | int ogg_stream_reset(ogg_stream_state *os){ | ||
929 | if(ogg_stream_check(os)) return -1; | ||
930 | |||
931 | os->body_fill=0; | ||
932 | os->body_returned=0; | ||
933 | |||
934 | os->lacing_fill=0; | ||
935 | os->lacing_packet=0; | ||
936 | os->lacing_returned=0; | ||
937 | |||
938 | /* os->header_fill=0; */ | ||
939 | |||
940 | os->e_o_s=0; | ||
941 | os->b_o_s=0; | ||
942 | os->pageno=-1; | ||
943 | os->packetno=0; | ||
944 | os->granulepos=0; | ||
945 | |||
946 | return(0); | ||
947 | } | ||
948 | |||
949 | int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){ | ||
950 | if(ogg_stream_check(os)) return -1; | ||
951 | ogg_stream_reset(os); | ||
952 | os->serialno=serialno; | ||
953 | return(0); | ||
954 | } | ||
955 | |||
956 | static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv) | ||
957 | ICODE_ATTR_TREMOR_NOT_MDCT; | ||
958 | static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){ | ||
959 | |||
960 | /* The last part of decode. We have the stream broken into packet | ||
961 | segments. Now we need to group them into packets (or return the | ||
962 | out of sync markers) */ | ||
963 | |||
964 | int ptr=os->lacing_returned; | ||
965 | |||
966 | if(os->lacing_packet<=ptr)return(0); | ||
967 | |||
968 | if(os->lacing_vals[ptr]&0x400){ | ||
969 | /* we need to tell the codec there's a gap; it might need to | ||
970 | handle previous packet dependencies. */ | ||
971 | os->lacing_returned++; | ||
972 | os->packetno++; | ||
973 | return(-1); | ||
974 | } | ||
975 | |||
976 | if(!op && !adv)return(1); /* just using peek as an inexpensive way | ||
977 | to ask if there's a whole packet | ||
978 | waiting */ | ||
979 | |||
980 | /* Gather the whole packet. We'll have no holes or a partial packet */ | ||
981 | { | ||
982 | int size=os->lacing_vals[ptr]&0xff; | ||
983 | long bytes=size; | ||
984 | int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */ | ||
985 | int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */ | ||
986 | |||
987 | while(size==255){ | ||
988 | int val=os->lacing_vals[++ptr]; | ||
989 | size=val&0xff; | ||
990 | if(val&0x200)eos=0x200; | ||
991 | bytes+=size; | ||
992 | } | ||
993 | |||
994 | if(op){ | ||
995 | op->e_o_s=eos; | ||
996 | op->b_o_s=bos; | ||
997 | op->packet=os->body_data+os->body_returned; | ||
998 | op->packetno=os->packetno; | ||
999 | op->granulepos=os->granule_vals[ptr]; | ||
1000 | op->bytes=bytes; | ||
1001 | } | ||
1002 | |||
1003 | if(adv){ | ||
1004 | os->body_returned+=bytes; | ||
1005 | os->lacing_returned=ptr+1; | ||
1006 | os->packetno++; | ||
1007 | } | ||
1008 | } | ||
1009 | return(1); | ||
1010 | } | ||
1011 | |||
1012 | int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op) | ||
1013 | ICODE_ATTR_TREMOR_NOT_MDCT; | ||
1014 | int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){ | ||
1015 | if(ogg_stream_check(os)) return 0; | ||
1016 | return _packetout(os,op,1); | ||
1017 | } | ||
1018 | |||
1019 | int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op) | ||
1020 | ICODE_ATTR_TREMOR_NOT_MDCT; | ||
1021 | int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){ | ||
1022 | if(ogg_stream_check(os)) return 0; | ||
1023 | return _packetout(os,op,0); | ||
1024 | } | ||
1025 | |||
1026 | /* | ||
1027 | void ogg_packet_clear(ogg_packet *op) { | ||
1028 | _ogg_free(op->packet); | ||
1029 | memset(op, 0, sizeof(*op)); | ||
1030 | } | ||
1031 | */ | ||
1032 | #ifdef _V_SELFTEST | ||
1033 | #include <stdio.h> | ||
1034 | |||
1035 | ogg_stream_state os_en, os_de; | ||
1036 | ogg_sync_state oy; | ||
1037 | |||
1038 | void checkpacket(ogg_packet *op,long len, int no, long pos){ | ||
1039 | long j; | ||
1040 | static int sequence=0; | ||
1041 | static int lastno=0; | ||
1042 | |||
1043 | if(op->bytes!=len){ | ||
1044 | fprintf(stderr,"incorrect packet length (%ld != %ld)!\n",op->bytes,len); | ||
1045 | exit(1); | ||
1046 | } | ||
1047 | if(op->granulepos!=pos){ | ||
1048 | fprintf(stderr,"incorrect packet granpos (%ld != %ld)!\n",(long)op->granulepos,pos); | ||
1049 | exit(1); | ||
1050 | } | ||
1051 | |||
1052 | /* packet number just follows sequence/gap; adjust the input number | ||
1053 | for that */ | ||
1054 | if(no==0){ | ||
1055 | sequence=0; | ||
1056 | }else{ | ||
1057 | sequence++; | ||
1058 | if(no>lastno+1) | ||
1059 | sequence++; | ||
1060 | } | ||
1061 | lastno=no; | ||
1062 | if(op->packetno!=sequence){ | ||
1063 | fprintf(stderr,"incorrect packet sequence %ld != %d\n", | ||
1064 | (long)(op->packetno),sequence); | ||
1065 | exit(1); | ||
1066 | } | ||
1067 | |||
1068 | /* Test data */ | ||
1069 | for(j=0;j<op->bytes;j++) | ||
1070 | if(op->packet[j]!=((j+no)&0xff)){ | ||
1071 | fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n", | ||
1072 | j,op->packet[j],(j+no)&0xff); | ||
1073 | exit(1); | ||
1074 | } | ||
1075 | } | ||
1076 | |||
1077 | void check_page(unsigned char *data,const int *header,ogg_page *og){ | ||
1078 | long j; | ||
1079 | /* Test data */ | ||
1080 | for(j=0;j<og->body_len;j++) | ||
1081 | if(og->body[j]!=data[j]){ | ||
1082 | fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n", | ||
1083 | j,data[j],og->body[j]); | ||
1084 | exit(1); | ||
1085 | } | ||
1086 | |||
1087 | /* Test header */ | ||
1088 | for(j=0;j<og->header_len;j++){ | ||
1089 | if(og->header[j]!=header[j]){ | ||
1090 | fprintf(stderr,"header content mismatch at pos %ld:\n",j); | ||
1091 | for(j=0;j<header[26]+27;j++) | ||
1092 | fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]); | ||
1093 | fprintf(stderr,"\n"); | ||
1094 | exit(1); | ||
1095 | } | ||
1096 | } | ||
1097 | if(og->header_len!=header[26]+27){ | ||
1098 | fprintf(stderr,"header length incorrect! (%ld!=%d)\n", | ||
1099 | og->header_len,header[26]+27); | ||
1100 | exit(1); | ||
1101 | } | ||
1102 | } | ||
1103 | |||
1104 | void print_header(ogg_page *og){ | ||
1105 | int j; | ||
1106 | fprintf(stderr,"\nHEADER:\n"); | ||
1107 | fprintf(stderr," capture: %c %c %c %c version: %d flags: %x\n", | ||
1108 | og->header[0],og->header[1],og->header[2],og->header[3], | ||
1109 | (int)og->header[4],(int)og->header[5]); | ||
1110 | |||
1111 | fprintf(stderr," granulepos: %d serialno: %d pageno: %ld\n", | ||
1112 | (og->header[9]<<24)|(og->header[8]<<16)| | ||
1113 | (og->header[7]<<8)|og->header[6], | ||
1114 | (og->header[17]<<24)|(og->header[16]<<16)| | ||
1115 | (og->header[15]<<8)|og->header[14], | ||
1116 | ((long)(og->header[21])<<24)|(og->header[20]<<16)| | ||
1117 | (og->header[19]<<8)|og->header[18]); | ||
1118 | |||
1119 | fprintf(stderr," checksum: %02x:%02x:%02x:%02x\n segments: %d (", | ||
1120 | (int)og->header[22],(int)og->header[23], | ||
1121 | (int)og->header[24],(int)og->header[25], | ||
1122 | (int)og->header[26]); | ||
1123 | |||
1124 | for(j=27;j<og->header_len;j++) | ||
1125 | fprintf(stderr,"%d ",(int)og->header[j]); | ||
1126 | fprintf(stderr,")\n\n"); | ||
1127 | } | ||
1128 | |||
1129 | void copy_page(ogg_page *og){ | ||
1130 | unsigned char *temp=_ogg_malloc(og->header_len); | ||
1131 | memcpy(temp,og->header,og->header_len); | ||
1132 | og->header=temp; | ||
1133 | |||
1134 | temp=_ogg_malloc(og->body_len); | ||
1135 | memcpy(temp,og->body,og->body_len); | ||
1136 | og->body=temp; | ||
1137 | } | ||
1138 | |||
1139 | void free_page(ogg_page *og){ | ||
1140 | _ogg_free (og->header); | ||
1141 | _ogg_free (og->body); | ||
1142 | } | ||
1143 | |||
1144 | void error(void){ | ||
1145 | fprintf(stderr,"error!\n"); | ||
1146 | exit(1); | ||
1147 | } | ||
1148 | |||
1149 | /* 17 only */ | ||
1150 | const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06, | ||
1151 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1152 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1153 | 0x15,0xed,0xec,0x91, | ||
1154 | 1, | ||
1155 | 17}; | ||
1156 | |||
1157 | /* 17, 254, 255, 256, 500, 510, 600 byte, pad */ | ||
1158 | const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1159 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1160 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1161 | 0x59,0x10,0x6c,0x2c, | ||
1162 | 1, | ||
1163 | 17}; | ||
1164 | const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04, | ||
1165 | 0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1166 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1167 | 0x89,0x33,0x85,0xce, | ||
1168 | 13, | ||
1169 | 254,255,0,255,1,255,245,255,255,0, | ||
1170 | 255,255,90}; | ||
1171 | |||
1172 | /* nil packets; beginning,middle,end */ | ||
1173 | const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1174 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1175 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1176 | 0xff,0x7b,0x23,0x17, | ||
1177 | 1, | ||
1178 | 0}; | ||
1179 | const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04, | ||
1180 | 0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1181 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1182 | 0x5c,0x3f,0x66,0xcb, | ||
1183 | 17, | ||
1184 | 17,254,255,0,0,255,1,0,255,245,255,255,0, | ||
1185 | 255,255,90,0}; | ||
1186 | |||
1187 | /* large initial packet */ | ||
1188 | const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1189 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1190 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1191 | 0x01,0x27,0x31,0xaa, | ||
1192 | 18, | ||
1193 | 255,255,255,255,255,255,255,255, | ||
1194 | 255,255,255,255,255,255,255,255,255,10}; | ||
1195 | |||
1196 | const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04, | ||
1197 | 0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1198 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1199 | 0x7f,0x4e,0x8a,0xd2, | ||
1200 | 4, | ||
1201 | 255,4,255,0}; | ||
1202 | |||
1203 | |||
1204 | /* continuing packet test */ | ||
1205 | const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1206 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1207 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1208 | 0xff,0x7b,0x23,0x17, | ||
1209 | 1, | ||
1210 | 0}; | ||
1211 | |||
1212 | const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00, | ||
1213 | 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, | ||
1214 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1215 | 0xf8,0x3c,0x19,0x79, | ||
1216 | 255, | ||
1217 | 255,255,255,255,255,255,255,255, | ||
1218 | 255,255,255,255,255,255,255,255, | ||
1219 | 255,255,255,255,255,255,255,255, | ||
1220 | 255,255,255,255,255,255,255,255, | ||
1221 | 255,255,255,255,255,255,255,255, | ||
1222 | 255,255,255,255,255,255,255,255, | ||
1223 | 255,255,255,255,255,255,255,255, | ||
1224 | 255,255,255,255,255,255,255,255, | ||
1225 | 255,255,255,255,255,255,255,255, | ||
1226 | 255,255,255,255,255,255,255,255, | ||
1227 | 255,255,255,255,255,255,255,255, | ||
1228 | 255,255,255,255,255,255,255,255, | ||
1229 | 255,255,255,255,255,255,255,255, | ||
1230 | 255,255,255,255,255,255,255,255, | ||
1231 | 255,255,255,255,255,255,255,255, | ||
1232 | 255,255,255,255,255,255,255,255, | ||
1233 | 255,255,255,255,255,255,255,255, | ||
1234 | 255,255,255,255,255,255,255,255, | ||
1235 | 255,255,255,255,255,255,255,255, | ||
1236 | 255,255,255,255,255,255,255,255, | ||
1237 | 255,255,255,255,255,255,255,255, | ||
1238 | 255,255,255,255,255,255,255,255, | ||
1239 | 255,255,255,255,255,255,255,255, | ||
1240 | 255,255,255,255,255,255,255,255, | ||
1241 | 255,255,255,255,255,255,255,255, | ||
1242 | 255,255,255,255,255,255,255,255, | ||
1243 | 255,255,255,255,255,255,255,255, | ||
1244 | 255,255,255,255,255,255,255,255, | ||
1245 | 255,255,255,255,255,255,255,255, | ||
1246 | 255,255,255,255,255,255,255,255, | ||
1247 | 255,255,255,255,255,255,255,255, | ||
1248 | 255,255,255,255,255,255,255}; | ||
1249 | |||
1250 | const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05, | ||
1251 | 0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1252 | 0x01,0x02,0x03,0x04,2,0,0,0, | ||
1253 | 0x38,0xe6,0xb6,0x28, | ||
1254 | 6, | ||
1255 | 255,220,255,4,255,0}; | ||
1256 | |||
1257 | |||
1258 | /* spill expansion test */ | ||
1259 | const int head1_4b[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1260 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1261 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1262 | 0xff,0x7b,0x23,0x17, | ||
1263 | 1, | ||
1264 | 0}; | ||
1265 | |||
1266 | const int head2_4b[] = {0x4f,0x67,0x67,0x53,0,0x00, | ||
1267 | 0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1268 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1269 | 0xce,0x8f,0x17,0x1a, | ||
1270 | 23, | ||
1271 | 255,255,255,255,255,255,255,255, | ||
1272 | 255,255,255,255,255,255,255,255,255,10,255,4,255,0,0}; | ||
1273 | |||
1274 | |||
1275 | const int head3_4b[] = {0x4f,0x67,0x67,0x53,0,0x04, | ||
1276 | 0x07,0x14,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1277 | 0x01,0x02,0x03,0x04,2,0,0,0, | ||
1278 | 0x9b,0xb2,0x50,0xa1, | ||
1279 | 1, | ||
1280 | 0}; | ||
1281 | |||
1282 | /* page with the 255 segment limit */ | ||
1283 | const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1284 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1285 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1286 | 0xff,0x7b,0x23,0x17, | ||
1287 | 1, | ||
1288 | 0}; | ||
1289 | |||
1290 | const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00, | ||
1291 | 0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00, | ||
1292 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1293 | 0xed,0x2a,0x2e,0xa7, | ||
1294 | 255, | ||
1295 | 10,10,10,10,10,10,10,10, | ||
1296 | 10,10,10,10,10,10,10,10, | ||
1297 | 10,10,10,10,10,10,10,10, | ||
1298 | 10,10,10,10,10,10,10,10, | ||
1299 | 10,10,10,10,10,10,10,10, | ||
1300 | 10,10,10,10,10,10,10,10, | ||
1301 | 10,10,10,10,10,10,10,10, | ||
1302 | 10,10,10,10,10,10,10,10, | ||
1303 | 10,10,10,10,10,10,10,10, | ||
1304 | 10,10,10,10,10,10,10,10, | ||
1305 | 10,10,10,10,10,10,10,10, | ||
1306 | 10,10,10,10,10,10,10,10, | ||
1307 | 10,10,10,10,10,10,10,10, | ||
1308 | 10,10,10,10,10,10,10,10, | ||
1309 | 10,10,10,10,10,10,10,10, | ||
1310 | 10,10,10,10,10,10,10,10, | ||
1311 | 10,10,10,10,10,10,10,10, | ||
1312 | 10,10,10,10,10,10,10,10, | ||
1313 | 10,10,10,10,10,10,10,10, | ||
1314 | 10,10,10,10,10,10,10,10, | ||
1315 | 10,10,10,10,10,10,10,10, | ||
1316 | 10,10,10,10,10,10,10,10, | ||
1317 | 10,10,10,10,10,10,10,10, | ||
1318 | 10,10,10,10,10,10,10,10, | ||
1319 | 10,10,10,10,10,10,10,10, | ||
1320 | 10,10,10,10,10,10,10,10, | ||
1321 | 10,10,10,10,10,10,10,10, | ||
1322 | 10,10,10,10,10,10,10,10, | ||
1323 | 10,10,10,10,10,10,10,10, | ||
1324 | 10,10,10,10,10,10,10,10, | ||
1325 | 10,10,10,10,10,10,10,10, | ||
1326 | 10,10,10,10,10,10,10}; | ||
1327 | |||
1328 | const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04, | ||
1329 | 0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00, | ||
1330 | 0x01,0x02,0x03,0x04,2,0,0,0, | ||
1331 | 0x6c,0x3b,0x82,0x3d, | ||
1332 | 1, | ||
1333 | 50}; | ||
1334 | |||
1335 | |||
1336 | /* packet that overspans over an entire page */ | ||
1337 | const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1338 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1339 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1340 | 0xff,0x7b,0x23,0x17, | ||
1341 | 1, | ||
1342 | 0}; | ||
1343 | |||
1344 | const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00, | ||
1345 | 0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1346 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1347 | 0x68,0x22,0x7c,0x3d, | ||
1348 | 255, | ||
1349 | 100, | ||
1350 | 255,255,255,255,255,255,255,255, | ||
1351 | 255,255,255,255,255,255,255,255, | ||
1352 | 255,255,255,255,255,255,255,255, | ||
1353 | 255,255,255,255,255,255,255,255, | ||
1354 | 255,255,255,255,255,255,255,255, | ||
1355 | 255,255,255,255,255,255,255,255, | ||
1356 | 255,255,255,255,255,255,255,255, | ||
1357 | 255,255,255,255,255,255,255,255, | ||
1358 | 255,255,255,255,255,255,255,255, | ||
1359 | 255,255,255,255,255,255,255,255, | ||
1360 | 255,255,255,255,255,255,255,255, | ||
1361 | 255,255,255,255,255,255,255,255, | ||
1362 | 255,255,255,255,255,255,255,255, | ||
1363 | 255,255,255,255,255,255,255,255, | ||
1364 | 255,255,255,255,255,255,255,255, | ||
1365 | 255,255,255,255,255,255,255,255, | ||
1366 | 255,255,255,255,255,255,255,255, | ||
1367 | 255,255,255,255,255,255,255,255, | ||
1368 | 255,255,255,255,255,255,255,255, | ||
1369 | 255,255,255,255,255,255,255,255, | ||
1370 | 255,255,255,255,255,255,255,255, | ||
1371 | 255,255,255,255,255,255,255,255, | ||
1372 | 255,255,255,255,255,255,255,255, | ||
1373 | 255,255,255,255,255,255,255,255, | ||
1374 | 255,255,255,255,255,255,255,255, | ||
1375 | 255,255,255,255,255,255,255,255, | ||
1376 | 255,255,255,255,255,255,255,255, | ||
1377 | 255,255,255,255,255,255,255,255, | ||
1378 | 255,255,255,255,255,255,255,255, | ||
1379 | 255,255,255,255,255,255,255,255, | ||
1380 | 255,255,255,255,255,255,255,255, | ||
1381 | 255,255,255,255,255,255}; | ||
1382 | |||
1383 | const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01, | ||
1384 | 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, | ||
1385 | 0x01,0x02,0x03,0x04,2,0,0,0, | ||
1386 | 0xf4,0x87,0xba,0xf3, | ||
1387 | 255, | ||
1388 | 255,255,255,255,255,255,255,255, | ||
1389 | 255,255,255,255,255,255,255,255, | ||
1390 | 255,255,255,255,255,255,255,255, | ||
1391 | 255,255,255,255,255,255,255,255, | ||
1392 | 255,255,255,255,255,255,255,255, | ||
1393 | 255,255,255,255,255,255,255,255, | ||
1394 | 255,255,255,255,255,255,255,255, | ||
1395 | 255,255,255,255,255,255,255,255, | ||
1396 | 255,255,255,255,255,255,255,255, | ||
1397 | 255,255,255,255,255,255,255,255, | ||
1398 | 255,255,255,255,255,255,255,255, | ||
1399 | 255,255,255,255,255,255,255,255, | ||
1400 | 255,255,255,255,255,255,255,255, | ||
1401 | 255,255,255,255,255,255,255,255, | ||
1402 | 255,255,255,255,255,255,255,255, | ||
1403 | 255,255,255,255,255,255,255,255, | ||
1404 | 255,255,255,255,255,255,255,255, | ||
1405 | 255,255,255,255,255,255,255,255, | ||
1406 | 255,255,255,255,255,255,255,255, | ||
1407 | 255,255,255,255,255,255,255,255, | ||
1408 | 255,255,255,255,255,255,255,255, | ||
1409 | 255,255,255,255,255,255,255,255, | ||
1410 | 255,255,255,255,255,255,255,255, | ||
1411 | 255,255,255,255,255,255,255,255, | ||
1412 | 255,255,255,255,255,255,255,255, | ||
1413 | 255,255,255,255,255,255,255,255, | ||
1414 | 255,255,255,255,255,255,255,255, | ||
1415 | 255,255,255,255,255,255,255,255, | ||
1416 | 255,255,255,255,255,255,255,255, | ||
1417 | 255,255,255,255,255,255,255,255, | ||
1418 | 255,255,255,255,255,255,255,255, | ||
1419 | 255,255,255,255,255,255,255}; | ||
1420 | |||
1421 | const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05, | ||
1422 | 0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1423 | 0x01,0x02,0x03,0x04,3,0,0,0, | ||
1424 | 0xf7,0x2f,0x6c,0x60, | ||
1425 | 5, | ||
1426 | 254,255,4,255,0}; | ||
1427 | |||
1428 | /* packet that overspans over an entire page */ | ||
1429 | const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02, | ||
1430 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1431 | 0x01,0x02,0x03,0x04,0,0,0,0, | ||
1432 | 0xff,0x7b,0x23,0x17, | ||
1433 | 1, | ||
1434 | 0}; | ||
1435 | |||
1436 | const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00, | ||
1437 | 0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1438 | 0x01,0x02,0x03,0x04,1,0,0,0, | ||
1439 | 0x68,0x22,0x7c,0x3d, | ||
1440 | 255, | ||
1441 | 100, | ||
1442 | 255,255,255,255,255,255,255,255, | ||
1443 | 255,255,255,255,255,255,255,255, | ||
1444 | 255,255,255,255,255,255,255,255, | ||
1445 | 255,255,255,255,255,255,255,255, | ||
1446 | 255,255,255,255,255,255,255,255, | ||
1447 | 255,255,255,255,255,255,255,255, | ||
1448 | 255,255,255,255,255,255,255,255, | ||
1449 | 255,255,255,255,255,255,255,255, | ||
1450 | 255,255,255,255,255,255,255,255, | ||
1451 | 255,255,255,255,255,255,255,255, | ||
1452 | 255,255,255,255,255,255,255,255, | ||
1453 | 255,255,255,255,255,255,255,255, | ||
1454 | 255,255,255,255,255,255,255,255, | ||
1455 | 255,255,255,255,255,255,255,255, | ||
1456 | 255,255,255,255,255,255,255,255, | ||
1457 | 255,255,255,255,255,255,255,255, | ||
1458 | 255,255,255,255,255,255,255,255, | ||
1459 | 255,255,255,255,255,255,255,255, | ||
1460 | 255,255,255,255,255,255,255,255, | ||
1461 | 255,255,255,255,255,255,255,255, | ||
1462 | 255,255,255,255,255,255,255,255, | ||
1463 | 255,255,255,255,255,255,255,255, | ||
1464 | 255,255,255,255,255,255,255,255, | ||
1465 | 255,255,255,255,255,255,255,255, | ||
1466 | 255,255,255,255,255,255,255,255, | ||
1467 | 255,255,255,255,255,255,255,255, | ||
1468 | 255,255,255,255,255,255,255,255, | ||
1469 | 255,255,255,255,255,255,255,255, | ||
1470 | 255,255,255,255,255,255,255,255, | ||
1471 | 255,255,255,255,255,255,255,255, | ||
1472 | 255,255,255,255,255,255,255,255, | ||
1473 | 255,255,255,255,255,255}; | ||
1474 | |||
1475 | const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05, | ||
1476 | 0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00, | ||
1477 | 0x01,0x02,0x03,0x04,2,0,0,0, | ||
1478 | 0xd4,0xe0,0x60,0xe5, | ||
1479 | 1, | ||
1480 | 0}; | ||
1481 | |||
1482 | void test_pack(const int *pl, const int **headers, int byteskip, | ||
1483 | int pageskip, int packetskip){ | ||
1484 | unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */ | ||
1485 | long inptr=0; | ||
1486 | long outptr=0; | ||
1487 | long deptr=0; | ||
1488 | long depacket=0; | ||
1489 | long granule_pos=7,pageno=0; | ||
1490 | int i,j,packets,pageout=pageskip; | ||
1491 | int eosflag=0; | ||
1492 | int bosflag=0; | ||
1493 | |||
1494 | int byteskipcount=0; | ||
1495 | |||
1496 | ogg_stream_reset(&os_en); | ||
1497 | ogg_stream_reset(&os_de); | ||
1498 | ogg_sync_reset(&oy); | ||
1499 | |||
1500 | for(packets=0;packets<packetskip;packets++) | ||
1501 | depacket+=pl[packets]; | ||
1502 | |||
1503 | for(packets=0;;packets++)if(pl[packets]==-1)break; | ||
1504 | |||
1505 | for(i=0;i<packets;i++){ | ||
1506 | /* construct a test packet */ | ||
1507 | ogg_packet op; | ||
1508 | int len=pl[i]; | ||
1509 | |||
1510 | op.packet=data+inptr; | ||
1511 | op.bytes=len; | ||
1512 | op.e_o_s=(pl[i+1]<0?1:0); | ||
1513 | op.granulepos=granule_pos; | ||
1514 | |||
1515 | granule_pos+=1024; | ||
1516 | |||
1517 | for(j=0;j<len;j++)data[inptr++]=i+j; | ||
1518 | |||
1519 | /* submit the test packet */ | ||
1520 | ogg_stream_packetin(&os_en,&op); | ||
1521 | |||
1522 | /* retrieve any finished pages */ | ||
1523 | { | ||
1524 | ogg_page og; | ||
1525 | |||
1526 | while(ogg_stream_pageout(&os_en,&og)){ | ||
1527 | /* We have a page. Check it carefully */ | ||
1528 | |||
1529 | fprintf(stderr,"%ld, ",pageno); | ||
1530 | |||
1531 | if(headers[pageno]==NULL){ | ||
1532 | fprintf(stderr,"coded too many pages!\n"); | ||
1533 | exit(1); | ||
1534 | } | ||
1535 | |||
1536 | check_page(data+outptr,headers[pageno],&og); | ||
1537 | |||
1538 | outptr+=og.body_len; | ||
1539 | pageno++; | ||
1540 | if(pageskip){ | ||
1541 | bosflag=1; | ||
1542 | pageskip--; | ||
1543 | deptr+=og.body_len; | ||
1544 | } | ||
1545 | |||
1546 | /* have a complete page; submit it to sync/decode */ | ||
1547 | |||
1548 | { | ||
1549 | ogg_page og_de; | ||
1550 | ogg_packet op_de,op_de2; | ||
1551 | char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len); | ||
1552 | char *next=buf; | ||
1553 | byteskipcount+=og.header_len; | ||
1554 | if(byteskipcount>byteskip){ | ||
1555 | memcpy(next,og.header,byteskipcount-byteskip); | ||
1556 | next+=byteskipcount-byteskip; | ||
1557 | byteskipcount=byteskip; | ||
1558 | } | ||
1559 | |||
1560 | byteskipcount+=og.body_len; | ||
1561 | if(byteskipcount>byteskip){ | ||
1562 | memcpy(next,og.body,byteskipcount-byteskip); | ||
1563 | next+=byteskipcount-byteskip; | ||
1564 | byteskipcount=byteskip; | ||
1565 | } | ||
1566 | |||
1567 | ogg_sync_wrote(&oy,next-buf); | ||
1568 | |||
1569 | while(1){ | ||
1570 | int ret=ogg_sync_pageout(&oy,&og_de); | ||
1571 | if(ret==0)break; | ||
1572 | if(ret<0)continue; | ||
1573 | /* got a page. Happy happy. Verify that it's good. */ | ||
1574 | |||
1575 | fprintf(stderr,"(%d), ",pageout); | ||
1576 | |||
1577 | check_page(data+deptr,headers[pageout],&og_de); | ||
1578 | deptr+=og_de.body_len; | ||
1579 | pageout++; | ||
1580 | |||
1581 | /* submit it to deconstitution */ | ||
1582 | ogg_stream_pagein(&os_de,&og_de); | ||
1583 | |||
1584 | /* packets out? */ | ||
1585 | while(ogg_stream_packetpeek(&os_de,&op_de2)>0){ | ||
1586 | ogg_stream_packetpeek(&os_de,NULL); | ||
1587 | ogg_stream_packetout(&os_de,&op_de); /* just catching them all */ | ||
1588 | |||
1589 | /* verify peek and out match */ | ||
1590 | if(memcmp(&op_de,&op_de2,sizeof(op_de))){ | ||
1591 | fprintf(stderr,"packetout != packetpeek! pos=%ld\n", | ||
1592 | depacket); | ||
1593 | exit(1); | ||
1594 | } | ||
1595 | |||
1596 | /* verify the packet! */ | ||
1597 | /* check data */ | ||
1598 | if(memcmp(data+depacket,op_de.packet,op_de.bytes)){ | ||
1599 | fprintf(stderr,"packet data mismatch in decode! pos=%ld\n", | ||
1600 | depacket); | ||
1601 | exit(1); | ||
1602 | } | ||
1603 | /* check bos flag */ | ||
1604 | if(bosflag==0 && op_de.b_o_s==0){ | ||
1605 | fprintf(stderr,"b_o_s flag not set on packet!\n"); | ||
1606 | exit(1); | ||
1607 | } | ||
1608 | if(bosflag && op_de.b_o_s){ | ||
1609 | fprintf(stderr,"b_o_s flag incorrectly set on packet!\n"); | ||
1610 | exit(1); | ||
1611 | } | ||
1612 | bosflag=1; | ||
1613 | depacket+=op_de.bytes; | ||
1614 | |||
1615 | /* check eos flag */ | ||
1616 | if(eosflag){ | ||
1617 | fprintf(stderr,"Multiple decoded packets with eos flag!\n"); | ||
1618 | exit(1); | ||
1619 | } | ||
1620 | |||
1621 | if(op_de.e_o_s)eosflag=1; | ||
1622 | |||
1623 | /* check granulepos flag */ | ||
1624 | if(op_de.granulepos!=-1){ | ||
1625 | fprintf(stderr," granule:%ld ",(long)op_de.granulepos); | ||
1626 | } | ||
1627 | } | ||
1628 | } | ||
1629 | } | ||
1630 | } | ||
1631 | } | ||
1632 | } | ||
1633 | _ogg_free(data); | ||
1634 | if(headers[pageno]!=NULL){ | ||
1635 | fprintf(stderr,"did not write last page!\n"); | ||
1636 | exit(1); | ||
1637 | } | ||
1638 | if(headers[pageout]!=NULL){ | ||
1639 | fprintf(stderr,"did not decode last page!\n"); | ||
1640 | exit(1); | ||
1641 | } | ||
1642 | if(inptr!=outptr){ | ||
1643 | fprintf(stderr,"encoded page data incomplete!\n"); | ||
1644 | exit(1); | ||
1645 | } | ||
1646 | if(inptr!=deptr){ | ||
1647 | fprintf(stderr,"decoded page data incomplete!\n"); | ||
1648 | exit(1); | ||
1649 | } | ||
1650 | if(inptr!=depacket){ | ||
1651 | fprintf(stderr,"decoded packet data incomplete!\n"); | ||
1652 | exit(1); | ||
1653 | } | ||
1654 | if(!eosflag){ | ||
1655 | fprintf(stderr,"Never got a packet with EOS set!\n"); | ||
1656 | exit(1); | ||
1657 | } | ||
1658 | fprintf(stderr,"ok.\n"); | ||
1659 | } | ||
1660 | |||
1661 | int main(void){ | ||
1662 | |||
1663 | ogg_stream_init(&os_en,0x04030201); | ||
1664 | ogg_stream_init(&os_de,0x04030201); | ||
1665 | ogg_sync_init(&oy); | ||
1666 | |||
1667 | /* Exercise each code path in the framing code. Also verify that | ||
1668 | the checksums are working. */ | ||
1669 | |||
1670 | { | ||
1671 | /* 17 only */ | ||
1672 | const int packets[]={17, -1}; | ||
1673 | const int *headret[]={head1_0,NULL}; | ||
1674 | |||
1675 | fprintf(stderr,"testing single page encoding... "); | ||
1676 | test_pack(packets,headret,0,0,0); | ||
1677 | } | ||
1678 | |||
1679 | { | ||
1680 | /* 17, 254, 255, 256, 500, 510, 600 byte, pad */ | ||
1681 | const int packets[]={17, 254, 255, 256, 500, 510, 600, -1}; | ||
1682 | const int *headret[]={head1_1,head2_1,NULL}; | ||
1683 | |||
1684 | fprintf(stderr,"testing basic page encoding... "); | ||
1685 | test_pack(packets,headret,0,0,0); | ||
1686 | } | ||
1687 | |||
1688 | { | ||
1689 | /* nil packets; beginning,middle,end */ | ||
1690 | const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1}; | ||
1691 | const int *headret[]={head1_2,head2_2,NULL}; | ||
1692 | |||
1693 | fprintf(stderr,"testing basic nil packets... "); | ||
1694 | test_pack(packets,headret,0,0,0); | ||
1695 | } | ||
1696 | |||
1697 | { | ||
1698 | /* large initial packet */ | ||
1699 | const int packets[]={4345,259,255,-1}; | ||
1700 | const int *headret[]={head1_3,head2_3,NULL}; | ||
1701 | |||
1702 | fprintf(stderr,"testing initial-packet lacing > 4k... "); | ||
1703 | test_pack(packets,headret,0,0,0); | ||
1704 | } | ||
1705 | |||
1706 | { | ||
1707 | /* continuing packet test; with page spill expansion, we have to | ||
1708 | overflow the lacing table. */ | ||
1709 | const int packets[]={0,65500,259,255,-1}; | ||
1710 | const int *headret[]={head1_4,head2_4,head3_4,NULL}; | ||
1711 | |||
1712 | fprintf(stderr,"testing single packet page span... "); | ||
1713 | test_pack(packets,headret,0,0,0); | ||
1714 | } | ||
1715 | |||
1716 | { | ||
1717 | /* spill expand packet test */ | ||
1718 | const int packets[]={0,4345,259,255,0,0,-1}; | ||
1719 | const int *headret[]={head1_4b,head2_4b,head3_4b,NULL}; | ||
1720 | |||
1721 | fprintf(stderr,"testing page spill expansion... "); | ||
1722 | test_pack(packets,headret,0,0,0); | ||
1723 | } | ||
1724 | |||
1725 | /* page with the 255 segment limit */ | ||
1726 | { | ||
1727 | |||
1728 | const int packets[]={0,10,10,10,10,10,10,10,10, | ||
1729 | 10,10,10,10,10,10,10,10, | ||
1730 | 10,10,10,10,10,10,10,10, | ||
1731 | 10,10,10,10,10,10,10,10, | ||
1732 | 10,10,10,10,10,10,10,10, | ||
1733 | 10,10,10,10,10,10,10,10, | ||
1734 | 10,10,10,10,10,10,10,10, | ||
1735 | 10,10,10,10,10,10,10,10, | ||
1736 | 10,10,10,10,10,10,10,10, | ||
1737 | 10,10,10,10,10,10,10,10, | ||
1738 | 10,10,10,10,10,10,10,10, | ||
1739 | 10,10,10,10,10,10,10,10, | ||
1740 | 10,10,10,10,10,10,10,10, | ||
1741 | 10,10,10,10,10,10,10,10, | ||
1742 | 10,10,10,10,10,10,10,10, | ||
1743 | 10,10,10,10,10,10,10,10, | ||
1744 | 10,10,10,10,10,10,10,10, | ||
1745 | 10,10,10,10,10,10,10,10, | ||
1746 | 10,10,10,10,10,10,10,10, | ||
1747 | 10,10,10,10,10,10,10,10, | ||
1748 | 10,10,10,10,10,10,10,10, | ||
1749 | 10,10,10,10,10,10,10,10, | ||
1750 | 10,10,10,10,10,10,10,10, | ||
1751 | 10,10,10,10,10,10,10,10, | ||
1752 | 10,10,10,10,10,10,10,10, | ||
1753 | 10,10,10,10,10,10,10,10, | ||
1754 | 10,10,10,10,10,10,10,10, | ||
1755 | 10,10,10,10,10,10,10,10, | ||
1756 | 10,10,10,10,10,10,10,10, | ||
1757 | 10,10,10,10,10,10,10,10, | ||
1758 | 10,10,10,10,10,10,10,10, | ||
1759 | 10,10,10,10,10,10,10,50,-1}; | ||
1760 | const int *headret[]={head1_5,head2_5,head3_5,NULL}; | ||
1761 | |||
1762 | fprintf(stderr,"testing max packet segments... "); | ||
1763 | test_pack(packets,headret,0,0,0); | ||
1764 | } | ||
1765 | |||
1766 | { | ||
1767 | /* packet that overspans over an entire page */ | ||
1768 | const int packets[]={0,100,130049,259,255,-1}; | ||
1769 | const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL}; | ||
1770 | |||
1771 | fprintf(stderr,"testing very large packets... "); | ||
1772 | test_pack(packets,headret,0,0,0); | ||
1773 | } | ||
1774 | |||
1775 | { | ||
1776 | /* test for the libogg 1.1.1 resync in large continuation bug | ||
1777 | found by Josh Coalson) */ | ||
1778 | const int packets[]={0,100,130049,259,255,-1}; | ||
1779 | const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL}; | ||
1780 | |||
1781 | fprintf(stderr,"testing continuation resync in very large packets... "); | ||
1782 | test_pack(packets,headret,100,2,3); | ||
1783 | } | ||
1784 | |||
1785 | { | ||
1786 | /* term only page. why not? */ | ||
1787 | const int packets[]={0,100,64770,-1}; | ||
1788 | const int *headret[]={head1_7,head2_7,head3_7,NULL}; | ||
1789 | |||
1790 | fprintf(stderr,"testing zero data page (1 nil packet)... "); | ||
1791 | test_pack(packets,headret,0,0,0); | ||
1792 | } | ||
1793 | |||
1794 | |||
1795 | |||
1796 | { | ||
1797 | /* build a bunch of pages for testing */ | ||
1798 | unsigned char *data=_ogg_malloc(1024*1024); | ||
1799 | int pl[]={0, 1,1,98,4079, 1,1,2954,2057, 76,34,912,0,234,1000,1000, 1000,300,-1}; | ||
1800 | int inptr=0,i,j; | ||
1801 | ogg_page og[5]; | ||
1802 | |||
1803 | ogg_stream_reset(&os_en); | ||
1804 | |||
1805 | for(i=0;pl[i]!=-1;i++){ | ||
1806 | ogg_packet op; | ||
1807 | int len=pl[i]; | ||
1808 | |||
1809 | op.packet=data+inptr; | ||
1810 | op.bytes=len; | ||
1811 | op.e_o_s=(pl[i+1]<0?1:0); | ||
1812 | op.granulepos=(i+1)*1000; | ||
1813 | |||
1814 | for(j=0;j<len;j++)data[inptr++]=i+j; | ||
1815 | ogg_stream_packetin(&os_en,&op); | ||
1816 | } | ||
1817 | |||
1818 | _ogg_free(data); | ||
1819 | |||
1820 | /* retrieve finished pages */ | ||
1821 | for(i=0;i<5;i++){ | ||
1822 | if(ogg_stream_pageout(&os_en,&og[i])==0){ | ||
1823 | fprintf(stderr,"Too few pages output building sync tests!\n"); | ||
1824 | exit(1); | ||
1825 | } | ||
1826 | copy_page(&og[i]); | ||
1827 | } | ||
1828 | |||
1829 | /* Test lost pages on pagein/packetout: no rollback */ | ||
1830 | { | ||
1831 | ogg_page temp; | ||
1832 | ogg_packet test; | ||
1833 | |||
1834 | fprintf(stderr,"Testing loss of pages... "); | ||
1835 | |||
1836 | ogg_sync_reset(&oy); | ||
1837 | ogg_stream_reset(&os_de); | ||
1838 | for(i=0;i<5;i++){ | ||
1839 | memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header, | ||
1840 | og[i].header_len); | ||
1841 | ogg_sync_wrote(&oy,og[i].header_len); | ||
1842 | memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len); | ||
1843 | ogg_sync_wrote(&oy,og[i].body_len); | ||
1844 | } | ||
1845 | |||
1846 | ogg_sync_pageout(&oy,&temp); | ||
1847 | ogg_stream_pagein(&os_de,&temp); | ||
1848 | ogg_sync_pageout(&oy,&temp); | ||
1849 | ogg_stream_pagein(&os_de,&temp); | ||
1850 | ogg_sync_pageout(&oy,&temp); | ||
1851 | /* skip */ | ||
1852 | ogg_sync_pageout(&oy,&temp); | ||
1853 | ogg_stream_pagein(&os_de,&temp); | ||
1854 | |||
1855 | /* do we get the expected results/packets? */ | ||
1856 | |||
1857 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1858 | checkpacket(&test,0,0,0); | ||
1859 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1860 | checkpacket(&test,1,1,-1); | ||
1861 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1862 | checkpacket(&test,1,2,-1); | ||
1863 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1864 | checkpacket(&test,98,3,-1); | ||
1865 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1866 | checkpacket(&test,4079,4,5000); | ||
1867 | if(ogg_stream_packetout(&os_de,&test)!=-1){ | ||
1868 | fprintf(stderr,"Error: loss of page did not return error\n"); | ||
1869 | exit(1); | ||
1870 | } | ||
1871 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1872 | checkpacket(&test,76,9,-1); | ||
1873 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1874 | checkpacket(&test,34,10,-1); | ||
1875 | fprintf(stderr,"ok.\n"); | ||
1876 | } | ||
1877 | |||
1878 | /* Test lost pages on pagein/packetout: rollback with continuation */ | ||
1879 | { | ||
1880 | ogg_page temp; | ||
1881 | ogg_packet test; | ||
1882 | |||
1883 | fprintf(stderr,"Testing loss of pages (rollback required)... "); | ||
1884 | |||
1885 | ogg_sync_reset(&oy); | ||
1886 | ogg_stream_reset(&os_de); | ||
1887 | for(i=0;i<5;i++){ | ||
1888 | memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header, | ||
1889 | og[i].header_len); | ||
1890 | ogg_sync_wrote(&oy,og[i].header_len); | ||
1891 | memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len); | ||
1892 | ogg_sync_wrote(&oy,og[i].body_len); | ||
1893 | } | ||
1894 | |||
1895 | ogg_sync_pageout(&oy,&temp); | ||
1896 | ogg_stream_pagein(&os_de,&temp); | ||
1897 | ogg_sync_pageout(&oy,&temp); | ||
1898 | ogg_stream_pagein(&os_de,&temp); | ||
1899 | ogg_sync_pageout(&oy,&temp); | ||
1900 | ogg_stream_pagein(&os_de,&temp); | ||
1901 | ogg_sync_pageout(&oy,&temp); | ||
1902 | /* skip */ | ||
1903 | ogg_sync_pageout(&oy,&temp); | ||
1904 | ogg_stream_pagein(&os_de,&temp); | ||
1905 | |||
1906 | /* do we get the expected results/packets? */ | ||
1907 | |||
1908 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1909 | checkpacket(&test,0,0,0); | ||
1910 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1911 | checkpacket(&test,1,1,-1); | ||
1912 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1913 | checkpacket(&test,1,2,-1); | ||
1914 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1915 | checkpacket(&test,98,3,-1); | ||
1916 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1917 | checkpacket(&test,4079,4,5000); | ||
1918 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1919 | checkpacket(&test,1,5,-1); | ||
1920 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1921 | checkpacket(&test,1,6,-1); | ||
1922 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1923 | checkpacket(&test,2954,7,-1); | ||
1924 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1925 | checkpacket(&test,2057,8,9000); | ||
1926 | if(ogg_stream_packetout(&os_de,&test)!=-1){ | ||
1927 | fprintf(stderr,"Error: loss of page did not return error\n"); | ||
1928 | exit(1); | ||
1929 | } | ||
1930 | if(ogg_stream_packetout(&os_de,&test)!=1)error(); | ||
1931 | checkpacket(&test,300,17,18000); | ||
1932 | fprintf(stderr,"ok.\n"); | ||
1933 | } | ||
1934 | |||
1935 | /* the rest only test sync */ | ||
1936 | { | ||
1937 | ogg_page og_de; | ||
1938 | /* Test fractional page inputs: incomplete capture */ | ||
1939 | fprintf(stderr,"Testing sync on partial inputs... "); | ||
1940 | ogg_sync_reset(&oy); | ||
1941 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header, | ||
1942 | 3); | ||
1943 | ogg_sync_wrote(&oy,3); | ||
1944 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
1945 | |||
1946 | /* Test fractional page inputs: incomplete fixed header */ | ||
1947 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3, | ||
1948 | 20); | ||
1949 | ogg_sync_wrote(&oy,20); | ||
1950 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
1951 | |||
1952 | /* Test fractional page inputs: incomplete header */ | ||
1953 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23, | ||
1954 | 5); | ||
1955 | ogg_sync_wrote(&oy,5); | ||
1956 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
1957 | |||
1958 | /* Test fractional page inputs: incomplete body */ | ||
1959 | |||
1960 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28, | ||
1961 | og[1].header_len-28); | ||
1962 | ogg_sync_wrote(&oy,og[1].header_len-28); | ||
1963 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
1964 | |||
1965 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000); | ||
1966 | ogg_sync_wrote(&oy,1000); | ||
1967 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
1968 | |||
1969 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000, | ||
1970 | og[1].body_len-1000); | ||
1971 | ogg_sync_wrote(&oy,og[1].body_len-1000); | ||
1972 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
1973 | |||
1974 | fprintf(stderr,"ok.\n"); | ||
1975 | } | ||
1976 | |||
1977 | /* Test fractional page inputs: page + incomplete capture */ | ||
1978 | { | ||
1979 | ogg_page og_de; | ||
1980 | fprintf(stderr,"Testing sync on 1+partial inputs... "); | ||
1981 | ogg_sync_reset(&oy); | ||
1982 | |||
1983 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header, | ||
1984 | og[1].header_len); | ||
1985 | ogg_sync_wrote(&oy,og[1].header_len); | ||
1986 | |||
1987 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body, | ||
1988 | og[1].body_len); | ||
1989 | ogg_sync_wrote(&oy,og[1].body_len); | ||
1990 | |||
1991 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header, | ||
1992 | 20); | ||
1993 | ogg_sync_wrote(&oy,20); | ||
1994 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
1995 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
1996 | |||
1997 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20, | ||
1998 | og[1].header_len-20); | ||
1999 | ogg_sync_wrote(&oy,og[1].header_len-20); | ||
2000 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body, | ||
2001 | og[1].body_len); | ||
2002 | ogg_sync_wrote(&oy,og[1].body_len); | ||
2003 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
2004 | |||
2005 | fprintf(stderr,"ok.\n"); | ||
2006 | } | ||
2007 | |||
2008 | /* Test recapture: garbage + page */ | ||
2009 | { | ||
2010 | ogg_page og_de; | ||
2011 | fprintf(stderr,"Testing search for capture... "); | ||
2012 | ogg_sync_reset(&oy); | ||
2013 | |||
2014 | /* 'garbage' */ | ||
2015 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body, | ||
2016 | og[1].body_len); | ||
2017 | ogg_sync_wrote(&oy,og[1].body_len); | ||
2018 | |||
2019 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header, | ||
2020 | og[1].header_len); | ||
2021 | ogg_sync_wrote(&oy,og[1].header_len); | ||
2022 | |||
2023 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body, | ||
2024 | og[1].body_len); | ||
2025 | ogg_sync_wrote(&oy,og[1].body_len); | ||
2026 | |||
2027 | memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header, | ||
2028 | 20); | ||
2029 | ogg_sync_wrote(&oy,20); | ||
2030 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
2031 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
2032 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
2033 | |||
2034 | memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20, | ||
2035 | og[2].header_len-20); | ||
2036 | ogg_sync_wrote(&oy,og[2].header_len-20); | ||
2037 | memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body, | ||
2038 | og[2].body_len); | ||
2039 | ogg_sync_wrote(&oy,og[2].body_len); | ||
2040 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
2041 | |||
2042 | fprintf(stderr,"ok.\n"); | ||
2043 | } | ||
2044 | |||
2045 | /* Test recapture: page + garbage + page */ | ||
2046 | { | ||
2047 | ogg_page og_de; | ||
2048 | fprintf(stderr,"Testing recapture... "); | ||
2049 | ogg_sync_reset(&oy); | ||
2050 | |||
2051 | memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header, | ||
2052 | og[1].header_len); | ||
2053 | ogg_sync_wrote(&oy,og[1].header_len); | ||
2054 | |||
2055 | memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body, | ||
2056 | og[1].body_len); | ||
2057 | ogg_sync_wrote(&oy,og[1].body_len); | ||
2058 | |||
2059 | memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header, | ||
2060 | og[2].header_len); | ||
2061 | ogg_sync_wrote(&oy,og[2].header_len); | ||
2062 | |||
2063 | memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header, | ||
2064 | og[2].header_len); | ||
2065 | ogg_sync_wrote(&oy,og[2].header_len); | ||
2066 | |||
2067 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
2068 | |||
2069 | memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body, | ||
2070 | og[2].body_len-5); | ||
2071 | ogg_sync_wrote(&oy,og[2].body_len-5); | ||
2072 | |||
2073 | memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header, | ||
2074 | og[3].header_len); | ||
2075 | ogg_sync_wrote(&oy,og[3].header_len); | ||
2076 | |||
2077 | memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body, | ||
2078 | og[3].body_len); | ||
2079 | ogg_sync_wrote(&oy,og[3].body_len); | ||
2080 | |||
2081 | if(ogg_sync_pageout(&oy,&og_de)>0)error(); | ||
2082 | if(ogg_sync_pageout(&oy,&og_de)<=0)error(); | ||
2083 | |||
2084 | fprintf(stderr,"ok.\n"); | ||
2085 | } | ||
2086 | |||
2087 | /* Free page data that was previously copied */ | ||
2088 | { | ||
2089 | for(i=0;i<5;i++){ | ||
2090 | free_page(&og[i]); | ||
2091 | } | ||
2092 | } | ||
2093 | } | ||
2094 | |||
2095 | return(0); | ||
2096 | } | ||
2097 | |||
2098 | #endif | ||
2099 | |||
2100 | |||
2101 | |||
2102 | |||
diff --git a/lib/rbcodec/codecs/libtremor/info.c b/lib/rbcodec/codecs/libtremor/info.c new file mode 100644 index 0000000000..d922711e34 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/info.c | |||
@@ -0,0 +1,330 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: maintain the info structure, info <-> header packets | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | /* general handling of the header and the vorbis_info structure (and | ||
19 | substructures) */ | ||
20 | |||
21 | #include "config-tremor.h" | ||
22 | #include <string.h> | ||
23 | #include <ctype.h> | ||
24 | #include "ogg.h" | ||
25 | #include "ivorbiscodec.h" | ||
26 | #include "codec_internal.h" | ||
27 | #include "codebook.h" | ||
28 | #include "registry.h" | ||
29 | #include "window.h" | ||
30 | #include "misc.h" | ||
31 | #include "os.h" | ||
32 | |||
33 | /* helpers */ | ||
34 | static void _v_readstring(oggpack_buffer *o,char *buf,int bytes){ | ||
35 | while(bytes--){ | ||
36 | *buf++=oggpack_read(o,8); | ||
37 | } | ||
38 | } | ||
39 | |||
40 | /* | ||
41 | void vorbis_comment_init(vorbis_comment *vc){ | ||
42 | memset(vc,0,sizeof(*vc)); | ||
43 | } | ||
44 | |||
45 | void vorbis_comment_clear(vorbis_comment *vc){ | ||
46 | if(vc){ | ||
47 | long i; | ||
48 | if(vc->user_comments){ | ||
49 | for(i=0;i<vc->comments;i++) | ||
50 | if(vc->user_comments[i])_ogg_free(vc->user_comments[i]); | ||
51 | _ogg_free(vc->user_comments); | ||
52 | } | ||
53 | if(vc->comment_lengths)_ogg_free(vc->comment_lengths); | ||
54 | if(vc->vendor)_ogg_free(vc->vendor); | ||
55 | memset(vc,0,sizeof(*vc)); | ||
56 | } | ||
57 | } | ||
58 | */ | ||
59 | |||
60 | /* blocksize 0 is guaranteed to be short, 1 is guarantted to be long. | ||
61 | They may be equal, but short will never ge greater than long */ | ||
62 | int vorbis_info_blocksize(vorbis_info *vi,int zo){ | ||
63 | codec_setup_info *ci = (codec_setup_info *)vi->codec_setup; | ||
64 | return ci ? ci->blocksizes[zo] : -1; | ||
65 | } | ||
66 | |||
67 | /* used by synthesis, which has a full, alloced vi */ | ||
68 | void vorbis_info_init(vorbis_info *vi){ | ||
69 | memset(vi,0,sizeof(*vi)); | ||
70 | vi->codec_setup=(codec_setup_info *)_ogg_calloc(1,sizeof(codec_setup_info)); | ||
71 | } | ||
72 | |||
73 | void vorbis_info_clear(vorbis_info *vi){ | ||
74 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
75 | int i; | ||
76 | |||
77 | if(ci){ | ||
78 | |||
79 | for(i=0;i<ci->modes;i++) | ||
80 | if(ci->mode_param[i])_ogg_free(ci->mode_param[i]); | ||
81 | |||
82 | for(i=0;i<ci->maps;i++) /* unpack does the range checking */ | ||
83 | if(ci->map_param[i]) | ||
84 | _mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]); | ||
85 | |||
86 | for(i=0;i<ci->floors;i++) /* unpack does the range checking */ | ||
87 | if(ci->floor_param[i]) | ||
88 | _floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]); | ||
89 | |||
90 | for(i=0;i<ci->residues;i++) /* unpack does the range checking */ | ||
91 | if(ci->residue_param[i]) | ||
92 | _residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]); | ||
93 | |||
94 | for(i=0;i<ci->books;i++){ | ||
95 | if(ci->book_param[i]){ | ||
96 | /* knows if the book was not alloced */ | ||
97 | vorbis_staticbook_destroy(ci->book_param[i]); | ||
98 | } | ||
99 | if(ci->fullbooks) | ||
100 | vorbis_book_clear(ci->fullbooks+i); | ||
101 | } | ||
102 | if(ci->fullbooks) | ||
103 | _ogg_free(ci->fullbooks); | ||
104 | |||
105 | _ogg_free(ci); | ||
106 | } | ||
107 | |||
108 | memset(vi,0,sizeof(*vi)); | ||
109 | } | ||
110 | |||
111 | /* Header packing/unpacking ********************************************/ | ||
112 | |||
113 | static int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb){ | ||
114 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
115 | if(!ci)return(OV_EFAULT); | ||
116 | |||
117 | vi->version=oggpack_read(opb,32); | ||
118 | if(vi->version!=0)return(OV_EVERSION); | ||
119 | |||
120 | vi->channels=oggpack_read(opb,8); | ||
121 | vi->rate=oggpack_read(opb,32); | ||
122 | |||
123 | vi->bitrate_upper=oggpack_read(opb,32); | ||
124 | vi->bitrate_nominal=oggpack_read(opb,32); | ||
125 | vi->bitrate_lower=oggpack_read(opb,32); | ||
126 | |||
127 | ci->blocksizes_nbits[0]=oggpack_read(opb,4); | ||
128 | ci->blocksizes_nbits[1]=oggpack_read(opb,4); | ||
129 | ci->blocksizes[0]=1<<(ci->blocksizes_nbits[0]); | ||
130 | ci->blocksizes[1]=1<<(ci->blocksizes_nbits[1]); | ||
131 | |||
132 | if(vi->rate<1)goto err_out; | ||
133 | if(vi->channels<1)goto err_out; | ||
134 | if(ci->blocksizes[0]<64)goto err_out; | ||
135 | if(ci->blocksizes[1]<ci->blocksizes[0])goto err_out; | ||
136 | if(ci->blocksizes[1]>8192)goto err_out; | ||
137 | |||
138 | if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */ | ||
139 | |||
140 | return(0); | ||
141 | err_out: | ||
142 | vorbis_info_clear(vi); | ||
143 | return(OV_EBADHEADER); | ||
144 | } | ||
145 | |||
146 | #if 0 | ||
147 | static int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb){ | ||
148 | int vendorlen; | ||
149 | vendorlen=oggpack_read(opb,32); | ||
150 | if(vendorlen<0)goto err_out; | ||
151 | if(vendorlen>opb->storage-oggpack_bytes(opb))goto err_out; | ||
152 | vc->vendor=(char *)_ogg_calloc(vendorlen+1,1); | ||
153 | if(vc->vendor==NULL)goto err_out; | ||
154 | _v_readstring(opb,vc->vendor,vendorlen); | ||
155 | vc->comments=0; | ||
156 | /* ROCKBOX: the meat of this function was deleted as we don't need it */ | ||
157 | return(0); | ||
158 | err_out: | ||
159 | vorbis_comment_clear(vc); | ||
160 | return(OV_EBADHEADER); | ||
161 | } | ||
162 | #endif | ||
163 | |||
164 | /* all of the real encoding details are here. The modes, books, | ||
165 | everything */ | ||
166 | static int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){ | ||
167 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
168 | int i; | ||
169 | if(!ci)return(OV_EFAULT); | ||
170 | |||
171 | /* codebooks */ | ||
172 | ci->books=oggpack_read(opb,8)+1; | ||
173 | if(ci->books<=0)goto err_out; | ||
174 | for(i=0;i<ci->books;i++){ | ||
175 | ci->book_param[i]=vorbis_staticbook_unpack(opb); | ||
176 | if(!ci->book_param[i])goto err_out; | ||
177 | } | ||
178 | |||
179 | /* time backend settings */ | ||
180 | ci->times=oggpack_read(opb,6)+1; | ||
181 | if(ci->times<=0)goto err_out; | ||
182 | for(i=0;i<ci->times;i++){ | ||
183 | ci->time_type[i]=oggpack_read(opb,16); | ||
184 | if(ci->time_type[i]<0 || ci->time_type[i]>=VI_TIMEB)goto err_out; | ||
185 | /* ci->time_param[i]=_time_P[ci->time_type[i]]->unpack(vi,opb); | ||
186 | Vorbis I has no time backend */ | ||
187 | /*if(!ci->time_param[i])goto err_out;*/ | ||
188 | } | ||
189 | |||
190 | /* floor backend settings */ | ||
191 | ci->floors=oggpack_read(opb,6)+1; | ||
192 | if(ci->floors<=0)goto err_out; | ||
193 | for(i=0;i<ci->floors;i++){ | ||
194 | ci->floor_type[i]=oggpack_read(opb,16); | ||
195 | if(ci->floor_type[i]<0 || ci->floor_type[i]>=VI_FLOORB)goto err_out; | ||
196 | ci->floor_param[i]=_floor_P[ci->floor_type[i]]->unpack(vi,opb); | ||
197 | if(!ci->floor_param[i])goto err_out; | ||
198 | } | ||
199 | |||
200 | /* residue backend settings */ | ||
201 | ci->residues=oggpack_read(opb,6)+1; | ||
202 | if(ci->residues<=0)goto err_out; | ||
203 | for(i=0;i<ci->residues;i++){ | ||
204 | ci->residue_type[i]=oggpack_read(opb,16); | ||
205 | if(ci->residue_type[i]<0 || ci->residue_type[i]>=VI_RESB)goto err_out; | ||
206 | ci->residue_param[i]=_residue_P[ci->residue_type[i]]->unpack(vi,opb); | ||
207 | if(!ci->residue_param[i])goto err_out; | ||
208 | } | ||
209 | |||
210 | /* map backend settings */ | ||
211 | ci->maps=oggpack_read(opb,6)+1; | ||
212 | if(ci->maps<=0)goto err_out; | ||
213 | for(i=0;i<ci->maps;i++){ | ||
214 | ci->map_type[i]=oggpack_read(opb,16); | ||
215 | if(ci->map_type[i]<0 || ci->map_type[i]>=VI_MAPB)goto err_out; | ||
216 | ci->map_param[i]=_mapping_P[ci->map_type[i]]->unpack(vi,opb); | ||
217 | if(!ci->map_param[i])goto err_out; | ||
218 | } | ||
219 | |||
220 | /* mode settings */ | ||
221 | ci->modes=oggpack_read(opb,6)+1; | ||
222 | if(ci->modes<=0)goto err_out; | ||
223 | for(i=0;i<ci->modes;i++){ | ||
224 | ci->mode_param[i]=(vorbis_info_mode *)_ogg_calloc(1,sizeof(*ci->mode_param[i])); | ||
225 | ci->mode_param[i]->blockflag=oggpack_read(opb,1); | ||
226 | ci->mode_param[i]->windowtype=oggpack_read(opb,16); | ||
227 | ci->mode_param[i]->transformtype=oggpack_read(opb,16); | ||
228 | ci->mode_param[i]->mapping=oggpack_read(opb,8); | ||
229 | |||
230 | if(ci->mode_param[i]->windowtype>=VI_WINDOWB)goto err_out; | ||
231 | if(ci->mode_param[i]->transformtype>=VI_WINDOWB)goto err_out; | ||
232 | if(ci->mode_param[i]->mapping>=ci->maps)goto err_out; | ||
233 | if(ci->mode_param[i]->mapping<0)goto err_out; | ||
234 | } | ||
235 | |||
236 | if(oggpack_read(opb,1)!=1)goto err_out; /* top level EOP check */ | ||
237 | |||
238 | return(0); | ||
239 | err_out: | ||
240 | vorbis_info_clear(vi); | ||
241 | return(OV_EBADHEADER); | ||
242 | } | ||
243 | |||
244 | /* Is this packet a vorbis ID header? */ | ||
245 | int vorbis_synthesis_idheader(ogg_packet *op){ | ||
246 | oggpack_buffer opb; | ||
247 | char buffer[6]; | ||
248 | |||
249 | if(op){ | ||
250 | oggpack_readinit(&opb,op->packet,op->bytes); | ||
251 | |||
252 | if(!op->b_o_s) | ||
253 | return(0); /* Not the initial packet */ | ||
254 | |||
255 | if(oggpack_read(&opb,8) != 1) | ||
256 | return 0; /* not an ID header */ | ||
257 | |||
258 | memset(buffer,0,6); | ||
259 | _v_readstring(&opb,buffer,6); | ||
260 | if(memcmp(buffer,"vorbis",6)) | ||
261 | return 0; /* not vorbis */ | ||
262 | |||
263 | return 1; | ||
264 | } | ||
265 | |||
266 | return 0; | ||
267 | } | ||
268 | |||
269 | /* The Vorbis header is in three packets; the initial small packet in | ||
270 | the first page that identifies basic parameters, a second packet | ||
271 | with bitstream comments and a third packet that holds the | ||
272 | codebook. */ | ||
273 | |||
274 | int vorbis_synthesis_headerin(vorbis_info *vi,ogg_packet *op){ | ||
275 | oggpack_buffer opb; | ||
276 | |||
277 | if(op){ | ||
278 | oggpack_readinit(&opb,op->packet,op->bytes); | ||
279 | |||
280 | /* Which of the three types of header is this? */ | ||
281 | /* Also verify header-ness, vorbis */ | ||
282 | { | ||
283 | char buffer[6]; | ||
284 | int packtype=oggpack_read(&opb,8); | ||
285 | memset(buffer,0,6); | ||
286 | _v_readstring(&opb,buffer,6); | ||
287 | if(memcmp(buffer,"vorbis",6)){ | ||
288 | /* not a vorbis header */ | ||
289 | return(OV_ENOTVORBIS); | ||
290 | } | ||
291 | switch(packtype){ | ||
292 | case 0x01: /* least significant *bit* is read first */ | ||
293 | if(!op->b_o_s){ | ||
294 | /* Not the initial packet */ | ||
295 | return(OV_EBADHEADER); | ||
296 | } | ||
297 | if(vi->rate!=0){ | ||
298 | /* previously initialized info header */ | ||
299 | return(OV_EBADHEADER); | ||
300 | } | ||
301 | |||
302 | return(_vorbis_unpack_info(vi,&opb)); | ||
303 | |||
304 | case 0x03: /* least significant *bit* is read first */ | ||
305 | if(vi->rate==0){ | ||
306 | /* um... we didn't get the initial header */ | ||
307 | return(OV_EBADHEADER); | ||
308 | } | ||
309 | |||
310 | /*return(_vorbis_unpack_comment(vc,&opb));*/ | ||
311 | return 0; | ||
312 | |||
313 | case 0x05: /* least significant *bit* is read first */ | ||
314 | if(vi->rate==0 /*|| vc->vendor==NULL*/){ | ||
315 | /* um... we didn;t get the initial header or comments yet */ | ||
316 | return(OV_EBADHEADER); | ||
317 | } | ||
318 | |||
319 | return(_vorbis_unpack_books(vi,&opb)); | ||
320 | |||
321 | default: | ||
322 | /* Not a valid vorbis header type */ | ||
323 | return(OV_EBADHEADER); | ||
324 | break; | ||
325 | } | ||
326 | } | ||
327 | } | ||
328 | return(OV_EBADHEADER); | ||
329 | } | ||
330 | |||
diff --git a/lib/rbcodec/codecs/libtremor/ivorbiscodec.h b/lib/rbcodec/codecs/libtremor/ivorbiscodec.h new file mode 100644 index 0000000000..4fb041603d --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/ivorbiscodec.h | |||
@@ -0,0 +1,204 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: libvorbis codec headers | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _vorbis_codec_h_ | ||
19 | #define _vorbis_codec_h_ | ||
20 | |||
21 | #ifdef __cplusplus | ||
22 | extern "C" | ||
23 | { | ||
24 | #endif /* __cplusplus */ | ||
25 | |||
26 | #include "ogg.h" | ||
27 | //#include <codecs/lib/codeclib.h> | ||
28 | |||
29 | typedef struct vorbis_info{ | ||
30 | int version; | ||
31 | int channels; | ||
32 | long rate; | ||
33 | |||
34 | /* The below bitrate declarations are *hints*. | ||
35 | Combinations of the three values carry the following implications: | ||
36 | |||
37 | all three set to the same value: | ||
38 | implies a fixed rate bitstream | ||
39 | only nominal set: | ||
40 | implies a VBR stream that averages the nominal bitrate. No hard | ||
41 | upper/lower limit | ||
42 | upper and or lower set: | ||
43 | implies a VBR bitstream that obeys the bitrate limits. nominal | ||
44 | may also be set to give a nominal rate. | ||
45 | none set: | ||
46 | the coder does not care to speculate. | ||
47 | */ | ||
48 | |||
49 | long bitrate_upper; | ||
50 | long bitrate_nominal; | ||
51 | long bitrate_lower; | ||
52 | |||
53 | void *codec_setup; | ||
54 | } vorbis_info; | ||
55 | |||
56 | /* vorbis_dsp_state buffers the current vorbis audio | ||
57 | analysis/synthesis state. The DSP state belongs to a specific | ||
58 | logical bitstream ****************************************************/ | ||
59 | typedef struct vorbis_dsp_state{ | ||
60 | vorbis_info *vi; | ||
61 | |||
62 | ogg_int32_t *residues[2]; | ||
63 | ogg_int32_t *floors; | ||
64 | ogg_int32_t *saved; | ||
65 | ogg_int32_t *saved_ptr[CHANNELS]; | ||
66 | |||
67 | int ri; | ||
68 | |||
69 | ogg_int32_t **pcmb; | ||
70 | ogg_int32_t **pcmret; | ||
71 | int pcm_storage; | ||
72 | int pcm_current; | ||
73 | int pcm_returned; | ||
74 | |||
75 | int eofflag; | ||
76 | |||
77 | long lW; | ||
78 | long W; | ||
79 | long nW; | ||
80 | |||
81 | ogg_int64_t granulepos; | ||
82 | ogg_int64_t sequence; | ||
83 | |||
84 | void *backend_state; | ||
85 | } vorbis_dsp_state; | ||
86 | |||
87 | typedef struct vorbis_block{ | ||
88 | /* necessary stream state for linking to the framing abstraction */ | ||
89 | oggpack_buffer opb; | ||
90 | |||
91 | long lW; | ||
92 | long W; | ||
93 | long nW; | ||
94 | int pcmend; | ||
95 | int mode; | ||
96 | |||
97 | int eofflag; | ||
98 | ogg_int64_t granulepos; | ||
99 | ogg_int64_t sequence; | ||
100 | vorbis_dsp_state *vd; /* For read-only access of configuration */ | ||
101 | |||
102 | /* local storage to avoid remallocing; it's up to the mapping to | ||
103 | structure it */ | ||
104 | void *localstore; | ||
105 | long localtop; | ||
106 | long localalloc; | ||
107 | long totaluse; | ||
108 | struct alloc_chain *reap; | ||
109 | } vorbis_block; | ||
110 | |||
111 | /* vorbis_block is a single block of data to be processed as part of | ||
112 | the analysis/synthesis stream; it belongs to a specific logical | ||
113 | bitstream, but is independant from other vorbis_blocks belonging to | ||
114 | that logical bitstream. *************************************************/ | ||
115 | |||
116 | struct alloc_chain{ | ||
117 | void *ptr; | ||
118 | struct alloc_chain *next; | ||
119 | }; | ||
120 | |||
121 | /* vorbis_info contains all the setup information specific to the | ||
122 | specific compression/decompression mode in progress (eg, | ||
123 | psychoacoustic settings, channel setup, options, codebook | ||
124 | etc). vorbis_info and substructures are in backends.h. | ||
125 | *********************************************************************/ | ||
126 | |||
127 | /* the comments are not part of vorbis_info so that vorbis_info can be | ||
128 | static storage */ | ||
129 | typedef struct vorbis_comment{ | ||
130 | /* unlimited user comment fields. libvorbis writes 'libvorbis' | ||
131 | whatever vendor is set to in encode */ | ||
132 | char **user_comments; | ||
133 | int *comment_lengths; | ||
134 | int comments; | ||
135 | char *vendor; | ||
136 | |||
137 | } vorbis_comment; | ||
138 | |||
139 | |||
140 | /* libvorbis encodes in two abstraction layers; first we perform DSP | ||
141 | and produce a packet (see docs/analysis.txt). The packet is then | ||
142 | coded into a framed OggSquish bitstream by the second layer (see | ||
143 | docs/framing.txt). Decode is the reverse process; we sync/frame | ||
144 | the bitstream and extract individual packets, then decode the | ||
145 | packet back into PCM audio. | ||
146 | |||
147 | The extra framing/packetizing is used in streaming formats, such as | ||
148 | files. Over the net (such as with UDP), the framing and | ||
149 | packetization aren't necessary as they're provided by the transport | ||
150 | and the streaming layer is not used */ | ||
151 | |||
152 | /* Vorbis PRIMITIVES: general ***************************************/ | ||
153 | |||
154 | extern void vorbis_info_init(vorbis_info *vi); | ||
155 | extern void vorbis_info_clear(vorbis_info *vi); | ||
156 | extern int vorbis_info_blocksize(vorbis_info *vi,int zo); | ||
157 | /* | ||
158 | extern void vorbis_comment_init(vorbis_comment *vc); | ||
159 | extern void vorbis_comment_add(vorbis_comment *vc, char *comment); | ||
160 | extern void vorbis_comment_add_tag(vorbis_comment *vc, | ||
161 | char *tag, char *contents); | ||
162 | extern void vorbis_comment_clear(vorbis_comment *vc); | ||
163 | */ | ||
164 | extern int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb); | ||
165 | extern int vorbis_block_clear(vorbis_block *vb); | ||
166 | extern void vorbis_dsp_clear(vorbis_dsp_state *v); | ||
167 | |||
168 | /* Vorbis PRIMITIVES: synthesis layer *******************************/ | ||
169 | extern int vorbis_synthesis_idheader(ogg_packet *op); | ||
170 | extern int vorbis_synthesis_headerin(vorbis_info *vi,ogg_packet *op); | ||
171 | |||
172 | extern int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi); | ||
173 | extern int vorbis_synthesis_restart(vorbis_dsp_state *v); | ||
174 | extern int vorbis_synthesis(vorbis_block *vb,ogg_packet *op); | ||
175 | extern int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op); | ||
176 | extern int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb); | ||
177 | extern int vorbis_synthesis_pcmout(vorbis_dsp_state *v,ogg_int32_t ***pcm); | ||
178 | extern int vorbis_synthesis_read(vorbis_dsp_state *v,int samples); | ||
179 | extern long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op); | ||
180 | |||
181 | /* Vorbis ERRORS and return codes ***********************************/ | ||
182 | |||
183 | #define OV_FALSE -1 | ||
184 | #define OV_EOF -2 | ||
185 | #define OV_HOLE -3 | ||
186 | |||
187 | #define OV_EREAD -128 | ||
188 | #define OV_EFAULT -129 | ||
189 | #define OV_EIMPL -130 | ||
190 | #define OV_EINVAL -131 | ||
191 | #define OV_ENOTVORBIS -132 | ||
192 | #define OV_EBADHEADER -133 | ||
193 | #define OV_EVERSION -134 | ||
194 | #define OV_ENOTAUDIO -135 | ||
195 | #define OV_EBADPACKET -136 | ||
196 | #define OV_EBADLINK -137 | ||
197 | #define OV_ENOSEEK -138 | ||
198 | |||
199 | #ifdef __cplusplus | ||
200 | } | ||
201 | #endif /* __cplusplus */ | ||
202 | |||
203 | #endif | ||
204 | |||
diff --git a/lib/rbcodec/codecs/libtremor/ivorbisfile.h b/lib/rbcodec/codecs/libtremor/ivorbisfile.h new file mode 100644 index 0000000000..076783514e --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/ivorbisfile.h | |||
@@ -0,0 +1,131 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: stdio-based convenience library for opening/seeking/decoding | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _OV_FILE_H_ | ||
19 | #define _OV_FILE_H_ | ||
20 | |||
21 | #ifdef __cplusplus | ||
22 | extern "C" | ||
23 | { | ||
24 | #endif /* __cplusplus */ | ||
25 | |||
26 | #include <stdio.h> | ||
27 | #include "ivorbiscodec.h" | ||
28 | |||
29 | |||
30 | #define CHUNKSIZE 1024 | ||
31 | /* The function prototypes for the callbacks are basically the same as for | ||
32 | * the stdio functions fread, fseek, fclose, ftell. | ||
33 | * The one difference is that the FILE * arguments have been replaced with | ||
34 | * a void * - this is to be used as a pointer to whatever internal data these | ||
35 | * functions might need. In the stdio case, it's just a FILE * cast to a void * | ||
36 | * | ||
37 | * If you use other functions, check the docs for these functions and return | ||
38 | * the right values. For seek_func(), you *MUST* return -1 if the stream is | ||
39 | * unseekable | ||
40 | */ | ||
41 | typedef struct { | ||
42 | size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource); | ||
43 | int (*seek_func) (void *datasource, ogg_int64_t offset, int whence); | ||
44 | int (*close_func) (void *datasource); | ||
45 | long (*tell_func) (void *datasource); | ||
46 | } ov_callbacks; | ||
47 | |||
48 | #define NOTOPEN 0 | ||
49 | #define PARTOPEN 1 | ||
50 | #define OPENED 2 | ||
51 | #define STREAMSET 3 | ||
52 | #define INITSET 4 | ||
53 | |||
54 | typedef struct OggVorbis_File { | ||
55 | void *datasource; /* Pointer to a FILE *, etc. */ | ||
56 | int seekable; | ||
57 | ogg_int64_t offset; | ||
58 | ogg_int64_t end; | ||
59 | ogg_sync_state oy; | ||
60 | |||
61 | /* If the FILE handle isn't seekable (eg, a pipe), only the current | ||
62 | stream appears */ | ||
63 | int links; | ||
64 | ogg_int64_t *offsets; | ||
65 | ogg_int64_t *dataoffsets; | ||
66 | ogg_uint32_t *serialnos; | ||
67 | ogg_int64_t *pcmlengths; | ||
68 | vorbis_info *vi; | ||
69 | /* vorbis_comment *vc; */ | ||
70 | |||
71 | /* Decoding working state local storage */ | ||
72 | ogg_int64_t pcm_offset; | ||
73 | int ready_state; | ||
74 | ogg_uint32_t current_serialno; | ||
75 | int current_link; | ||
76 | |||
77 | ogg_int64_t bittrack; | ||
78 | ogg_int64_t samptrack; | ||
79 | |||
80 | ogg_stream_state os; /* take physical pages, weld into a logical | ||
81 | stream of packets */ | ||
82 | vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */ | ||
83 | vorbis_block vb; /* local working space for packet->PCM decode */ | ||
84 | |||
85 | ov_callbacks callbacks; | ||
86 | |||
87 | } OggVorbis_File; | ||
88 | |||
89 | extern int ov_clear(OggVorbis_File *vf); | ||
90 | extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf, | ||
91 | const char *initial, long ibytes, ov_callbacks callbacks); | ||
92 | |||
93 | extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf, | ||
94 | const char *initial, long ibytes, ov_callbacks callbacks); | ||
95 | extern int ov_test_open(OggVorbis_File *vf); | ||
96 | |||
97 | extern long ov_bitrate(OggVorbis_File *vf,int i); | ||
98 | extern long ov_bitrate_instant(OggVorbis_File *vf); | ||
99 | extern long ov_streams(OggVorbis_File *vf); | ||
100 | extern long ov_seekable(OggVorbis_File *vf); | ||
101 | extern long ov_serialnumber(OggVorbis_File *vf,int i); | ||
102 | |||
103 | extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i); | ||
104 | extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i); | ||
105 | extern ogg_int64_t ov_time_total(OggVorbis_File *vf,int i); | ||
106 | |||
107 | extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos); | ||
108 | extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos); | ||
109 | extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos); | ||
110 | extern int ov_time_seek(OggVorbis_File *vf,ogg_int64_t pos); | ||
111 | extern int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t pos); | ||
112 | |||
113 | extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf); | ||
114 | extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf); | ||
115 | extern ogg_int64_t ov_time_tell(OggVorbis_File *vf); | ||
116 | |||
117 | extern vorbis_info *ov_info(OggVorbis_File *vf,int link); | ||
118 | extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link); | ||
119 | |||
120 | extern long ov_read(OggVorbis_File *vf,char *buffer,int length, | ||
121 | int *bitstream); | ||
122 | extern long ov_read_fixed(OggVorbis_File *vf,ogg_int32_t ***pcm_channels, | ||
123 | int length,int *bitstream); | ||
124 | |||
125 | #ifdef __cplusplus | ||
126 | } | ||
127 | #endif /* __cplusplus */ | ||
128 | |||
129 | #endif | ||
130 | |||
131 | |||
diff --git a/lib/rbcodec/codecs/libtremor/libtremor.make b/lib/rbcodec/codecs/libtremor/libtremor.make new file mode 100644 index 0000000000..4a581508b0 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/libtremor.make | |||
@@ -0,0 +1,18 @@ | |||
1 | # __________ __ ___. | ||
2 | # Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
3 | # Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
4 | # Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
5 | # Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
6 | # \/ \/ \/ \/ \/ | ||
7 | # $Id$ | ||
8 | # | ||
9 | |||
10 | # libtremor | ||
11 | TREMORLIB := $(CODECDIR)/libtremor.a | ||
12 | TREMORLIB_SRC := $(call preprocess, $(RBCODECLIB_DIR)/codecs/libtremor/SOURCES) | ||
13 | TREMORLIB_OBJ := $(call c2obj, $(TREMORLIB_SRC)) | ||
14 | OTHER_SRC += $(TREMORLIB_SRC) | ||
15 | |||
16 | $(TREMORLIB): $(TREMORLIB_OBJ) | ||
17 | $(SILENT)$(shell rm -f $@) | ||
18 | $(call PRINTS,AR $(@F))$(AR) rcs $@ $^ >/dev/null | ||
diff --git a/lib/rbcodec/codecs/libtremor/lsp_lookup.h b/lib/rbcodec/codecs/libtremor/lsp_lookup.h new file mode 100644 index 0000000000..d996677ca1 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/lsp_lookup.h | |||
@@ -0,0 +1,132 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: lookup data | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _V_LOOKUP_DATA_H_ | ||
19 | #define _V_LOOKUP_DATA_H_ | ||
20 | |||
21 | #include "os_types.h" | ||
22 | |||
23 | #define FROMdB_LOOKUP_SZ 35 | ||
24 | #define FROMdB2_LOOKUP_SZ 32 | ||
25 | #define FROMdB_SHIFT 5 | ||
26 | #define FROMdB2_SHIFT 3 | ||
27 | #define FROMdB2_MASK 31 | ||
28 | |||
29 | static const ogg_int32_t FROMdB_LOOKUP[FROMdB_LOOKUP_SZ] ={ | ||
30 | 0x003fffff, 0x0028619b, 0x00197a96, 0x0010137a, | ||
31 | 0x000a24b0, 0x00066666, 0x000409c3, 0x00028c42, | ||
32 | 0x00019b8c, 0x000103ab, 0x0000a3d7, 0x00006760, | ||
33 | 0x0000413a, 0x00002928, 0x000019f8, 0x00001062, | ||
34 | 0x00000a56, 0x00000686, 0x0000041e, 0x00000299, | ||
35 | 0x000001a3, 0x00000109, 0x000000a7, 0x00000069, | ||
36 | 0x00000042, 0x0000002a, 0x0000001a, 0x00000011, | ||
37 | 0x0000000b, 0x00000007, 0x00000004, 0x00000003, | ||
38 | 0x00000002, 0x00000001, 0x00000001}; | ||
39 | |||
40 | static const ogg_int32_t FROMdB2_LOOKUP[FROMdB2_LOOKUP_SZ] ={ | ||
41 | 0x000001fc, 0x000001f5, 0x000001ee, 0x000001e7, | ||
42 | 0x000001e0, 0x000001d9, 0x000001d2, 0x000001cc, | ||
43 | 0x000001c5, 0x000001bf, 0x000001b8, 0x000001b2, | ||
44 | 0x000001ac, 0x000001a6, 0x000001a0, 0x0000019a, | ||
45 | 0x00000194, 0x0000018e, 0x00000188, 0x00000183, | ||
46 | 0x0000017d, 0x00000178, 0x00000172, 0x0000016d, | ||
47 | 0x00000168, 0x00000163, 0x0000015e, 0x00000159, | ||
48 | 0x00000154, 0x0000014f, 0x0000014a, 0x00000145, | ||
49 | }; | ||
50 | |||
51 | #define INVSQ_LOOKUP_I_SHIFT 10 | ||
52 | #define INVSQ_LOOKUP_I_MASK 1023 | ||
53 | static const long INVSQ_LOOKUP_I[64+1] ={ | ||
54 | 92682, 91966, 91267, 90583, | ||
55 | 89915, 89261, 88621, 87995, | ||
56 | 87381, 86781, 86192, 85616, | ||
57 | 85051, 84497, 83953, 83420, | ||
58 | 82897, 82384, 81880, 81385, | ||
59 | 80899, 80422, 79953, 79492, | ||
60 | 79039, 78594, 78156, 77726, | ||
61 | 77302, 76885, 76475, 76072, | ||
62 | 75674, 75283, 74898, 74519, | ||
63 | 74146, 73778, 73415, 73058, | ||
64 | 72706, 72359, 72016, 71679, | ||
65 | 71347, 71019, 70695, 70376, | ||
66 | 70061, 69750, 69444, 69141, | ||
67 | 68842, 68548, 68256, 67969, | ||
68 | 67685, 67405, 67128, 66855, | ||
69 | 66585, 66318, 66054, 65794, | ||
70 | 65536, | ||
71 | }; | ||
72 | |||
73 | static const long INVSQ_LOOKUP_IDel[64] ={ | ||
74 | 716, 699, 684, 668, | ||
75 | 654, 640, 626, 614, | ||
76 | 600, 589, 576, 565, | ||
77 | 554, 544, 533, 523, | ||
78 | 513, 504, 495, 486, | ||
79 | 477, 469, 461, 453, | ||
80 | 445, 438, 430, 424, | ||
81 | 417, 410, 403, 398, | ||
82 | 391, 385, 379, 373, | ||
83 | 368, 363, 357, 352, | ||
84 | 347, 343, 337, 332, | ||
85 | 328, 324, 319, 315, | ||
86 | 311, 306, 303, 299, | ||
87 | 294, 292, 287, 284, | ||
88 | 280, 277, 273, 270, | ||
89 | 267, 264, 260, 258, | ||
90 | }; | ||
91 | |||
92 | #define COS_LOOKUP_I_SHIFT 9 | ||
93 | #define COS_LOOKUP_I_MASK 511 | ||
94 | #define COS_LOOKUP_I_SZ 128 | ||
95 | static const ogg_int32_t COS_LOOKUP_I[COS_LOOKUP_I_SZ+1] ={ | ||
96 | 16384, 16379, 16364, 16340, | ||
97 | 16305, 16261, 16207, 16143, | ||
98 | 16069, 15986, 15893, 15791, | ||
99 | 15679, 15557, 15426, 15286, | ||
100 | 15137, 14978, 14811, 14635, | ||
101 | 14449, 14256, 14053, 13842, | ||
102 | 13623, 13395, 13160, 12916, | ||
103 | 12665, 12406, 12140, 11866, | ||
104 | 11585, 11297, 11003, 10702, | ||
105 | 10394, 10080, 9760, 9434, | ||
106 | 9102, 8765, 8423, 8076, | ||
107 | 7723, 7366, 7005, 6639, | ||
108 | 6270, 5897, 5520, 5139, | ||
109 | 4756, 4370, 3981, 3590, | ||
110 | 3196, 2801, 2404, 2006, | ||
111 | 1606, 1205, 804, 402, | ||
112 | 0, -401, -803, -1204, | ||
113 | -1605, -2005, -2403, -2800, | ||
114 | -3195, -3589, -3980, -4369, | ||
115 | -4755, -5138, -5519, -5896, | ||
116 | -6269, -6638, -7004, -7365, | ||
117 | -7722, -8075, -8422, -8764, | ||
118 | -9101, -9433, -9759, -10079, | ||
119 | -10393, -10701, -11002, -11296, | ||
120 | -11584, -11865, -12139, -12405, | ||
121 | -12664, -12915, -13159, -13394, | ||
122 | -13622, -13841, -14052, -14255, | ||
123 | -14448, -14634, -14810, -14977, | ||
124 | -15136, -15285, -15425, -15556, | ||
125 | -15678, -15790, -15892, -15985, | ||
126 | -16068, -16142, -16206, -16260, | ||
127 | -16304, -16339, -16363, -16378, | ||
128 | -16383, | ||
129 | }; | ||
130 | |||
131 | #endif | ||
132 | |||
diff --git a/lib/rbcodec/codecs/libtremor/mapping0.c b/lib/rbcodec/codecs/libtremor/mapping0.c new file mode 100644 index 0000000000..084d5e076d --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/mapping0.c | |||
@@ -0,0 +1,416 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: channel mapping 0 implementation | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <stdio.h> | ||
20 | #include <string.h> | ||
21 | #include <math.h> | ||
22 | #include "ogg.h" | ||
23 | #include "ivorbiscodec.h" | ||
24 | #include "codeclib.h" | ||
25 | #include "codec_internal.h" | ||
26 | #include "codebook.h" | ||
27 | #include "window.h" | ||
28 | #include "registry.h" | ||
29 | #include "misc.h" | ||
30 | #include <codecs/lib/codeclib.h> | ||
31 | |||
32 | /* simplistic, wasteful way of doing this (unique lookup for each | ||
33 | mode/submapping); there should be a central repository for | ||
34 | identical lookups. That will require minor work, so I'm putting it | ||
35 | off as low priority. | ||
36 | |||
37 | Why a lookup for each backend in a given mode? Because the | ||
38 | blocksize is set by the mode, and low backend lookups may require | ||
39 | parameters from other areas of the mode/mapping */ | ||
40 | |||
41 | typedef struct { | ||
42 | vorbis_info_mode *mode; | ||
43 | vorbis_info_mapping0 *map; | ||
44 | |||
45 | vorbis_look_floor **floor_look; | ||
46 | |||
47 | vorbis_look_residue **residue_look; | ||
48 | |||
49 | vorbis_func_floor **floor_func; | ||
50 | vorbis_func_residue **residue_func; | ||
51 | |||
52 | int ch; | ||
53 | long lastframe; /* if a different mode is called, we need to | ||
54 | invalidate decay */ | ||
55 | } vorbis_look_mapping0; | ||
56 | |||
57 | static void mapping0_free_info(vorbis_info_mapping *i){ | ||
58 | vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i; | ||
59 | if(info){ | ||
60 | memset(info,0,sizeof(*info)); | ||
61 | _ogg_free(info); | ||
62 | } | ||
63 | } | ||
64 | |||
65 | static void mapping0_free_look(vorbis_look_mapping *look){ | ||
66 | int i; | ||
67 | vorbis_look_mapping0 *l=(vorbis_look_mapping0 *)look; | ||
68 | if(l){ | ||
69 | |||
70 | for(i=0;i<l->map->submaps;i++){ | ||
71 | l->floor_func[i]->free_look(l->floor_look[i]); | ||
72 | l->residue_func[i]->free_look(l->residue_look[i]); | ||
73 | } | ||
74 | |||
75 | _ogg_free(l->floor_func); | ||
76 | _ogg_free(l->residue_func); | ||
77 | _ogg_free(l->floor_look); | ||
78 | _ogg_free(l->residue_look); | ||
79 | memset(l,0,sizeof(*l)); | ||
80 | _ogg_free(l); | ||
81 | } | ||
82 | } | ||
83 | |||
84 | static vorbis_look_mapping *mapping0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, | ||
85 | vorbis_info_mapping *m){ | ||
86 | int i; | ||
87 | vorbis_info *vi=vd->vi; | ||
88 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
89 | vorbis_look_mapping0 *look=(vorbis_look_mapping0 *)_ogg_calloc(1,sizeof(*look)); | ||
90 | vorbis_info_mapping0 *info=look->map=(vorbis_info_mapping0 *)m; | ||
91 | look->mode=vm; | ||
92 | |||
93 | look->floor_look=(vorbis_look_floor **)_ogg_calloc(info->submaps,sizeof(*look->floor_look)); | ||
94 | |||
95 | look->residue_look=(vorbis_look_residue **)_ogg_calloc(info->submaps,sizeof(*look->residue_look)); | ||
96 | |||
97 | look->floor_func=(vorbis_func_floor **)_ogg_calloc(info->submaps,sizeof(*look->floor_func)); | ||
98 | look->residue_func=(vorbis_func_residue **)_ogg_calloc(info->submaps,sizeof(*look->residue_func)); | ||
99 | |||
100 | for(i=0;i<info->submaps;i++){ | ||
101 | int floornum=info->floorsubmap[i]; | ||
102 | int resnum=info->residuesubmap[i]; | ||
103 | |||
104 | look->floor_func[i]=_floor_P[ci->floor_type[floornum]]; | ||
105 | look->floor_look[i]=look->floor_func[i]-> | ||
106 | look(vd,vm,ci->floor_param[floornum]); | ||
107 | look->residue_func[i]=_residue_P[ci->residue_type[resnum]]; | ||
108 | look->residue_look[i]=look->residue_func[i]-> | ||
109 | look(vd,vm,ci->residue_param[resnum]); | ||
110 | |||
111 | } | ||
112 | |||
113 | look->ch=vi->channels; | ||
114 | |||
115 | return(look); | ||
116 | } | ||
117 | |||
118 | static int ilog(unsigned int v){ | ||
119 | int ret=0; | ||
120 | if(v)--v; | ||
121 | while(v){ | ||
122 | ret++; | ||
123 | v>>=1; | ||
124 | } | ||
125 | return(ret); | ||
126 | } | ||
127 | |||
128 | |||
129 | /* also responsible for range checking */ | ||
130 | static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){ | ||
131 | int i,b; | ||
132 | vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)_ogg_calloc(1,sizeof(*info)); | ||
133 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
134 | memset(info,0,sizeof(*info)); | ||
135 | |||
136 | b=oggpack_read(opb,1); | ||
137 | if(b<0)goto err_out; | ||
138 | if(b){ | ||
139 | info->submaps=oggpack_read(opb,4)+1; | ||
140 | if(info->submaps<=0)goto err_out; | ||
141 | }else | ||
142 | info->submaps=1; | ||
143 | |||
144 | b=oggpack_read(opb,1); | ||
145 | if(b<0)goto err_out; | ||
146 | if(b){ | ||
147 | info->coupling_steps=oggpack_read(opb,8)+1; | ||
148 | if(info->coupling_steps<=0)goto err_out; | ||
149 | for(i=0;i<info->coupling_steps;i++){ | ||
150 | int testM=oggpack_read(opb,ilog(vi->channels)); | ||
151 | info->coupling_mag[i]=testM; | ||
152 | int testA=oggpack_read(opb,ilog(vi->channels)); | ||
153 | info->coupling_ang[i]=testA; | ||
154 | |||
155 | if(testM<0 || | ||
156 | testA<0 || | ||
157 | testM==testA || | ||
158 | testM>=vi->channels || | ||
159 | testA>=vi->channels) goto err_out; | ||
160 | } | ||
161 | |||
162 | } | ||
163 | |||
164 | if(oggpack_read(opb,2)!=0)goto err_out; /* 2,3:reserved */ | ||
165 | |||
166 | if(info->submaps>1){ | ||
167 | for(i=0;i<vi->channels;i++){ | ||
168 | info->chmuxlist[i]=oggpack_read(opb,4); | ||
169 | if(info->chmuxlist[i]>=info->submaps || info->chmuxlist[i]<0)goto err_out; | ||
170 | } | ||
171 | } | ||
172 | for(i=0;i<info->submaps;i++){ | ||
173 | int temp=oggpack_read(opb,8); | ||
174 | if(temp>=ci->times)goto err_out; | ||
175 | info->floorsubmap[i]=oggpack_read(opb,8); | ||
176 | if(info->floorsubmap[i]>=ci->floors || info->floorsubmap[i]<0)goto err_out; | ||
177 | info->residuesubmap[i]=oggpack_read(opb,8); | ||
178 | if(info->residuesubmap[i]>=ci->residues || info->residuesubmap[i]<0) | ||
179 | goto err_out; | ||
180 | } | ||
181 | |||
182 | return info; | ||
183 | |||
184 | err_out: | ||
185 | mapping0_free_info(info); | ||
186 | return(NULL); | ||
187 | } | ||
188 | |||
189 | #ifdef _ARM_ASSEM_ | ||
190 | #define MAGANG( _mag, _ang )\ | ||
191 | {\ | ||
192 | register int temp;\ | ||
193 | asm( "mov %[temp], %[ang]\n\t"\ | ||
194 | "cmp %[mag], #0\n\t"\ | ||
195 | "rsble %[temp], %[temp], #0\n\t"\ | ||
196 | "cmp %[ang], #0\n\t"\ | ||
197 | "subgt %[ang], %[mag], %[temp]\n\t"\ | ||
198 | "movle %[ang], %[mag]\n\t"\ | ||
199 | "addle %[mag], %[mag], %[temp]\n\t"\ | ||
200 | : [mag] "+r" ( ( _mag ) ), [ang] "+r" ( ( _ang ) ), [temp] "=&r" (temp)\ | ||
201 | :\ | ||
202 | : "cc" );\ | ||
203 | } | ||
204 | |||
205 | static inline void channel_couple(ogg_int32_t *pcmM, ogg_int32_t *pcmA, int n) | ||
206 | { | ||
207 | ogg_int32_t * const pcmMend = pcmM + n/2; | ||
208 | while(LIKELY(pcmM < pcmMend)) | ||
209 | { | ||
210 | register int M0 asm("r2"),M1 asm("r3"),M2 asm("r4"),M3 asm("r5"); | ||
211 | register int A0 asm("r6"),A1 asm("r7"),A2 asm("r8"),A3 asm("r9"); | ||
212 | asm volatile( "ldmia %[pcmM], {%[M0], %[M1], %[M2], %[M3]}\n\t" | ||
213 | "ldmia %[pcmA], {%[A0], %[A1], %[A2], %[A3]}\n\t" | ||
214 | : [M0] "=r" (M0), [M1] "=r" (M1), [M2] "=r" (M2), [M3] "=r" (M3), | ||
215 | [A0] "=r" (A0), [A1] "=r" (A1), [A2] "=r" (A2), [A3] "=r" (A3) | ||
216 | : [pcmM] "r" (pcmM), [pcmA] "r" (pcmA) | ||
217 | : "memory" ); | ||
218 | MAGANG( M0, A0 ); | ||
219 | MAGANG( M1, A1 ); | ||
220 | MAGANG( M2, A2 ); | ||
221 | MAGANG( M3, A3 ); | ||
222 | asm volatile( "stmia %[pcmM]!, {%[M0], %[M1], %[M2], %[M3]}\n\t" | ||
223 | "stmia %[pcmA]!, {%[A0], %[A1], %[A2], %[A3]}\n\t" | ||
224 | : [pcmM] "+r" (pcmM), [pcmA] "+r" (pcmA) | ||
225 | : [M0] "r" (M0), [M1] "r" (M1), [M2] "r" (M2), [M3] "r" (M3), | ||
226 | [A0] "r" (A0), [A1] "r" (A1), [A2] "r" (A2), [A3] "r" (A3) | ||
227 | : "memory" ); | ||
228 | } | ||
229 | } | ||
230 | |||
231 | #elif defined CPU_COLDFIRE | ||
232 | |||
233 | #define MAGANG( _mag, _ang, _off )\ | ||
234 | {\ | ||
235 | asm volatile( "tst.l %[mag]\n\t"\ | ||
236 | "bgt.s 1f\n\t"\ | ||
237 | "neg.l %[ang]\n\t" /* neg sets cc so we might as well jump */ \ | ||
238 | "ble.s 2f\n\t"\ | ||
239 | ".word 0x51fb\n\t" /* trapf.l, shadow next 2 insns */ \ | ||
240 | /* if we didn't jump, the next test will */ \ | ||
241 | /* false anyway */ \ | ||
242 | "1:\n\t"\ | ||
243 | "tst.l %[ang]\n\t"\ | ||
244 | "bgt.s 2f\n\t"\ | ||
245 | "add.l %[mag], %[ang]\n\t"\ | ||
246 | "move.l %[ang], (" #_off ", %[pcmM])\n\t"\ | ||
247 | ".word 0x51fa\n\t" /* trapf.w, shadow next insn */ \ | ||
248 | "2:\n\t"\ | ||
249 | "sub.l %[ang], %[mag]\n\t"\ | ||
250 | "move.l %[mag], (%[pcmA])+\n\t"\ | ||
251 | : [mag] "+r" ( ( _mag ) ), [ang] "+d" ( ( _ang ) ),\ | ||
252 | [pcmA] "+a" (pcmA)\ | ||
253 | : [pcmM] "a" (pcmM)\ | ||
254 | : "cc", "memory" );\ | ||
255 | } | ||
256 | static inline void channel_couple(ogg_int32_t *pcmM, ogg_int32_t *pcmA, unsigned int n) | ||
257 | { | ||
258 | ogg_int32_t * const pcmMend = pcmM + n/2; | ||
259 | while(LIKELY(pcmM < pcmMend)) | ||
260 | { | ||
261 | register int M0 asm("a2"),M1 asm("a3"),M2 asm("a4"),M3 asm("a5"); | ||
262 | register int A0 asm("d2"),A1 asm("d3"),A2 asm("d4"),A3 asm("d5"); | ||
263 | asm volatile( "movem.l (%[pcmM]), %[M0]-%[M3]\n\t" | ||
264 | "movem.l (%[pcmA]), %[A0]-%[A3]\n\t" | ||
265 | : [M0] "=r" (M0), [M1] "=r" (M1), [M2] "=r" (M2), [M3] "=r" (M3), | ||
266 | [A0] "=r" (A0), [A1] "=r" (A1), [A2] "=r" (A2), [A3] "=r" (A3) | ||
267 | : [pcmM] "a" (pcmM), [pcmA] "a" (pcmA) ); | ||
268 | |||
269 | /* use offsets instead of autoinc since the store to pcmM is conditional */ | ||
270 | MAGANG( M0, A0, 0 ); | ||
271 | MAGANG( M1, A1, 4 ); | ||
272 | MAGANG( M2, A2, 8 ); | ||
273 | MAGANG( M3, A3, 12 ); | ||
274 | |||
275 | asm volatile( "lea.l (4*4, %[pcmM]), %[pcmM]\n\t" | ||
276 | : [pcmM] "+a" (pcmM)); | ||
277 | } | ||
278 | } | ||
279 | #else | ||
280 | static inline void channel_couple(ogg_int32_t *pcmM, ogg_int32_t *pcmA, int n) | ||
281 | { | ||
282 | int j; | ||
283 | for(j=0;j<n/2;j++){ | ||
284 | ogg_int32_t mag = pcmM[j], ang = pcmA[j], _ang; | ||
285 | if(mag>0) | ||
286 | _ang = ang; | ||
287 | else | ||
288 | _ang = -ang; | ||
289 | |||
290 | if(ang>0) | ||
291 | pcmA[j]=mag-_ang; | ||
292 | else{ | ||
293 | pcmA[j]=mag; | ||
294 | pcmM[j]=mag+_ang; | ||
295 | } | ||
296 | |||
297 | } | ||
298 | } | ||
299 | #endif | ||
300 | |||
301 | static int mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){ | ||
302 | vorbis_dsp_state *vd=vb->vd; | ||
303 | vorbis_info *vi=vd->vi; | ||
304 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
305 | vorbis_look_mapping0 *look=(vorbis_look_mapping0 *)l; | ||
306 | vorbis_info_mapping0 *info=look->map; | ||
307 | |||
308 | int i,j; | ||
309 | long n=vb->pcmend=ci->blocksizes[vb->W]; | ||
310 | |||
311 | /* bounded mapping arrays instead of using alloca(); | ||
312 | avoids memory leak; we can only deal with stereo anyway */ | ||
313 | ogg_int32_t *pcmbundle[CHANNELS]; | ||
314 | int zerobundle[CHANNELS]; | ||
315 | int nonzero[CHANNELS]; | ||
316 | void *floormemo[CHANNELS]; | ||
317 | |||
318 | /* time domain information decode (note that applying the | ||
319 | information would have to happen later; we'll probably add a | ||
320 | function entry to the harness for that later */ | ||
321 | /* NOT IMPLEMENTED */ | ||
322 | |||
323 | /* recover the spectral envelope; store it in the PCM vector for now */ | ||
324 | for(i=0;i<vi->channels;i++){ | ||
325 | int submap=info->chmuxlist[i]; | ||
326 | floormemo[i]=look->floor_func[submap]-> | ||
327 | inverse1(vb,look->floor_look[submap]); | ||
328 | if(floormemo[i]) | ||
329 | nonzero[i]=1; | ||
330 | else | ||
331 | nonzero[i]=0; | ||
332 | memset(vd->floors + i * ci->blocksizes[vb->W]/2,0,sizeof(ogg_int32_t)*n/2); | ||
333 | } | ||
334 | |||
335 | /* channel coupling can 'dirty' the nonzero listing */ | ||
336 | for(i=0;i<info->coupling_steps;i++){ | ||
337 | if(nonzero[info->coupling_mag[i]] || | ||
338 | nonzero[info->coupling_ang[i]]){ | ||
339 | nonzero[info->coupling_mag[i]]=1; | ||
340 | nonzero[info->coupling_ang[i]]=1; | ||
341 | } | ||
342 | } | ||
343 | |||
344 | /* recover the residue into our working vectors */ | ||
345 | for(i=0;i<info->submaps;i++){ | ||
346 | int ch_in_bundle=0; | ||
347 | for(j=0;j<vi->channels;j++){ | ||
348 | if(info->chmuxlist[j]==i){ | ||
349 | if(nonzero[j]) | ||
350 | zerobundle[ch_in_bundle]=1; | ||
351 | else | ||
352 | zerobundle[ch_in_bundle]=0; | ||
353 | pcmbundle[ch_in_bundle++] = vd->floors + j * ci->blocksizes[vb->W]/2; | ||
354 | } | ||
355 | } | ||
356 | |||
357 | look->residue_func[i]->inverse(vb,look->residue_look[i], | ||
358 | pcmbundle,zerobundle,ch_in_bundle); | ||
359 | } | ||
360 | |||
361 | //for(j=0;j<vi->channels;j++) | ||
362 | //_analysis_output("coupled",seq+j,vb->pcm[j],-8,n/2,0,0); | ||
363 | |||
364 | |||
365 | /* channel coupling */ | ||
366 | for(i=info->coupling_steps-1;i>=0;i--){ | ||
367 | ogg_int32_t *pcmM = vd->floors + info->coupling_mag[i] * ci->blocksizes[vb->W]/2; | ||
368 | ogg_int32_t *pcmA = vd->floors + info->coupling_ang[i] * ci->blocksizes[vb->W]/2; | ||
369 | channel_couple(pcmM,pcmA,n); | ||
370 | } | ||
371 | |||
372 | //for(j=0;j<vi->channels;j++) | ||
373 | //_analysis_output("residue",seq+j,vb->pcm[j],-8,n/2,0,0); | ||
374 | |||
375 | //for(j=0;j<vi->channels;j++) | ||
376 | //_analysis_output("mdct",seq+j,vb->pcm[j],-24,n/2,0,1); | ||
377 | |||
378 | /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */ | ||
379 | /* only MDCT right now.... */ | ||
380 | for(i=0;i<vi->channels;i++){ | ||
381 | ogg_int32_t *pcm = vd->floors + i*ci->blocksizes[vb->W]/2; | ||
382 | int submap=info->chmuxlist[i]; | ||
383 | |||
384 | if(nonzero[i]) { | ||
385 | /* compute and apply spectral envelope */ | ||
386 | look->floor_func[submap]-> | ||
387 | inverse2(vb,look->floor_look[submap],floormemo[i],pcm); | ||
388 | |||
389 | ff_imdct_half(ci->blocksizes_nbits[vb->W], | ||
390 | (int32_t*)vd->residues[vd->ri] + i*ci->blocksizes[vb->W]/2, | ||
391 | (int32_t*)&vd->floors[i*ci->blocksizes[vb->W]/2]); | ||
392 | } | ||
393 | else | ||
394 | memset(vd->residues[vd->ri] + i*ci->blocksizes[vb->W]/2, 0, sizeof(ogg_int32_t)*n/2); | ||
395 | } | ||
396 | |||
397 | //for(j=0;j<vi->channels;j++) | ||
398 | //_analysis_output("imdct",seq+j,vb->pcm[j],-24,n,0,0); | ||
399 | |||
400 | //for(j=0;j<vi->channels;j++) | ||
401 | //_analysis_output("window",seq+j,vb->pcm[j],-24,n,0,0); | ||
402 | |||
403 | //seq+=vi->channels; | ||
404 | /* all done! */ | ||
405 | return(0); | ||
406 | } | ||
407 | |||
408 | /* export hooks */ | ||
409 | const vorbis_func_mapping mapping0_exportbundle ICONST_ATTR ={ | ||
410 | &mapping0_unpack, | ||
411 | &mapping0_look, | ||
412 | &mapping0_free_info, | ||
413 | &mapping0_free_look, | ||
414 | &mapping0_inverse | ||
415 | }; | ||
416 | |||
diff --git a/lib/rbcodec/codecs/libtremor/misc.h b/lib/rbcodec/codecs/libtremor/misc.h new file mode 100644 index 0000000000..592a60ffd8 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/misc.h | |||
@@ -0,0 +1,276 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: miscellaneous math and prototypes | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | |||
20 | #ifndef _V_RANDOM_H_ | ||
21 | #define _V_RANDOM_H_ | ||
22 | #include "ivorbiscodec.h" | ||
23 | #include "os_types.h" | ||
24 | |||
25 | #include "codeclib_misc.h" | ||
26 | |||
27 | #include "asm_arm.h" | ||
28 | #include "asm_mcf5249.h" | ||
29 | |||
30 | /* Some prototypes that were not defined elsewhere */ | ||
31 | void *_vorbis_block_alloc(vorbis_block *vb,long bytes); | ||
32 | void _vorbis_block_ripcord(vorbis_block *vb); | ||
33 | extern int _ilog(unsigned int v); | ||
34 | |||
35 | #ifndef _V_WIDE_MATH | ||
36 | #define _V_WIDE_MATH | ||
37 | |||
38 | #ifndef _LOW_ACCURACY_ | ||
39 | /* 64 bit multiply */ | ||
40 | /* #include <sys/types.h> */ | ||
41 | #if 0 | ||
42 | #if BYTE_ORDER==LITTLE_ENDIAN | ||
43 | union magic { | ||
44 | struct { | ||
45 | ogg_int32_t lo; | ||
46 | ogg_int32_t hi; | ||
47 | } halves; | ||
48 | ogg_int64_t whole; | ||
49 | }; | ||
50 | #elif BYTE_ORDER==BIG_ENDIAN | ||
51 | union magic { | ||
52 | struct { | ||
53 | ogg_int32_t hi; | ||
54 | ogg_int32_t lo; | ||
55 | } halves; | ||
56 | ogg_int64_t whole; | ||
57 | }; | ||
58 | #endif | ||
59 | |||
60 | static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { | ||
61 | union magic magic; | ||
62 | magic.whole = (ogg_int64_t)x * y; | ||
63 | return magic.halves.hi; | ||
64 | } | ||
65 | static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { | ||
66 | return MULT32(x,y)<<1; | ||
67 | } | ||
68 | |||
69 | static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { | ||
70 | union magic magic; | ||
71 | magic.whole = (ogg_int64_t)x * y; | ||
72 | return ((ogg_uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17); | ||
73 | } | ||
74 | #endif | ||
75 | #else | ||
76 | /* 32 bit multiply, more portable but less accurate */ | ||
77 | |||
78 | /* | ||
79 | * Note: Precision is biased towards the first argument therefore ordering | ||
80 | * is important. Shift values were chosen for the best sound quality after | ||
81 | * many listening tests. | ||
82 | */ | ||
83 | |||
84 | /* | ||
85 | * For MULT32 and MULT31: The second argument is always a lookup table | ||
86 | * value already preshifted from 31 to 8 bits. We therefore take the | ||
87 | * opportunity to save on text space and use unsigned char for those | ||
88 | * tables in this case. | ||
89 | */ | ||
90 | |||
91 | static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { | ||
92 | return (x >> 9) * y; /* y preshifted >>23 */ | ||
93 | } | ||
94 | |||
95 | static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { | ||
96 | return (x >> 8) * y; /* y preshifted >>23 */ | ||
97 | } | ||
98 | |||
99 | static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { | ||
100 | return (x >> 6) * y; /* y preshifted >>9 */ | ||
101 | } | ||
102 | #endif | ||
103 | |||
104 | /* | ||
105 | * This should be used as a memory barrier, forcing all cached values in | ||
106 | * registers to wr writen back to memory. Might or might not be beneficial | ||
107 | * depending on the architecture and compiler. | ||
108 | */ | ||
109 | #define MB() | ||
110 | |||
111 | /* | ||
112 | * The XPROD functions are meant to optimize the cross products found all | ||
113 | * over the place in mdct.c by forcing memory operation ordering to avoid | ||
114 | * unnecessary register reloads as soon as memory is being written to. | ||
115 | * However this is only beneficial on CPUs with a sane number of general | ||
116 | * purpose registers which exclude the Intel x86. On Intel, better let the | ||
117 | * compiler actually reload registers directly from original memory by using | ||
118 | * macros. | ||
119 | */ | ||
120 | |||
121 | /* replaced XPROD32 with a macro to avoid memory reference | ||
122 | _x, _y are the results (must be l-values) */ | ||
123 | /* | ||
124 | #define XPROD32(_a, _b, _t, _v, _x, _y) \ | ||
125 | { (_x)=MULT32(_a,_t)+MULT32(_b,_v); \ | ||
126 | (_y)=MULT32(_b,_t)-MULT32(_a,_v); } | ||
127 | */ | ||
128 | |||
129 | #ifdef __i386__ | ||
130 | |||
131 | #define XPROD31(_a, _b, _t, _v, _x, _y) \ | ||
132 | { *(_x)=MULT31(_a,_t)+MULT31(_b,_v); \ | ||
133 | *(_y)=MULT31(_b,_t)-MULT31(_a,_v); } | ||
134 | #define XNPROD31(_a, _b, _t, _v, _x, _y) \ | ||
135 | { *(_x)=MULT31(_a,_t)-MULT31(_b,_v); \ | ||
136 | *(_y)=MULT31(_b,_t)+MULT31(_a,_v); } | ||
137 | |||
138 | #else | ||
139 | /* | ||
140 | static inline void XPROD31(ogg_int32_t a, ogg_int32_t b, | ||
141 | ogg_int32_t t, ogg_int32_t v, | ||
142 | ogg_int32_t *x, ogg_int32_t *y) | ||
143 | { | ||
144 | *x = MULT31(a, t) + MULT31(b, v); | ||
145 | *y = MULT31(b, t) - MULT31(a, v); | ||
146 | } | ||
147 | |||
148 | static inline void XNPROD31(ogg_int32_t a, ogg_int32_t b, | ||
149 | ogg_int32_t t, ogg_int32_t v, | ||
150 | ogg_int32_t *x, ogg_int32_t *y) | ||
151 | { | ||
152 | *x = MULT31(a, t) - MULT31(b, v); | ||
153 | *y = MULT31(b, t) + MULT31(a, v); | ||
154 | } | ||
155 | */ | ||
156 | #endif | ||
157 | |||
158 | #if 0 | ||
159 | #ifndef _V_VECT_OPS | ||
160 | #define _V_VECT_OPS | ||
161 | |||
162 | /* generic misc.h has symmetrical versions of vect_add_right_left | ||
163 | and vect_add_left_right (since symmetrical versions of | ||
164 | vect_mult_fw and vect_mult_bw i.e. both use MULT31) */ | ||
165 | static inline | ||
166 | void vect_add_right_left(ogg_int32_t *x, const ogg_int32_t *y, int n) | ||
167 | { | ||
168 | while (n>0) { | ||
169 | *x++ += *y++; | ||
170 | n--; | ||
171 | } | ||
172 | } | ||
173 | |||
174 | static inline | ||
175 | void vect_add_left_right(ogg_int32_t *x, const ogg_int32_t *y, int n) | ||
176 | { | ||
177 | vect_add_right_left(x,y,n); | ||
178 | } | ||
179 | |||
180 | static inline | ||
181 | void ogg_vect_mult_fw(ogg_int32_t *data, LOOKUP_T *window, int n) | ||
182 | { | ||
183 | while(n>0) { | ||
184 | *data = MULT31(*data, *window); | ||
185 | data++; | ||
186 | window++; | ||
187 | n--; | ||
188 | } | ||
189 | } | ||
190 | |||
191 | static inline | ||
192 | void ogg_vect_mult_bw(ogg_int32_t *data, LOOKUP_T *window, int n) | ||
193 | { | ||
194 | while(n>0) { | ||
195 | *data = MULT31(*data, *window); | ||
196 | data++; | ||
197 | window--; | ||
198 | n--; | ||
199 | } | ||
200 | } | ||
201 | |||
202 | /* generic memcpy is probably optimal */ | ||
203 | static inline void vect_copy(ogg_int32_t *x, const ogg_int32_t *y, int n) | ||
204 | { | ||
205 | memcpy(x,y,n*sizeof(ogg_int32_t)); | ||
206 | } | ||
207 | #endif | ||
208 | |||
209 | static inline ogg_int32_t VFLOAT_MULT(ogg_int32_t a,ogg_int32_t ap, | ||
210 | ogg_int32_t b,ogg_int32_t bp, | ||
211 | ogg_int32_t *p){ | ||
212 | if(a && b){ | ||
213 | #ifndef _LOW_ACCURACY_ | ||
214 | *p=ap+bp+32; | ||
215 | return MULT32(a,b); | ||
216 | #else | ||
217 | *p=ap+bp+31; | ||
218 | return (a>>15)*(b>>16); | ||
219 | #endif | ||
220 | }else | ||
221 | return 0; | ||
222 | } | ||
223 | #endif | ||
224 | #endif | ||
225 | static inline ogg_int32_t VFLOAT_MULTI(ogg_int32_t a,ogg_int32_t ap, | ||
226 | ogg_int32_t i, | ||
227 | ogg_int32_t *p){ | ||
228 | |||
229 | int ip=_ilog(abs(i))-31; | ||
230 | return VFLOAT_MULT(a,ap,i<<-ip,ip,p); | ||
231 | } | ||
232 | #if 0 | ||
233 | static inline ogg_int32_t VFLOAT_ADD(ogg_int32_t a,ogg_int32_t ap, | ||
234 | ogg_int32_t b,ogg_int32_t bp, | ||
235 | ogg_int32_t *p){ | ||
236 | |||
237 | if(!a){ | ||
238 | *p=bp; | ||
239 | return b; | ||
240 | }else if(!b){ | ||
241 | *p=ap; | ||
242 | return a; | ||
243 | } | ||
244 | |||
245 | /* yes, this can leak a bit. */ | ||
246 | if(ap>bp){ | ||
247 | int shift=ap-bp+1; | ||
248 | *p=ap+1; | ||
249 | a>>=1; | ||
250 | if(shift<32){ | ||
251 | b=(b+(1<<(shift-1)))>>shift; | ||
252 | }else{ | ||
253 | b=0; | ||
254 | } | ||
255 | }else{ | ||
256 | int shift=bp-ap+1; | ||
257 | *p=bp+1; | ||
258 | b>>=1; | ||
259 | if(shift<32){ | ||
260 | a=(a+(1<<(shift-1)))>>shift; | ||
261 | }else{ | ||
262 | a=0; | ||
263 | } | ||
264 | } | ||
265 | |||
266 | a+=b; | ||
267 | if((a&0xc0000000)==0xc0000000 || | ||
268 | (a&0xc0000000)==0){ | ||
269 | a<<=1; | ||
270 | (*p)--; | ||
271 | } | ||
272 | return(a); | ||
273 | } | ||
274 | #endif | ||
275 | #endif | ||
276 | |||
diff --git a/lib/rbcodec/codecs/libtremor/ogg.h b/lib/rbcodec/codecs/libtremor/ogg.h new file mode 100644 index 0000000000..d3af919b85 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/ogg.h | |||
@@ -0,0 +1,282 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * | ||
4 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
5 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
6 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
7 | * * | ||
8 | * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 * | ||
9 | * by the Xiph.Org Foundation http://www.xiph.org/ * | ||
10 | * * | ||
11 | ******************************************************************** | ||
12 | |||
13 | function: toplevel libogg include | ||
14 | last mod: $Id$ | ||
15 | |||
16 | ********************************************************************/ | ||
17 | #ifndef _OGG_H | ||
18 | #define _OGG_H | ||
19 | |||
20 | #ifdef __cplusplus | ||
21 | extern "C" { | ||
22 | #endif | ||
23 | |||
24 | #include <stddef.h> | ||
25 | #include "os_types.h" | ||
26 | |||
27 | extern const unsigned long mask[] ICONST_ATTR; | ||
28 | |||
29 | typedef struct { | ||
30 | void *iov_base; | ||
31 | size_t iov_len; | ||
32 | } ogg_iovec_t; | ||
33 | |||
34 | typedef struct { | ||
35 | long endbyte; | ||
36 | int endbit; | ||
37 | |||
38 | unsigned char *buffer; | ||
39 | unsigned char *ptr; | ||
40 | long storage; | ||
41 | } oggpack_buffer; | ||
42 | |||
43 | /* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/ | ||
44 | |||
45 | typedef struct { | ||
46 | unsigned char *header; | ||
47 | long header_len; | ||
48 | unsigned char *body; | ||
49 | long body_len; | ||
50 | } ogg_page; | ||
51 | |||
52 | /* ogg_stream_state contains the current encode/decode state of a logical | ||
53 | Ogg bitstream **********************************************************/ | ||
54 | |||
55 | typedef struct { | ||
56 | unsigned char *body_data; /* bytes from packet bodies */ | ||
57 | long body_storage; /* storage elements allocated */ | ||
58 | long body_fill; /* elements stored; fill mark */ | ||
59 | long body_returned; /* elements of fill returned */ | ||
60 | |||
61 | |||
62 | int *lacing_vals; /* The values that will go to the segment table */ | ||
63 | ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact | ||
64 | this way, but it is simple coupled to the | ||
65 | lacing fifo */ | ||
66 | long lacing_storage; | ||
67 | long lacing_fill; | ||
68 | long lacing_packet; | ||
69 | long lacing_returned; | ||
70 | |||
71 | #if 0 | ||
72 | unsigned char header[282]; /* working space for header encode */ | ||
73 | int header_fill; | ||
74 | #endif | ||
75 | int e_o_s; /* set when we have buffered the last packet in the | ||
76 | logical bitstream */ | ||
77 | int b_o_s; /* set after we've written the initial page | ||
78 | of a logical bitstream */ | ||
79 | ogg_uint32_t serialno; | ||
80 | long pageno; | ||
81 | ogg_int64_t packetno; /* sequence number for decode; the framing | ||
82 | knows where there's a hole in the data, | ||
83 | but we need coupling so that the codec | ||
84 | (which is in a separate abstraction | ||
85 | layer) also knows about the gap */ | ||
86 | ogg_int64_t granulepos; | ||
87 | |||
88 | } ogg_stream_state; | ||
89 | |||
90 | /* ogg_packet is used to encapsulate the data and metadata belonging | ||
91 | to a single raw Ogg/Vorbis packet *************************************/ | ||
92 | |||
93 | typedef struct { | ||
94 | unsigned char *packet; | ||
95 | long bytes; | ||
96 | long b_o_s; | ||
97 | long e_o_s; | ||
98 | |||
99 | ogg_int64_t granulepos; | ||
100 | |||
101 | ogg_int64_t packetno; /* sequence number for decode; the framing | ||
102 | knows where there's a hole in the data, | ||
103 | but we need coupling so that the codec | ||
104 | (which is in a separate abstraction | ||
105 | layer) also knows about the gap */ | ||
106 | } ogg_packet; | ||
107 | |||
108 | typedef struct { | ||
109 | unsigned char *data; | ||
110 | int storage; | ||
111 | int fill; | ||
112 | int returned; | ||
113 | |||
114 | int unsynced; | ||
115 | int headerbytes; | ||
116 | int bodybytes; | ||
117 | } ogg_sync_state; | ||
118 | |||
119 | /* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ | ||
120 | /* | ||
121 | extern void oggpack_writeinit(oggpack_buffer *b); | ||
122 | extern int oggpack_writecheck(oggpack_buffer *b); | ||
123 | extern void oggpack_writetrunc(oggpack_buffer *b,long bits); | ||
124 | extern void oggpack_writealign(oggpack_buffer *b); | ||
125 | extern void oggpack_writecopy(oggpack_buffer *b,void *source,long bits); | ||
126 | extern void oggpack_reset(oggpack_buffer *b); | ||
127 | extern void oggpack_writeclear(oggpack_buffer *b); */ | ||
128 | extern void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); | ||
129 | /* | ||
130 | extern void oggpack_write(oggpack_buffer *b,unsigned long value,int bits); | ||
131 | extern long oggpack_look(oggpack_buffer *b,int bits); | ||
132 | */ | ||
133 | |||
134 | static inline long oggpack_look(oggpack_buffer *b,int bits){ | ||
135 | unsigned long ret; | ||
136 | unsigned long m; | ||
137 | |||
138 | if(bits<0 || bits>32) return -1; | ||
139 | m=mask[bits]; | ||
140 | bits+=b->endbit; | ||
141 | |||
142 | if(b->endbyte >= b->storage-4){ | ||
143 | /* not the main path */ | ||
144 | if(b->endbyte > b->storage-((bits+7)>>3)) return -1; | ||
145 | /* special case to avoid reading b->ptr[0], which might be past the end of | ||
146 | the buffer; also skips some useless accounting */ | ||
147 | else if(!bits)return(0L); | ||
148 | } | ||
149 | |||
150 | ret=b->ptr[0]>>b->endbit; | ||
151 | if(bits>8){ | ||
152 | ret|=b->ptr[1]<<(8-b->endbit); | ||
153 | if(bits>16){ | ||
154 | ret|=b->ptr[2]<<(16-b->endbit); | ||
155 | if(bits>24){ | ||
156 | ret|=b->ptr[3]<<(24-b->endbit); | ||
157 | if(bits>32 && b->endbit) | ||
158 | ret|=b->ptr[4]<<(32-b->endbit); | ||
159 | } | ||
160 | } | ||
161 | } | ||
162 | return(m&ret); | ||
163 | } | ||
164 | /* | ||
165 | extern long oggpack_look1(oggpack_buffer *b); | ||
166 | extern void oggpack_adv(oggpack_buffer *b,int bits); | ||
167 | */ | ||
168 | |||
169 | static inline void oggpack_adv(oggpack_buffer *b, unsigned int bits){ | ||
170 | bits+=b->endbit; | ||
171 | |||
172 | if(b->endbyte > b->storage-(int)((bits+7)>>3)) goto overflow; | ||
173 | |||
174 | b->ptr+=bits/8; | ||
175 | b->endbyte+=bits/8; | ||
176 | b->endbit=bits&7; | ||
177 | return; | ||
178 | |||
179 | overflow: | ||
180 | b->ptr=NULL; | ||
181 | b->endbyte=b->storage; | ||
182 | b->endbit=1; | ||
183 | } | ||
184 | |||
185 | /* | ||
186 | extern void oggpack_adv1(oggpack_buffer *b); | ||
187 | */ | ||
188 | extern long oggpack_read(oggpack_buffer *b,int bits); | ||
189 | /* | ||
190 | extern long oggpack_read1(oggpack_buffer *b); | ||
191 | extern long oggpack_bytes(oggpack_buffer *b); | ||
192 | */ | ||
193 | static inline long oggpack_bytes(oggpack_buffer *b){ | ||
194 | return(b->endbyte+(b->endbit+7)/8); | ||
195 | } | ||
196 | #if 0 | ||
197 | extern long oggpack_bits(oggpack_buffer *b); | ||
198 | extern unsigned char *oggpack_get_buffer(oggpack_buffer *b); | ||
199 | |||
200 | extern void oggpackB_writeinit(oggpack_buffer *b); | ||
201 | extern int oggpackB_writecheck(oggpack_buffer *b); | ||
202 | extern void oggpackB_writetrunc(oggpack_buffer *b,long bits); | ||
203 | extern void oggpackB_writealign(oggpack_buffer *b); | ||
204 | extern void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits); | ||
205 | extern void oggpackB_reset(oggpack_buffer *b); | ||
206 | extern void oggpackB_writeclear(oggpack_buffer *b); | ||
207 | extern void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); | ||
208 | extern void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits); | ||
209 | extern long oggpackB_look(oggpack_buffer *b,int bits); | ||
210 | extern long oggpackB_look1(oggpack_buffer *b); | ||
211 | extern void oggpackB_adv(oggpack_buffer *b,int bits); | ||
212 | extern void oggpackB_adv1(oggpack_buffer *b); | ||
213 | extern long oggpackB_read(oggpack_buffer *b,int bits); | ||
214 | extern long oggpackB_read1(oggpack_buffer *b); | ||
215 | extern long oggpackB_bytes(oggpack_buffer *b); | ||
216 | extern long oggpackB_bits(oggpack_buffer *b); | ||
217 | extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b); | ||
218 | # endif | ||
219 | /* Ogg BITSTREAM PRIMITIVES: encoding **************************/ | ||
220 | #if 0 | ||
221 | extern int ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op); | ||
222 | extern int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, | ||
223 | int count, long e_o_s, ogg_int64_t granulepos); | ||
224 | extern int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og); | ||
225 | extern int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill); | ||
226 | extern int ogg_stream_flush(ogg_stream_state *os, ogg_page *og); | ||
227 | #endif | ||
228 | /* Ogg BITSTREAM PRIMITIVES: decoding **************************/ | ||
229 | |||
230 | extern int _os_body_expand(ogg_stream_state *os,int needed); | ||
231 | |||
232 | extern int ogg_sync_init(ogg_sync_state *oy); | ||
233 | extern int ogg_sync_clear(ogg_sync_state *oy); | ||
234 | extern int ogg_sync_reset(ogg_sync_state *oy); | ||
235 | /* | ||
236 | extern int ogg_sync_destroy(ogg_sync_state *oy); | ||
237 | extern int ogg_sync_check(ogg_sync_state *oy); | ||
238 | */ | ||
239 | |||
240 | extern char *ogg_sync_buffer(ogg_sync_state *oy, long size); | ||
241 | extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes); | ||
242 | extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); | ||
243 | /* | ||
244 | extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og); | ||
245 | */ | ||
246 | extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og, bool copy_body); | ||
247 | extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); | ||
248 | extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); | ||
249 | |||
250 | /* Ogg BITSTREAM PRIMITIVES: general ***************************/ | ||
251 | |||
252 | extern int ogg_stream_init(ogg_stream_state *os,int serialno); | ||
253 | extern int ogg_stream_clear(ogg_stream_state *os); | ||
254 | extern int ogg_stream_reset(ogg_stream_state *os); | ||
255 | extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); | ||
256 | /* | ||
257 | extern int ogg_stream_destroy(ogg_stream_state *os); | ||
258 | extern int ogg_stream_check(ogg_stream_state *os); | ||
259 | */ | ||
260 | extern int ogg_stream_eos(ogg_stream_state *os); | ||
261 | |||
262 | /* | ||
263 | extern void ogg_page_checksum_set(ogg_page *og); | ||
264 | extern int ogg_page_version(const ogg_page *og); | ||
265 | */ | ||
266 | extern int ogg_page_continued(const ogg_page *og); | ||
267 | extern int ogg_page_bos(const ogg_page *og); | ||
268 | extern int ogg_page_eos(const ogg_page *og); | ||
269 | extern ogg_int64_t ogg_page_granulepos(const ogg_page *og); | ||
270 | extern ogg_uint32_t ogg_page_serialno(const ogg_page *og); | ||
271 | /* | ||
272 | extern long ogg_page_pageno(const ogg_page *og); | ||
273 | extern int ogg_page_packets(const ogg_page *og); | ||
274 | |||
275 | extern void ogg_packet_clear(ogg_packet *op); | ||
276 | */ | ||
277 | |||
278 | #ifdef __cplusplus | ||
279 | } | ||
280 | #endif | ||
281 | |||
282 | #endif /* _OGG_H */ | ||
diff --git a/lib/rbcodec/codecs/libtremor/oggmalloc.c b/lib/rbcodec/codecs/libtremor/oggmalloc.c new file mode 100644 index 0000000000..783e0f7240 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/oggmalloc.c | |||
@@ -0,0 +1,86 @@ | |||
1 | #include "os_types.h" | ||
2 | #include <tlsf.h> | ||
3 | |||
4 | #if defined(CPU_ARM) || defined(CPU_COLDFIRE) || defined(CPU_MIPS) | ||
5 | #include <setjmp.h> | ||
6 | extern jmp_buf rb_jump_buf; | ||
7 | #define LONGJMP(x) longjmp(rb_jump_buf, x) | ||
8 | #elif defined(SIMULATOR) | ||
9 | #define LONGJMP(x) do { DEBUGF("Vorbis: allocation failed!\n"); return NULL; } while (false) | ||
10 | #else | ||
11 | #define LONGJMP(x) return NULL | ||
12 | #endif | ||
13 | |||
14 | void ogg_malloc_init(void) | ||
15 | { | ||
16 | size_t bufsize; | ||
17 | void* buf = ci->codec_get_buffer(&bufsize); | ||
18 | init_memory_pool(bufsize, buf); | ||
19 | } | ||
20 | |||
21 | void ogg_malloc_destroy() | ||
22 | { | ||
23 | size_t bufsize; | ||
24 | void* buf = ci->codec_get_buffer(&bufsize); | ||
25 | destroy_memory_pool(buf); | ||
26 | } | ||
27 | |||
28 | void *ogg_malloc(size_t size) | ||
29 | { | ||
30 | void* x = tlsf_malloc(size); | ||
31 | |||
32 | if (x == NULL) | ||
33 | LONGJMP(1); | ||
34 | |||
35 | return x; | ||
36 | } | ||
37 | |||
38 | void *ogg_calloc(size_t nmemb, size_t size) | ||
39 | { | ||
40 | void *x = tlsf_calloc(nmemb, size); | ||
41 | |||
42 | if (x == NULL) | ||
43 | LONGJMP(1); | ||
44 | |||
45 | return x; | ||
46 | } | ||
47 | |||
48 | void *ogg_realloc(void *ptr, size_t size) | ||
49 | { | ||
50 | void *x = tlsf_realloc(ptr, size); | ||
51 | |||
52 | if (x == NULL) | ||
53 | LONGJMP(1); | ||
54 | |||
55 | return x; | ||
56 | } | ||
57 | |||
58 | void ogg_free(void* ptr) | ||
59 | { | ||
60 | tlsf_free(ptr); | ||
61 | } | ||
62 | |||
63 | #ifdef TREMOR_USE_IRAM | ||
64 | /* Allocate IRAM buffer */ | ||
65 | static unsigned char iram_buff[IRAM_IBSS_SIZE] IBSS_ATTR MEM_ALIGN_ATTR; | ||
66 | static size_t iram_remain; | ||
67 | |||
68 | void iram_malloc_init(void){ | ||
69 | iram_remain=IRAM_IBSS_SIZE; | ||
70 | } | ||
71 | |||
72 | void *iram_malloc(size_t size){ | ||
73 | void* x; | ||
74 | |||
75 | /* always ensure alignment to CACHEALIGN_SIZE byte */ | ||
76 | size = (size + (CACHEALIGN_SIZE-1)) & ~(CACHEALIGN_SIZE-1); | ||
77 | |||
78 | if(size>iram_remain) | ||
79 | return NULL; | ||
80 | |||
81 | x = &iram_buff[IRAM_IBSS_SIZE-iram_remain]; | ||
82 | iram_remain-=size; | ||
83 | |||
84 | return x; | ||
85 | } | ||
86 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/os.h b/lib/rbcodec/codecs/libtremor/os.h new file mode 100644 index 0000000000..bafcaedb62 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/os.h | |||
@@ -0,0 +1,62 @@ | |||
1 | #ifndef _OS_H | ||
2 | #define _OS_H | ||
3 | /******************************************************************** | ||
4 | * * | ||
5 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
6 | * * | ||
7 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
8 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
9 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
10 | * * | ||
11 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
12 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
13 | * * | ||
14 | ******************************************************************** | ||
15 | |||
16 | function: #ifdef jail to whip a few platforms into the UNIX ideal. | ||
17 | |||
18 | ********************************************************************/ | ||
19 | |||
20 | #include <math.h> | ||
21 | #include "os_types.h" | ||
22 | |||
23 | #ifndef _V_IFDEFJAIL_H_ | ||
24 | # define _V_IFDEFJAIL_H_ | ||
25 | |||
26 | # ifdef __GNUC__ | ||
27 | # define STIN static inline | ||
28 | # elif defined(_WIN32) | ||
29 | # define STIN static __inline__ | ||
30 | # endif | ||
31 | #else | ||
32 | # define STIN static inline | ||
33 | #endif | ||
34 | |||
35 | #ifndef M_PI | ||
36 | # define M_PI (3.1415926536f) | ||
37 | #endif | ||
38 | |||
39 | #ifdef _WIN32 | ||
40 | # include <malloc.h> | ||
41 | # define rint(x) (floor((x)+0.5f)) | ||
42 | # define NO_FLOAT_MATH_LIB | ||
43 | # define FAST_HYPOT(a, b) sqrt((a)*(a) + (b)*(b)) | ||
44 | #endif | ||
45 | |||
46 | #ifdef HAVE_ALLOCA_H | ||
47 | # include <alloca.h> | ||
48 | #endif | ||
49 | |||
50 | #ifdef USE_MEMORY_H | ||
51 | # include <memory.h> | ||
52 | #endif | ||
53 | |||
54 | #ifndef min | ||
55 | # define min(x,y) ((x)>(y)?(y):(x)) | ||
56 | #endif | ||
57 | |||
58 | #ifndef max | ||
59 | # define max(x,y) ((x)<(y)?(y):(x)) | ||
60 | #endif | ||
61 | |||
62 | #endif /* _OS_H */ | ||
diff --git a/lib/rbcodec/codecs/libtremor/os_types.h b/lib/rbcodec/codecs/libtremor/os_types.h new file mode 100644 index 0000000000..b5bd0b713a --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/os_types.h | |||
@@ -0,0 +1,58 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: #ifdef jail to whip a few platforms into the UNIX ideal. | ||
15 | |||
16 | ********************************************************************/ | ||
17 | #include "config-tremor.h" | ||
18 | |||
19 | #ifndef _OS_TYPES_H | ||
20 | #define _OS_TYPES_H | ||
21 | |||
22 | #include <stdint.h> | ||
23 | #include <stdlib.h> | ||
24 | #include <codecs.h> | ||
25 | |||
26 | #ifdef _LOW_ACCURACY_ | ||
27 | # define X(n) (((((n)>>22)+1)>>1) - ((((n)>>22)+1)>>9)) | ||
28 | # define LOOKUP_T const unsigned char | ||
29 | # define LOOKUP_TNC unsigned char | ||
30 | #else | ||
31 | # define X(n) (n) | ||
32 | # define LOOKUP_T const ogg_int32_t | ||
33 | # define LOOKUP_TNC ogg_int32_t | ||
34 | #endif | ||
35 | |||
36 | /* make it easy on the folks that want to compile the libs with a | ||
37 | different malloc than stdlib */ | ||
38 | |||
39 | #define _ogg_malloc ogg_malloc | ||
40 | #define _ogg_calloc ogg_calloc | ||
41 | #define _ogg_realloc ogg_realloc | ||
42 | #define _ogg_free ogg_free | ||
43 | |||
44 | void ogg_malloc_init(void); | ||
45 | void ogg_malloc_destroy(void); | ||
46 | void *ogg_malloc(size_t size); | ||
47 | void *ogg_calloc(size_t nmemb, size_t size); | ||
48 | void *ogg_realloc(void *ptr, size_t size); | ||
49 | void ogg_free(void *ptr); | ||
50 | void iram_malloc_init(void); | ||
51 | void *iram_malloc(size_t size); | ||
52 | |||
53 | typedef int16_t ogg_int16_t; | ||
54 | typedef int32_t ogg_int32_t; | ||
55 | typedef uint32_t ogg_uint32_t; | ||
56 | typedef int64_t ogg_int64_t; | ||
57 | |||
58 | #endif /* _OS_TYPES_H */ | ||
diff --git a/lib/rbcodec/codecs/libtremor/registry.c b/lib/rbcodec/codecs/libtremor/registry.c new file mode 100644 index 0000000000..b1592628a1 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/registry.c | |||
@@ -0,0 +1,50 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: registry for floor, res backends and channel mappings | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "ivorbiscodec.h" | ||
19 | #include "codec_internal.h" | ||
20 | #include "registry.h" | ||
21 | #include "misc.h" | ||
22 | |||
23 | |||
24 | /* seems like major overkill now; the backend numbers will grow into | ||
25 | the infrastructure soon enough */ | ||
26 | |||
27 | extern vorbis_func_floor floor0_exportbundle; | ||
28 | extern vorbis_func_floor floor1_exportbundle; | ||
29 | extern vorbis_func_residue residue0_exportbundle; | ||
30 | extern vorbis_func_residue residue1_exportbundle; | ||
31 | extern vorbis_func_residue residue2_exportbundle; | ||
32 | extern vorbis_func_mapping mapping0_exportbundle; | ||
33 | |||
34 | vorbis_func_floor *_floor_P[] ICONST_ATTR = { | ||
35 | &floor0_exportbundle, | ||
36 | &floor1_exportbundle, | ||
37 | }; | ||
38 | |||
39 | vorbis_func_residue *_residue_P[] ICONST_ATTR = { | ||
40 | &residue0_exportbundle, | ||
41 | &residue1_exportbundle, | ||
42 | &residue2_exportbundle, | ||
43 | }; | ||
44 | |||
45 | vorbis_func_mapping *_mapping_P[] ICONST_ATTR = { | ||
46 | &mapping0_exportbundle, | ||
47 | }; | ||
48 | |||
49 | |||
50 | |||
diff --git a/lib/rbcodec/codecs/libtremor/registry.h b/lib/rbcodec/codecs/libtremor/registry.h new file mode 100644 index 0000000000..2bc8068f69 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/registry.h | |||
@@ -0,0 +1,40 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: registry for time, floor, res backends and channel mappings | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _V_REG_H_ | ||
19 | #define _V_REG_H_ | ||
20 | |||
21 | #define VI_TRANSFORMB 1 | ||
22 | #define VI_WINDOWB 1 | ||
23 | #define VI_TIMEB 1 | ||
24 | #define VI_FLOORB 2 | ||
25 | #define VI_RESB 3 | ||
26 | #define VI_MAPB 1 | ||
27 | |||
28 | #include "backends.h" | ||
29 | |||
30 | #if defined(_WIN32) && defined(VORBISDLL_IMPORT) | ||
31 | # define EXTERN __declspec(dllimport) extern | ||
32 | #else | ||
33 | # define EXTERN extern | ||
34 | #endif | ||
35 | |||
36 | EXTERN vorbis_func_floor *_floor_P[]; | ||
37 | EXTERN vorbis_func_residue *_residue_P[]; | ||
38 | EXTERN vorbis_func_mapping *_mapping_P[]; | ||
39 | |||
40 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/res012.c b/lib/rbcodec/codecs/libtremor/res012.c new file mode 100644 index 0000000000..e4ff440a6d --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/res012.c | |||
@@ -0,0 +1,374 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: residue backend 0, 1 and 2 implementation | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <string.h> | ||
20 | #include <math.h> | ||
21 | #include "ogg.h" | ||
22 | #include "ivorbiscodec.h" | ||
23 | #include "codec_internal.h" | ||
24 | #include "registry.h" | ||
25 | #include "codebook.h" | ||
26 | #include "misc.h" | ||
27 | #include "os.h" | ||
28 | |||
29 | typedef struct { | ||
30 | vorbis_info_residue0 *info; | ||
31 | int map; | ||
32 | |||
33 | int parts; | ||
34 | int stages; | ||
35 | codebook *fullbooks; | ||
36 | codebook *phrasebook; | ||
37 | codebook ***partbooks; | ||
38 | |||
39 | int partvals; | ||
40 | int **decodemap; | ||
41 | |||
42 | } vorbis_look_residue0; | ||
43 | |||
44 | static void res0_free_info(vorbis_info_residue *i){ | ||
45 | vorbis_info_residue0 *info=(vorbis_info_residue0 *)i; | ||
46 | if(info){ | ||
47 | memset(info,0,sizeof(*info)); | ||
48 | _ogg_free(info); | ||
49 | } | ||
50 | } | ||
51 | |||
52 | static void res0_free_look(vorbis_look_residue *i){ | ||
53 | int j; | ||
54 | if(i){ | ||
55 | |||
56 | vorbis_look_residue0 *look=(vorbis_look_residue0 *)i; | ||
57 | |||
58 | for(j=0;j<look->parts;j++) | ||
59 | if(look->partbooks[j])_ogg_free(look->partbooks[j]); | ||
60 | _ogg_free(look->partbooks); | ||
61 | for(j=0;j<look->partvals;j++) | ||
62 | _ogg_free(look->decodemap[j]); | ||
63 | _ogg_free(look->decodemap); | ||
64 | |||
65 | memset(look,0,sizeof(*look)); | ||
66 | _ogg_free(look); | ||
67 | } | ||
68 | } | ||
69 | |||
70 | static int ilog(unsigned int v){ | ||
71 | int ret=0; | ||
72 | while(v){ | ||
73 | ret++; | ||
74 | v>>=1; | ||
75 | } | ||
76 | return(ret); | ||
77 | } | ||
78 | |||
79 | static int icount(unsigned int v){ | ||
80 | int ret=0; | ||
81 | while(v){ | ||
82 | ret+=v&1; | ||
83 | v>>=1; | ||
84 | } | ||
85 | return(ret); | ||
86 | } | ||
87 | |||
88 | /* vorbis_info is for range checking */ | ||
89 | static vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){ | ||
90 | int j,acc=0; | ||
91 | vorbis_info_residue0 *info=(vorbis_info_residue0 *)_ogg_calloc(1,sizeof(*info)); | ||
92 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
93 | |||
94 | info->begin=oggpack_read(opb,24); | ||
95 | info->end=oggpack_read(opb,24); | ||
96 | info->grouping=oggpack_read(opb,24)+1; | ||
97 | info->partitions=oggpack_read(opb,6)+1; | ||
98 | info->groupbook=oggpack_read(opb,8); | ||
99 | |||
100 | /* check for premature EOP */ | ||
101 | if(info->groupbook<0)goto errout; | ||
102 | |||
103 | for(j=0;j<info->partitions;j++){ | ||
104 | int cascade=oggpack_read(opb,3); | ||
105 | int cflag=oggpack_read(opb,1); | ||
106 | if(cflag<0) goto errout; | ||
107 | if(cflag){ | ||
108 | int c=oggpack_read(opb,5); | ||
109 | if(c<0) goto errout; | ||
110 | cascade|=(c<<3); | ||
111 | } | ||
112 | info->secondstages[j]=cascade; | ||
113 | |||
114 | acc+=icount(cascade); | ||
115 | } | ||
116 | for(j=0;j<acc;j++){ | ||
117 | int book=oggpack_read(opb,8); | ||
118 | if(book<0) goto errout; | ||
119 | info->booklist[j]=book; | ||
120 | } | ||
121 | |||
122 | if(info->groupbook>=ci->books)goto errout; | ||
123 | for(j=0;j<acc;j++){ | ||
124 | if(info->booklist[j]>=ci->books)goto errout; | ||
125 | if(ci->book_param[info->booklist[j]]->maptype==0)goto errout; | ||
126 | } | ||
127 | |||
128 | /* verify the phrasebook is not specifying an impossible or | ||
129 | inconsistent partitioning scheme. */ | ||
130 | /* modify the phrasebook ranging check from r16327; an early beta | ||
131 | encoder had a bug where it used an oversized phrasebook by | ||
132 | accident. These files should continue to be playable, but don't | ||
133 | allow an exploit */ | ||
134 | { | ||
135 | int entries = ci->book_param[info->groupbook]->entries; | ||
136 | int dim = ci->book_param[info->groupbook]->dim; | ||
137 | int partvals = 1; | ||
138 | if (dim<1) goto errout; | ||
139 | while(dim>0){ | ||
140 | partvals *= info->partitions; | ||
141 | if(partvals > entries) goto errout; | ||
142 | dim--; | ||
143 | } | ||
144 | info->partvals = partvals; | ||
145 | } | ||
146 | |||
147 | return(info); | ||
148 | errout: | ||
149 | res0_free_info(info); | ||
150 | return(NULL); | ||
151 | } | ||
152 | |||
153 | static vorbis_look_residue *res0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, | ||
154 | vorbis_info_residue *vr){ | ||
155 | vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr; | ||
156 | vorbis_look_residue0 *look=(vorbis_look_residue0 *)_ogg_calloc(1,sizeof(*look)); | ||
157 | codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; | ||
158 | |||
159 | int j,k,acc=0; | ||
160 | int dim; | ||
161 | int maxstage=0; | ||
162 | look->info=info; | ||
163 | look->map=vm->mapping; | ||
164 | |||
165 | look->parts=info->partitions; | ||
166 | look->fullbooks=ci->fullbooks; | ||
167 | look->phrasebook=ci->fullbooks+info->groupbook; | ||
168 | dim=look->phrasebook->dim; | ||
169 | |||
170 | look->partbooks=(codebook ***)_ogg_calloc(look->parts,sizeof(*look->partbooks)); | ||
171 | |||
172 | for(j=0;j<look->parts;j++){ | ||
173 | int stages=ilog(info->secondstages[j]); | ||
174 | if(stages){ | ||
175 | if(stages>maxstage)maxstage=stages; | ||
176 | look->partbooks[j]=(codebook **)_ogg_calloc(stages,sizeof(*look->partbooks[j])); | ||
177 | for(k=0;k<stages;k++) | ||
178 | if(info->secondstages[j]&(1<<k)){ | ||
179 | look->partbooks[j][k]=ci->fullbooks+info->booklist[acc++]; | ||
180 | #ifdef TRAIN_RES | ||
181 | look->training_data[k][j]=calloc(look->partbooks[j][k]->entries, | ||
182 | sizeof(***look->training_data)); | ||
183 | #endif | ||
184 | } | ||
185 | } | ||
186 | } | ||
187 | |||
188 | look->partvals=look->parts; | ||
189 | for(j=1;j<dim;j++)look->partvals*=look->parts; | ||
190 | look->stages=maxstage; | ||
191 | look->decodemap=(int **)_ogg_malloc(look->partvals*sizeof(*look->decodemap)); | ||
192 | for(j=0;j<look->partvals;j++){ | ||
193 | long val=j; | ||
194 | long mult=look->partvals/look->parts; | ||
195 | look->decodemap[j]=(int *)_ogg_malloc(dim*sizeof(*look->decodemap[j])); | ||
196 | for(k=0;k<dim;k++){ | ||
197 | long deco=val/mult; | ||
198 | val-=deco*mult; | ||
199 | mult/=look->parts; | ||
200 | look->decodemap[j][k]=deco; | ||
201 | } | ||
202 | } | ||
203 | |||
204 | return(look); | ||
205 | } | ||
206 | |||
207 | /* a truncated packet here just means 'stop working'; it's not an error */ | ||
208 | static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl, | ||
209 | ogg_int32_t **in,int ch, | ||
210 | long (*decodepart)(codebook *, ogg_int32_t *, | ||
211 | oggpack_buffer *,int,int)){ | ||
212 | |||
213 | long i,j,k,l,s; | ||
214 | vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl; | ||
215 | vorbis_info_residue0 *info=look->info; | ||
216 | |||
217 | /* move all this setup out later */ | ||
218 | int samples_per_partition=info->grouping; | ||
219 | int partitions_per_word=look->phrasebook->dim; | ||
220 | int max=vb->pcmend>>1; | ||
221 | int end=(info->end<max?info->end:max); | ||
222 | int n=end-info->begin; | ||
223 | |||
224 | if(n>0){ | ||
225 | int partvals=n/samples_per_partition; | ||
226 | int partwords=(partvals+partitions_per_word-1)/partitions_per_word; | ||
227 | int ***partword=(int ***)alloca(ch*sizeof(*partword)); | ||
228 | |||
229 | for(j=0;j<ch;j++) | ||
230 | partword[j]=(int **)_vorbis_block_alloc(vb,partwords*sizeof(*partword[j])); | ||
231 | |||
232 | for(s=0;s<look->stages;s++){ | ||
233 | |||
234 | /* each loop decodes on partition codeword containing | ||
235 | partitions_pre_word partitions */ | ||
236 | for(i=0,l=0;i<partvals;l++){ | ||
237 | if(s==0){ | ||
238 | /* fetch the partition word for each channel */ | ||
239 | for(j=0;j<ch;j++){ | ||
240 | int temp=vorbis_book_decode(look->phrasebook,&vb->opb); | ||
241 | if(temp==-1 || temp>=info->partvals)goto eopbreak; | ||
242 | partword[j][l]=look->decodemap[temp]; | ||
243 | if(partword[j][l]==NULL)goto errout; | ||
244 | } | ||
245 | } | ||
246 | |||
247 | /* now we decode residual values for the partitions */ | ||
248 | for(k=0;k<partitions_per_word && i<partvals;k++,i++) | ||
249 | for(j=0;j<ch;j++){ | ||
250 | long offset=info->begin+i*samples_per_partition; | ||
251 | if(info->secondstages[partword[j][l][k]]&(1<<s)){ | ||
252 | codebook *stagebook=look->partbooks[partword[j][l][k]][s]; | ||
253 | if(stagebook){ | ||
254 | if(decodepart(stagebook,in[j]+offset,&vb->opb, | ||
255 | samples_per_partition,-8)==-1)goto eopbreak; | ||
256 | } | ||
257 | } | ||
258 | } | ||
259 | } | ||
260 | } | ||
261 | } | ||
262 | errout: | ||
263 | eopbreak: | ||
264 | return(0); | ||
265 | } | ||
266 | |||
267 | static int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl, | ||
268 | ogg_int32_t **in,int *nonzero,int ch){ | ||
269 | int i,used=0; | ||
270 | for(i=0;i<ch;i++) | ||
271 | if(nonzero[i]) | ||
272 | in[used++]=in[i]; | ||
273 | if(used) | ||
274 | return(_01inverse(vb,vl,in,used,vorbis_book_decodevs_add)); | ||
275 | else | ||
276 | return(0); | ||
277 | } | ||
278 | |||
279 | static int res1_inverse(vorbis_block *vb,vorbis_look_residue *vl, | ||
280 | ogg_int32_t **in,int *nonzero,int ch){ | ||
281 | int i,used=0; | ||
282 | for(i=0;i<ch;i++) | ||
283 | if(nonzero[i]) | ||
284 | in[used++]=in[i]; | ||
285 | if(used) | ||
286 | return(_01inverse(vb,vl,in,used,vorbis_book_decodev_add)); | ||
287 | else | ||
288 | return(0); | ||
289 | } | ||
290 | |||
291 | /* duplicate code here as speed is somewhat more important */ | ||
292 | static int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl, | ||
293 | ogg_int32_t **in,int *nonzero,int ch) | ||
294 | ICODE_ATTR_TREMOR_NOT_MDCT; | ||
295 | static int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl, | ||
296 | ogg_int32_t **in,int *nonzero,int ch){ | ||
297 | long i,k,l,s; | ||
298 | vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl; | ||
299 | vorbis_info_residue0 *info=look->info; | ||
300 | |||
301 | /* move all this setup out later */ | ||
302 | int samples_per_partition=info->grouping; | ||
303 | int partitions_per_word=look->phrasebook->dim; | ||
304 | int max=(vb->pcmend*ch)>>1; | ||
305 | int end=(info->end<max?info->end:max); | ||
306 | int n=end-info->begin; | ||
307 | |||
308 | if(n>0){ | ||
309 | |||
310 | int partvals=n/samples_per_partition; | ||
311 | int partwords=(partvals+partitions_per_word-1)/partitions_per_word; | ||
312 | int **partword=(int **)_vorbis_block_alloc(vb,partwords*sizeof(*partword)); | ||
313 | int beginoff=info->begin/ch; | ||
314 | |||
315 | for(i=0;i<ch;i++)if(nonzero[i])break; | ||
316 | if(i==ch)return(0); /* no nonzero vectors */ | ||
317 | |||
318 | samples_per_partition/=ch; | ||
319 | |||
320 | for(s=0;s<look->stages;s++){ | ||
321 | for(i=0,l=0;i<partvals;l++){ | ||
322 | |||
323 | if(s==0){ | ||
324 | /* fetch the partition word */ | ||
325 | int temp=vorbis_book_decode(look->phrasebook,&vb->opb); | ||
326 | if(temp==-1 || temp>=info->partvals)goto eopbreak; | ||
327 | partword[l]=look->decodemap[temp]; | ||
328 | if(partword[l]==NULL)goto errout; | ||
329 | } | ||
330 | |||
331 | /* now we decode residual values for the partitions */ | ||
332 | for(k=0;k<partitions_per_word && i<partvals;k++,i++) | ||
333 | if(info->secondstages[partword[l][k]]&(1<<s)){ | ||
334 | codebook *stagebook=look->partbooks[partword[l][k]][s]; | ||
335 | if(stagebook){ | ||
336 | if(vorbis_book_decodevv_add(stagebook,in, | ||
337 | i*samples_per_partition+beginoff,ch, | ||
338 | &vb->opb, | ||
339 | samples_per_partition,-8)==-1) | ||
340 | goto eopbreak; | ||
341 | } | ||
342 | } | ||
343 | } | ||
344 | } | ||
345 | } | ||
346 | errout: | ||
347 | eopbreak: | ||
348 | return(0); | ||
349 | } | ||
350 | |||
351 | |||
352 | const vorbis_func_residue residue0_exportbundle ICONST_ATTR ={ | ||
353 | &res0_unpack, | ||
354 | &res0_look, | ||
355 | &res0_free_info, | ||
356 | &res0_free_look, | ||
357 | &res0_inverse | ||
358 | }; | ||
359 | |||
360 | const vorbis_func_residue residue1_exportbundle ICONST_ATTR ={ | ||
361 | &res0_unpack, | ||
362 | &res0_look, | ||
363 | &res0_free_info, | ||
364 | &res0_free_look, | ||
365 | &res1_inverse | ||
366 | }; | ||
367 | |||
368 | const vorbis_func_residue residue2_exportbundle ICONST_ATTR ={ | ||
369 | &res0_unpack, | ||
370 | &res0_look, | ||
371 | &res0_free_info, | ||
372 | &res0_free_look, | ||
373 | &res2_inverse | ||
374 | }; | ||
diff --git a/lib/rbcodec/codecs/libtremor/sharedbook.c b/lib/rbcodec/codecs/libtremor/sharedbook.c new file mode 100644 index 0000000000..8b046217c7 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/sharedbook.c | |||
@@ -0,0 +1,460 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: basic shared codebook operations | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <math.h> | ||
20 | #include <string.h> | ||
21 | #include "ogg.h" | ||
22 | #include "os.h" | ||
23 | #include "misc.h" | ||
24 | #include "ivorbiscodec.h" | ||
25 | #include "codebook.h" | ||
26 | |||
27 | /**** pack/unpack helpers ******************************************/ | ||
28 | int _ilog(unsigned int v){ | ||
29 | int ret=0; | ||
30 | while(v){ | ||
31 | ret++; | ||
32 | v>>=1; | ||
33 | } | ||
34 | return(ret); | ||
35 | } | ||
36 | |||
37 | /* 32 bit float (not IEEE; nonnormalized mantissa + | ||
38 | biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm | ||
39 | Why not IEEE? It's just not that important here. */ | ||
40 | |||
41 | #define VQ_FEXP 10 | ||
42 | #define VQ_FMAN 21 | ||
43 | #define VQ_FEXP_BIAS 768 /* bias toward values smaller than 1. */ | ||
44 | |||
45 | static ogg_int32_t _float32_unpack(long val,int *point){ | ||
46 | long mant=val&0x1fffff; | ||
47 | int sign=val&0x80000000; | ||
48 | long exp =(val&0x7fe00000L)>>VQ_FMAN; | ||
49 | |||
50 | exp-=(VQ_FMAN-1)+VQ_FEXP_BIAS; | ||
51 | |||
52 | if(mant){ | ||
53 | while(!(mant&0x40000000)){ | ||
54 | mant<<=1; | ||
55 | exp-=1; | ||
56 | } | ||
57 | |||
58 | if(sign)mant= -mant; | ||
59 | }else{ | ||
60 | sign=0; | ||
61 | exp=-9999; | ||
62 | } | ||
63 | |||
64 | *point=exp; | ||
65 | return mant; | ||
66 | } | ||
67 | |||
68 | /* given a list of word lengths, generate a list of codewords. Works | ||
69 | for length ordered or unordered, always assigns the lowest valued | ||
70 | codewords first. Extended to handle unused entries (length 0) */ | ||
71 | static ogg_uint32_t *_make_words(long *l,long n,long sparsecount){ | ||
72 | long i,j,count=0; | ||
73 | ogg_uint32_t marker[33]; | ||
74 | ogg_uint32_t *r=(ogg_uint32_t *)_ogg_malloc((sparsecount?sparsecount:n)*sizeof(*r)); | ||
75 | memset(marker,0,sizeof(marker)); | ||
76 | |||
77 | for(i=0;i<n;i++){ | ||
78 | long length=l[i]; | ||
79 | if(length>0){ | ||
80 | ogg_uint32_t entry=marker[length]; | ||
81 | |||
82 | /* when we claim a node for an entry, we also claim the nodes | ||
83 | below it (pruning off the imagined tree that may have dangled | ||
84 | from it) as well as blocking the use of any nodes directly | ||
85 | above for leaves */ | ||
86 | |||
87 | /* update ourself */ | ||
88 | if(length<32 && (entry>>length)){ | ||
89 | /* error condition; the lengths must specify an overpopulated tree */ | ||
90 | _ogg_free(r); | ||
91 | return(NULL); | ||
92 | } | ||
93 | r[count++]=entry; | ||
94 | |||
95 | /* Look to see if the next shorter marker points to the node | ||
96 | above. if so, update it and repeat. */ | ||
97 | { | ||
98 | for(j=length;j>0;j--){ | ||
99 | |||
100 | if(marker[j]&1){ | ||
101 | /* have to jump branches */ | ||
102 | if(j==1) | ||
103 | marker[1]++; | ||
104 | else | ||
105 | marker[j]=marker[j-1]<<1; | ||
106 | break; /* invariant says next upper marker would already | ||
107 | have been moved if it was on the same path */ | ||
108 | } | ||
109 | marker[j]++; | ||
110 | } | ||
111 | } | ||
112 | |||
113 | /* prune the tree; the implicit invariant says all the longer | ||
114 | markers were dangling from our just-taken node. Dangle them | ||
115 | from our *new* node. */ | ||
116 | for(j=length+1;j<33;j++) | ||
117 | if((marker[j]>>1) == entry){ | ||
118 | entry=marker[j]; | ||
119 | marker[j]=marker[j-1]<<1; | ||
120 | }else | ||
121 | break; | ||
122 | }else | ||
123 | if(sparsecount==0)count++; | ||
124 | } | ||
125 | |||
126 | /* sanity check the huffman tree; an underpopulated tree must be | ||
127 | rejected. The only exception is the one-node pseudo-nil tree, | ||
128 | which appears to be underpopulated because the tree doesn't | ||
129 | really exist; there's only one possible 'codeword' or zero bits, | ||
130 | but the above tree-gen code doesn't mark that. */ | ||
131 | if(sparsecount != 1){ | ||
132 | for(i=1;i<33;i++) | ||
133 | if(marker[i] & (0xffffffffUL>>(32-i))){ | ||
134 | _ogg_free(r); | ||
135 | return(NULL); | ||
136 | } | ||
137 | } | ||
138 | |||
139 | /* bitreverse the words because our bitwise packer/unpacker is LSb | ||
140 | endian */ | ||
141 | for(i=0,count=0;i<n;i++){ | ||
142 | ogg_uint32_t temp=0; | ||
143 | for(j=0;j<l[i];j++){ | ||
144 | temp<<=1; | ||
145 | temp|=(r[count]>>j)&1; | ||
146 | } | ||
147 | |||
148 | if(sparsecount){ | ||
149 | if(l[i]) | ||
150 | r[count++]=temp; | ||
151 | }else | ||
152 | r[count++]=temp; | ||
153 | } | ||
154 | |||
155 | return(r); | ||
156 | } | ||
157 | |||
158 | /* there might be a straightforward one-line way to do the below | ||
159 | that's portable and totally safe against roundoff, but I haven't | ||
160 | thought of it. Therefore, we opt on the side of caution */ | ||
161 | long _book_maptype1_quantvals(const static_codebook *b){ | ||
162 | /* get us a starting hint, we'll polish it below */ | ||
163 | int bits=_ilog(b->entries); | ||
164 | int vals=b->entries>>((bits-1)*(b->dim-1)/b->dim); | ||
165 | |||
166 | while(1){ | ||
167 | long acc=1; | ||
168 | long acc1=1; | ||
169 | int i; | ||
170 | for(i=0;i<b->dim;i++){ | ||
171 | acc*=vals; | ||
172 | acc1*=vals+1; | ||
173 | } | ||
174 | if(acc<=b->entries && acc1>b->entries){ | ||
175 | return(vals); | ||
176 | }else{ | ||
177 | if(acc>b->entries){ | ||
178 | vals--; | ||
179 | }else{ | ||
180 | vals++; | ||
181 | } | ||
182 | } | ||
183 | } | ||
184 | } | ||
185 | |||
186 | /* different than what _book_unquantize does for mainline: | ||
187 | we repack the book in a fixed point format that shares the same | ||
188 | binary point. Upon first use, we can shift point if needed */ | ||
189 | |||
190 | /* we need to deal with two map types: in map type 1, the values are | ||
191 | generated algorithmically (each column of the vector counts through | ||
192 | the values in the quant vector). in map type 2, all the values came | ||
193 | in in an explicit list. Both value lists must be unpacked */ | ||
194 | |||
195 | static ogg_int32_t *_book_unquantize(const static_codebook *b,int n, | ||
196 | int *sparsemap,int *maxpoint){ | ||
197 | long j,k,count=0; | ||
198 | if(b->maptype==1 || b->maptype==2){ | ||
199 | int quantvals; | ||
200 | int minpoint,delpoint; | ||
201 | ogg_int32_t mindel=_float32_unpack(b->q_min,&minpoint); | ||
202 | ogg_int32_t delta=_float32_unpack(b->q_delta,&delpoint); | ||
203 | ogg_int32_t *r=(ogg_int32_t *)_ogg_calloc(n*b->dim,sizeof(*r)); | ||
204 | int *rp=(int *)_ogg_calloc(n*b->dim,sizeof(*rp)); | ||
205 | |||
206 | *maxpoint=minpoint; | ||
207 | |||
208 | /* maptype 1 and 2 both use a quantized value vector, but | ||
209 | different sizes */ | ||
210 | switch(b->maptype){ | ||
211 | case 1: | ||
212 | /* most of the time, entries%dimensions == 0, but we need to be | ||
213 | well defined. We define that the possible vales at each | ||
214 | scalar is values == entries/dim. If entries%dim != 0, we'll | ||
215 | have 'too few' values (values*dim<entries), which means that | ||
216 | we'll have 'left over' entries; left over entries use zeroed | ||
217 | values (and are wasted). So don't generate codebooks like | ||
218 | that */ | ||
219 | quantvals=_book_maptype1_quantvals(b); | ||
220 | for(j=0;j<b->entries;j++){ | ||
221 | if((sparsemap && b->lengthlist[j]) || !sparsemap){ | ||
222 | ogg_int32_t last=0; | ||
223 | int lastpoint=0; | ||
224 | int indexdiv=1; | ||
225 | for(k=0;k<b->dim;k++){ | ||
226 | int index= (j/indexdiv)%quantvals; | ||
227 | ogg_int32_t point=0; | ||
228 | int val=VFLOAT_MULTI(delta,delpoint, | ||
229 | abs(b->quantlist[index]),&point); | ||
230 | |||
231 | val=VFLOAT_ADD(mindel,minpoint,val,point,&point); | ||
232 | val=VFLOAT_ADD(last,lastpoint,val,point,&point); | ||
233 | |||
234 | if(b->q_sequencep){ | ||
235 | last=val; | ||
236 | lastpoint=point; | ||
237 | } | ||
238 | |||
239 | if(sparsemap){ | ||
240 | r[sparsemap[count]*b->dim+k]=val; | ||
241 | rp[sparsemap[count]*b->dim+k]=point; | ||
242 | }else{ | ||
243 | r[count*b->dim+k]=val; | ||
244 | rp[count*b->dim+k]=point; | ||
245 | } | ||
246 | if(*maxpoint<point)*maxpoint=point; | ||
247 | indexdiv*=quantvals; | ||
248 | } | ||
249 | count++; | ||
250 | } | ||
251 | |||
252 | } | ||
253 | break; | ||
254 | case 2: | ||
255 | for(j=0;j<b->entries;j++){ | ||
256 | if((sparsemap && b->lengthlist[j]) || !sparsemap){ | ||
257 | ogg_int32_t last=0; | ||
258 | int lastpoint=0; | ||
259 | |||
260 | for(k=0;k<b->dim;k++){ | ||
261 | ogg_int32_t point=0; | ||
262 | int val=VFLOAT_MULTI(delta,delpoint, | ||
263 | abs(b->quantlist[j*b->dim+k]),&point); | ||
264 | |||
265 | val=VFLOAT_ADD(mindel,minpoint,val,point,&point); | ||
266 | val=VFLOAT_ADD(last,lastpoint,val,point,&point); | ||
267 | |||
268 | if(b->q_sequencep){ | ||
269 | last=val; | ||
270 | lastpoint=point; | ||
271 | } | ||
272 | |||
273 | if(sparsemap){ | ||
274 | r[sparsemap[count]*b->dim+k]=val; | ||
275 | rp[sparsemap[count]*b->dim+k]=point; | ||
276 | }else{ | ||
277 | r[count*b->dim+k]=val; | ||
278 | rp[count*b->dim+k]=point; | ||
279 | } | ||
280 | if(*maxpoint<point)*maxpoint=point; | ||
281 | } | ||
282 | count++; | ||
283 | } | ||
284 | } | ||
285 | break; | ||
286 | } | ||
287 | |||
288 | for(j=0;j<n*b->dim;j++) | ||
289 | if(rp[j]<*maxpoint) | ||
290 | r[j]>>=*maxpoint-rp[j]; | ||
291 | |||
292 | _ogg_free(rp); | ||
293 | return(r); | ||
294 | } | ||
295 | return(NULL); | ||
296 | } | ||
297 | |||
298 | void vorbis_staticbook_destroy(static_codebook *b){ | ||
299 | if(b->quantlist)_ogg_free(b->quantlist); | ||
300 | if(b->lengthlist)_ogg_free(b->lengthlist); | ||
301 | memset(b,0,sizeof(*b)); | ||
302 | _ogg_free(b); | ||
303 | } | ||
304 | |||
305 | void vorbis_book_clear(codebook *b){ | ||
306 | /* static book is not cleared; we're likely called on the lookup and | ||
307 | the static codebook belongs to the info struct */ | ||
308 | if(b->valuelist)_ogg_free(b->valuelist); | ||
309 | if(b->codelist)_ogg_free(b->codelist); | ||
310 | |||
311 | if(b->dec_index)_ogg_free(b->dec_index); | ||
312 | if(b->dec_codelengths)_ogg_free(b->dec_codelengths); | ||
313 | if(b->dec_firsttable)_ogg_free(b->dec_firsttable); | ||
314 | |||
315 | memset(b,0,sizeof(*b)); | ||
316 | } | ||
317 | |||
318 | static ogg_uint32_t bitreverse(ogg_uint32_t x){ | ||
319 | x= ((x>>16)&0x0000ffffUL) | ((x<<16)&0xffff0000UL); | ||
320 | x= ((x>> 8)&0x00ff00ffUL) | ((x<< 8)&0xff00ff00UL); | ||
321 | x= ((x>> 4)&0x0f0f0f0fUL) | ((x<< 4)&0xf0f0f0f0UL); | ||
322 | x= ((x>> 2)&0x33333333UL) | ((x<< 2)&0xccccccccUL); | ||
323 | return((x>> 1)&0x55555555UL) | ((x<< 1)&0xaaaaaaaaUL); | ||
324 | } | ||
325 | |||
326 | static int sort32a(const void *a,const void *b){ | ||
327 | return (**(ogg_uint32_t **)a>**(ogg_uint32_t **)b)- | ||
328 | (**(ogg_uint32_t **)a<**(ogg_uint32_t **)b); | ||
329 | } | ||
330 | |||
331 | /* decode codebook arrangement is more heavily optimized than encode */ | ||
332 | int vorbis_book_init_decode(codebook *c,const static_codebook *s){ | ||
333 | int i,j,n=0,tabn; | ||
334 | int *sortindex; | ||
335 | memset(c,0,sizeof(*c)); | ||
336 | |||
337 | /* count actually used entries */ | ||
338 | for(i=0;i<s->entries;i++) | ||
339 | if(s->lengthlist[i]>0) | ||
340 | n++; | ||
341 | |||
342 | c->entries=s->entries; | ||
343 | c->used_entries=n; | ||
344 | c->dim=s->dim; | ||
345 | |||
346 | if(n>0){ | ||
347 | /* two different remappings go on here. | ||
348 | |||
349 | First, we collapse the likely sparse codebook down only to | ||
350 | actually represented values/words. This collapsing needs to be | ||
351 | indexed as map-valueless books are used to encode original entry | ||
352 | positions as integers. | ||
353 | |||
354 | Second, we reorder all vectors, including the entry index above, | ||
355 | by sorted bitreversed codeword to allow treeless decode. */ | ||
356 | |||
357 | /* perform sort */ | ||
358 | ogg_uint32_t *codes=_make_words(s->lengthlist,s->entries,c->used_entries); | ||
359 | ogg_uint32_t **codep=(ogg_uint32_t **)_ogg_malloc(sizeof(*codep)*n); | ||
360 | |||
361 | if(codes==NULL||codep==NULL){ | ||
362 | _ogg_free(codep); | ||
363 | _ogg_free(codes); | ||
364 | goto err_out; | ||
365 | } | ||
366 | |||
367 | for(i=0;i<n;i++){ | ||
368 | codes[i]=bitreverse(codes[i]); | ||
369 | codep[i]=codes+i; | ||
370 | } | ||
371 | |||
372 | qsort(codep,n,sizeof(*codep),sort32a); | ||
373 | |||
374 | sortindex=(int *)_ogg_malloc(n*sizeof(*sortindex)); | ||
375 | c->codelist=(ogg_uint32_t *)_ogg_malloc(n*sizeof(*c->codelist)); | ||
376 | /* the index is a reverse index */ | ||
377 | for(i=0;i<n;i++){ | ||
378 | int position=codep[i]-codes; | ||
379 | sortindex[position]=i; | ||
380 | } | ||
381 | |||
382 | for(i=0;i<n;i++) | ||
383 | c->codelist[sortindex[i]]=codes[i]; | ||
384 | _ogg_free(codep); | ||
385 | _ogg_free(codes); | ||
386 | |||
387 | |||
388 | |||
389 | c->valuelist=_book_unquantize(s,n,sortindex,&c->binarypoint); | ||
390 | c->dec_index=(int *)_ogg_malloc(n*sizeof(*c->dec_index)); | ||
391 | |||
392 | for(n=0,i=0;i<s->entries;i++) | ||
393 | if(s->lengthlist[i]>0) | ||
394 | c->dec_index[sortindex[n++]]=i; | ||
395 | |||
396 | c->dec_codelengths=(char *)_ogg_malloc(n*sizeof(*c->dec_codelengths)); | ||
397 | for(n=0,i=0;i<s->entries;i++) | ||
398 | if(s->lengthlist[i]>0) | ||
399 | c->dec_codelengths[sortindex[n++]]=s->lengthlist[i]; | ||
400 | |||
401 | _ogg_free(sortindex); | ||
402 | /* Use a larger cache size when we have a large codec buffer, helps decoding | ||
403 | speed especially on targets with slow memory and high bitrate files */ | ||
404 | #if CODEC_SIZE < 0x100000 | ||
405 | c->dec_firsttablen=_ilog(c->used_entries)-4; /* this is magic */ | ||
406 | #else | ||
407 | c->dec_firsttablen=_ilog(c->used_entries)+1; /* this is magic */ | ||
408 | #endif | ||
409 | if(c->dec_firsttablen<5)c->dec_firsttablen=5; | ||
410 | if(c->dec_firsttablen>8)c->dec_firsttablen=8; | ||
411 | |||
412 | tabn=1<<c->dec_firsttablen; | ||
413 | c->dec_firsttable=(ogg_uint32_t *)_ogg_calloc(tabn,sizeof(*c->dec_firsttable)); | ||
414 | c->dec_maxlength=0; | ||
415 | |||
416 | for(i=0;i<n;i++){ | ||
417 | if(c->dec_maxlength<c->dec_codelengths[i]) | ||
418 | c->dec_maxlength=c->dec_codelengths[i]; | ||
419 | if(c->dec_codelengths[i]<=c->dec_firsttablen){ | ||
420 | ogg_uint32_t orig=bitreverse(c->codelist[i]); | ||
421 | for(j=0;j<(1<<(c->dec_firsttablen-c->dec_codelengths[i]));j++) | ||
422 | c->dec_firsttable[orig|(j<<c->dec_codelengths[i])]=i+1; | ||
423 | } | ||
424 | } | ||
425 | |||
426 | /* now fill in 'unused' entries in the firsttable with hi/lo search | ||
427 | hints for the non-direct-hits */ | ||
428 | { | ||
429 | ogg_uint32_t mask=0xfffffffeUL<<(31-c->dec_firsttablen); | ||
430 | long lo=0,hi=0; | ||
431 | |||
432 | for(i=0;i<tabn;i++){ | ||
433 | ogg_uint32_t word=i<<(32-c->dec_firsttablen); | ||
434 | if(c->dec_firsttable[bitreverse(word)]==0){ | ||
435 | while((lo+1)<n && c->codelist[lo+1]<=word)lo++; | ||
436 | while( hi<n && word>=(c->codelist[hi]&mask))hi++; | ||
437 | |||
438 | /* we only actually have 15 bits per hint to play with here. | ||
439 | In order to overflow gracefully (nothing breaks, efficiency | ||
440 | just drops), encode as the difference from the extremes. */ | ||
441 | { | ||
442 | unsigned long loval=lo; | ||
443 | unsigned long hival=n-hi; | ||
444 | |||
445 | if(loval>0x7fff)loval=0x7fff; | ||
446 | if(hival>0x7fff)hival=0x7fff; | ||
447 | c->dec_firsttable[bitreverse(word)]= | ||
448 | 0x80000000UL | (loval<<15) | hival; | ||
449 | } | ||
450 | } | ||
451 | } | ||
452 | } | ||
453 | } | ||
454 | |||
455 | return(0); | ||
456 | err_out: | ||
457 | vorbis_book_clear(c); | ||
458 | return(-1); | ||
459 | } | ||
460 | |||
diff --git a/lib/rbcodec/codecs/libtremor/synthesis.c b/lib/rbcodec/codecs/libtremor/synthesis.c new file mode 100644 index 0000000000..d1ef99ae37 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/synthesis.c | |||
@@ -0,0 +1,129 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: single-block PCM synthesis | ||
15 | last mod: $Id$ | ||
16 | |||
17 | ********************************************************************/ | ||
18 | |||
19 | #include <stdio.h> | ||
20 | #include "ogg.h" | ||
21 | #include "ivorbiscodec.h" | ||
22 | #include "codec_internal.h" | ||
23 | #include "registry.h" | ||
24 | #include "misc.h" | ||
25 | #include "os.h" | ||
26 | |||
27 | |||
28 | static inline int _vorbis_synthesis1(vorbis_block *vb,ogg_packet *op,int decodep){ | ||
29 | vorbis_dsp_state *vd= vb ? vb->vd : 0; | ||
30 | private_state *b= vd ? (private_state *)vd->backend_state: 0; | ||
31 | vorbis_info *vi= vd ? vd->vi : 0; | ||
32 | codec_setup_info *ci= vi ? (codec_setup_info *)vi->codec_setup : 0; | ||
33 | oggpack_buffer *opb=vb ? &vb->opb : 0; | ||
34 | int type,mode; | ||
35 | |||
36 | if (!vd || !b || !vi || !ci || !opb) { | ||
37 | return OV_EBADPACKET; | ||
38 | } | ||
39 | |||
40 | /* first things first. Make sure decode is ready */ | ||
41 | _vorbis_block_ripcord(vb); | ||
42 | oggpack_readinit(opb,op->packet,op->bytes); | ||
43 | |||
44 | /* Check the packet type */ | ||
45 | if(oggpack_read(opb,1)!=0){ | ||
46 | /* Oops. This is not an audio data packet */ | ||
47 | return(OV_ENOTAUDIO); | ||
48 | } | ||
49 | |||
50 | /* read our mode and pre/post windowsize */ | ||
51 | mode=oggpack_read(opb,b->modebits); | ||
52 | if(mode==-1)return(OV_EBADPACKET); | ||
53 | |||
54 | vb->mode=mode; | ||
55 | if(!ci->mode_param[mode]){ | ||
56 | return(OV_EBADPACKET); | ||
57 | } | ||
58 | |||
59 | vb->W=ci->mode_param[mode]->blockflag; | ||
60 | if(vb->W){ | ||
61 | vb->lW=oggpack_read(opb,1); | ||
62 | vb->nW=oggpack_read(opb,1); | ||
63 | if(vb->nW==-1) return(OV_EBADPACKET); | ||
64 | }else{ | ||
65 | vb->lW=0; | ||
66 | vb->nW=0; | ||
67 | } | ||
68 | |||
69 | /* more setup */ | ||
70 | vb->granulepos=op->granulepos; | ||
71 | vb->sequence=op->packetno-3; /* first block is third packet */ | ||
72 | vb->eofflag=op->e_o_s; | ||
73 | |||
74 | if(decodep && vi->channels<=CHANNELS) | ||
75 | { | ||
76 | /* set pcm end point */ | ||
77 | vb->pcmend=ci->blocksizes[vb->W]; | ||
78 | |||
79 | /* unpack_header enforces range checking */ | ||
80 | type=ci->map_type[ci->mode_param[mode]->mapping]; | ||
81 | return(_mapping_P[type]->inverse(vb,b->mode[mode])); | ||
82 | }else{ | ||
83 | /* no pcm */ | ||
84 | vb->pcmend=0; | ||
85 | return(0); | ||
86 | } | ||
87 | } | ||
88 | |||
89 | int vorbis_synthesis(vorbis_block *vb,ogg_packet *op) | ||
90 | ICODE_ATTR_TREMOR_NOT_MDCT; | ||
91 | int vorbis_synthesis(vorbis_block *vb,ogg_packet *op){ | ||
92 | return _vorbis_synthesis1(vb,op,1); | ||
93 | } | ||
94 | |||
95 | /* used to track pcm position without actually performing decode. | ||
96 | Useful for sequential 'fast forward' */ | ||
97 | int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op){ | ||
98 | return _vorbis_synthesis1(vb,op,0); | ||
99 | } | ||
100 | |||
101 | long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op){ | ||
102 | codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; | ||
103 | oggpack_buffer opb; | ||
104 | int mode; | ||
105 | |||
106 | oggpack_readinit(&opb,op->packet,op->bytes); | ||
107 | |||
108 | /* Check the packet type */ | ||
109 | if(oggpack_read(&opb,1)!=0){ | ||
110 | /* Oops. This is not an audio data packet */ | ||
111 | return(OV_ENOTAUDIO); | ||
112 | } | ||
113 | |||
114 | { | ||
115 | int modebits=0; | ||
116 | int v=ci->modes; | ||
117 | while(v>1){ | ||
118 | modebits++; | ||
119 | v>>=1; | ||
120 | } | ||
121 | |||
122 | /* read our mode and pre/post windowsize */ | ||
123 | mode=oggpack_read(&opb,modebits); | ||
124 | } | ||
125 | if(mode==-1)return(OV_EBADPACKET); | ||
126 | return(ci->blocksizes[ci->mode_param[mode]->blockflag]); | ||
127 | } | ||
128 | |||
129 | |||
diff --git a/lib/rbcodec/codecs/libtremor/vorbisfile.c b/lib/rbcodec/codecs/libtremor/vorbisfile.c new file mode 100644 index 0000000000..271e5a09e3 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/vorbisfile.c | |||
@@ -0,0 +1,1671 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: stdio-based convenience library for opening/seeking/decoding | ||
15 | last mod: $Id$ | ||
16 | |||
17 | ********************************************************************/ | ||
18 | |||
19 | #include "config-tremor.h" | ||
20 | #include <stdio.h> | ||
21 | #include <errno.h> | ||
22 | #include <string.h> | ||
23 | #include <math.h> | ||
24 | #include "system.h" | ||
25 | |||
26 | #include "ivorbiscodec.h" | ||
27 | #include "ivorbisfile.h" | ||
28 | |||
29 | #include "os.h" | ||
30 | #include "misc.h" | ||
31 | |||
32 | /* A 'chained bitstream' is a Vorbis bitstream that contains more than | ||
33 | one logical bitstream arranged end to end (the only form of Ogg | ||
34 | multiplexing allowed in a Vorbis bitstream; grouping [parallel | ||
35 | multiplexing] is not allowed in Vorbis) */ | ||
36 | |||
37 | /* A Vorbis file can be played beginning to end (streamed) without | ||
38 | worrying ahead of time about chaining (see decoder_example.c). If | ||
39 | we have the whole file, however, and want random access | ||
40 | (seeking/scrubbing) or desire to know the total length/time of a | ||
41 | file, we need to account for the possibility of chaining. */ | ||
42 | |||
43 | /* We can handle things a number of ways; we can determine the entire | ||
44 | bitstream structure right off the bat, or find pieces on demand. | ||
45 | This example determines and caches structure for the entire | ||
46 | bitstream, but builds a virtual decoder on the fly when moving | ||
47 | between links in the chain. */ | ||
48 | |||
49 | /* There are also different ways to implement seeking. Enough | ||
50 | information exists in an Ogg bitstream to seek to | ||
51 | sample-granularity positions in the output. Or, one can seek by | ||
52 | picking some portion of the stream roughly in the desired area if | ||
53 | we only want coarse navigation through the stream. */ | ||
54 | |||
55 | /************************************************************************* | ||
56 | * Many, many internal helpers. The intention is not to be confusing; | ||
57 | * rampant duplication and monolithic function implementation would be | ||
58 | * harder to understand anyway. The high level functions are last. Begin | ||
59 | * grokking near the end of the file */ | ||
60 | |||
61 | |||
62 | /* read a little more data from the file/pipe into the ogg_sync framer */ | ||
63 | static long _get_data(OggVorbis_File *vf){ | ||
64 | if(!(vf->callbacks.read_func))return(-1); | ||
65 | if(vf->datasource){ | ||
66 | char *buffer=ogg_sync_buffer(&vf->oy,CHUNKSIZE); | ||
67 | long bytes=(vf->callbacks.read_func)(buffer,1,CHUNKSIZE,vf->datasource); | ||
68 | if(bytes>0)ogg_sync_wrote(&vf->oy,bytes); | ||
69 | return(bytes); | ||
70 | }else | ||
71 | return(0); | ||
72 | } | ||
73 | |||
74 | /* save a tiny smidge of verbosity to make the code more readable */ | ||
75 | static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){ | ||
76 | if(vf->datasource){ | ||
77 | if(!(vf->callbacks.seek_func)|| | ||
78 | (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1) | ||
79 | return OV_EREAD; | ||
80 | vf->offset=offset; | ||
81 | ogg_sync_reset(&vf->oy); | ||
82 | }else{ | ||
83 | /* shouldn't happen unless someone writes a broken callback */ | ||
84 | return OV_EFAULT; | ||
85 | } | ||
86 | return 0; | ||
87 | } | ||
88 | |||
89 | /* The read/seek functions track absolute position within the stream */ | ||
90 | |||
91 | /* from the head of the stream, get the next page. boundary specifies | ||
92 | if the function is allowed to fetch more data from the stream (and | ||
93 | how much) or only use internally buffered data. | ||
94 | |||
95 | boundary: -1) unbounded search | ||
96 | 0) read no additional data; use cached only | ||
97 | n) search for a new page beginning for n bytes | ||
98 | |||
99 | return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD) | ||
100 | n) found a page at absolute offset n */ | ||
101 | |||
102 | static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og, | ||
103 | ogg_int64_t boundary){ | ||
104 | if(boundary>0)boundary+=vf->offset; | ||
105 | while(1){ | ||
106 | long more; | ||
107 | |||
108 | if(boundary>0 && vf->offset>=boundary)return(OV_FALSE); | ||
109 | more=ogg_sync_pageseek(&vf->oy,og); | ||
110 | |||
111 | if(more<0){ | ||
112 | /* skipped n bytes */ | ||
113 | vf->offset-=more; | ||
114 | }else{ | ||
115 | if(more==0){ | ||
116 | /* send more paramedics */ | ||
117 | if(!boundary)return(OV_FALSE); | ||
118 | { | ||
119 | long ret=_get_data(vf); | ||
120 | if(ret==0)return(OV_EOF); | ||
121 | if(ret<0)return(OV_EREAD); | ||
122 | } | ||
123 | }else{ | ||
124 | /* got a page. Return the offset at the page beginning, | ||
125 | advance the internal offset past the page end */ | ||
126 | ogg_int64_t ret=vf->offset; | ||
127 | vf->offset+=more; | ||
128 | return(ret); | ||
129 | |||
130 | } | ||
131 | } | ||
132 | } | ||
133 | } | ||
134 | |||
135 | /* This is a nasty hack to work around the huge allocations we get from | ||
136 | huge comment packets, usually due to embedded album art */ | ||
137 | static int ogg_stream_discard_packet(OggVorbis_File *vf,ogg_page *og, | ||
138 | ogg_int64_t boundary){ | ||
139 | int ret; | ||
140 | while((ret = ogg_stream_packetout(&vf->os, NULL)) == 0) { | ||
141 | if(_get_next_page(vf, og, boundary)<0) | ||
142 | break; | ||
143 | ogg_stream_pagein(&vf->os,og,false); | ||
144 | } | ||
145 | if (ret < 0) | ||
146 | return -1; | ||
147 | /* We might be pretending to have filled in more of the buffer than there is | ||
148 | actual space, in this case the body storage must be expanded before we | ||
149 | start writing to it */ | ||
150 | if (vf->os.body_fill < og->body_len || vf->os.body_storage < vf->os.body_fill) | ||
151 | if(_os_body_expand(&vf->os, vf->os.body_fill - vf->os.body_storage + og->body_len)) | ||
152 | return -1; | ||
153 | memcpy(vf->os.body_data+vf->os.body_fill-og->body_len, og->body, og->body_len); | ||
154 | return 1; | ||
155 | } | ||
156 | |||
157 | /* find the latest page beginning before the current stream cursor | ||
158 | position. Much dirtier than the above as Ogg doesn't have any | ||
159 | backward search linkage. no 'readp' as it will certainly have to | ||
160 | read. */ | ||
161 | /* returns offset or OV_EREAD, OV_FAULT */ | ||
162 | static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){ | ||
163 | ogg_int64_t begin=vf->offset; | ||
164 | ogg_int64_t end=begin; | ||
165 | ogg_int64_t ret; | ||
166 | ogg_int64_t offset=-1; | ||
167 | |||
168 | while(offset==-1){ | ||
169 | begin-=CHUNKSIZE; | ||
170 | if(begin<0) | ||
171 | begin=0; | ||
172 | |||
173 | ret=_seek_helper(vf,begin); | ||
174 | if(ret)return(ret); | ||
175 | |||
176 | while(vf->offset<end){ | ||
177 | memset(og,0,sizeof(*og)); | ||
178 | ret=_get_next_page(vf,og,end-vf->offset); | ||
179 | if(ret==OV_EREAD)return(OV_EREAD); | ||
180 | if(ret<0){ | ||
181 | break; | ||
182 | }else{ | ||
183 | offset=ret; | ||
184 | } | ||
185 | } | ||
186 | } | ||
187 | |||
188 | /* In a fully compliant, non-multiplexed stream, we'll still be | ||
189 | holding the last page. In multiplexed (or noncompliant streams), | ||
190 | we will probably have to re-read the last page we saw */ | ||
191 | if(og->header_len==0){ | ||
192 | ret=_seek_helper(vf,offset); | ||
193 | if(ret)return(ret); | ||
194 | |||
195 | ret=_get_next_page(vf,og,CHUNKSIZE); | ||
196 | if(ret<0) | ||
197 | /* this shouldn't be possible */ | ||
198 | return(OV_EFAULT); | ||
199 | } | ||
200 | |||
201 | return(offset); | ||
202 | } | ||
203 | |||
204 | static void _add_serialno(ogg_page *og,ogg_uint32_t **serialno_list, int *n){ | ||
205 | long s = ogg_page_serialno(og); | ||
206 | (*n)++; | ||
207 | |||
208 | if(*serialno_list){ | ||
209 | *serialno_list = _ogg_realloc(*serialno_list, sizeof(**serialno_list)*(*n)); | ||
210 | }else{ | ||
211 | *serialno_list = _ogg_malloc(sizeof(**serialno_list)); | ||
212 | } | ||
213 | |||
214 | (*serialno_list)[(*n)-1] = s; | ||
215 | } | ||
216 | |||
217 | /* returns nonzero if found */ | ||
218 | static int _lookup_serialno(ogg_uint32_t s, ogg_uint32_t *serialno_list, int n){ | ||
219 | if(serialno_list){ | ||
220 | while(n--){ | ||
221 | if(*serialno_list == (ogg_uint32_t) s) return 1; | ||
222 | serialno_list++; | ||
223 | } | ||
224 | } | ||
225 | return 0; | ||
226 | } | ||
227 | |||
228 | static int _lookup_page_serialno(ogg_page *og, ogg_uint32_t *serialno_list, int n){ | ||
229 | ogg_uint32_t s = ogg_page_serialno(og); | ||
230 | return _lookup_serialno(s,serialno_list,n); | ||
231 | } | ||
232 | |||
233 | /* performs the same search as _get_prev_page, but prefers pages of | ||
234 | the specified serial number. If a page of the specified serialno is | ||
235 | spotted during the seek-back-and-read-forward, it will return the | ||
236 | info of last page of the matching serial number instead of the very | ||
237 | last page. If no page of the specified serialno is seen, it will | ||
238 | return the info of last page and alter *serialno. */ | ||
239 | static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf, | ||
240 | ogg_uint32_t *serial_list, int serial_n, | ||
241 | int *serialno, ogg_int64_t *granpos){ | ||
242 | ogg_page og; | ||
243 | ogg_int64_t begin=vf->offset; | ||
244 | ogg_int64_t end=begin; | ||
245 | ogg_int64_t ret; | ||
246 | |||
247 | ogg_int64_t prefoffset=-1; | ||
248 | ogg_int64_t offset=-1; | ||
249 | ogg_int64_t ret_serialno=-1; | ||
250 | ogg_int64_t ret_gran=-1; | ||
251 | |||
252 | while(offset==-1){ | ||
253 | begin-=CHUNKSIZE; | ||
254 | if(begin<0) | ||
255 | begin=0; | ||
256 | |||
257 | ret=_seek_helper(vf,begin); | ||
258 | if(ret)return(ret); | ||
259 | |||
260 | while(vf->offset<end){ | ||
261 | ret=_get_next_page(vf,&og,end-vf->offset); | ||
262 | if(ret==OV_EREAD)return(OV_EREAD); | ||
263 | if(ret<0){ | ||
264 | break; | ||
265 | }else{ | ||
266 | ret_serialno=ogg_page_serialno(&og); | ||
267 | ret_gran=ogg_page_granulepos(&og); | ||
268 | offset=ret; | ||
269 | |||
270 | if((ogg_uint32_t)ret_serialno == (ogg_uint32_t)*serialno){ | ||
271 | prefoffset=ret; | ||
272 | *granpos=ret_gran; | ||
273 | } | ||
274 | |||
275 | if(!_lookup_serialno((ogg_uint32_t)ret_serialno,serial_list,serial_n)){ | ||
276 | /* we fell off the end of the link, which means we seeked | ||
277 | back too far and shouldn't have been looking in that link | ||
278 | to begin with. If we found the preferred serial number, | ||
279 | forget that we saw it. */ | ||
280 | prefoffset=-1; | ||
281 | } | ||
282 | } | ||
283 | } | ||
284 | } | ||
285 | |||
286 | /* we're not interested in the page... just the serialno and granpos. */ | ||
287 | if(prefoffset>=0)return(prefoffset); | ||
288 | |||
289 | *serialno = ret_serialno; | ||
290 | *granpos = ret_gran; | ||
291 | return(offset); | ||
292 | |||
293 | } | ||
294 | |||
295 | /* uses the local ogg_stream storage in vf; this is important for | ||
296 | non-streaming input sources */ | ||
297 | static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi, | ||
298 | ogg_uint32_t **serialno_list, int *serialno_n, | ||
299 | ogg_page *og_ptr){ | ||
300 | ogg_page og; | ||
301 | ogg_packet op; | ||
302 | int i,ret; | ||
303 | int allbos=0; | ||
304 | |||
305 | if(!og_ptr){ | ||
306 | ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE); | ||
307 | if(llret==OV_EREAD)return(OV_EREAD); | ||
308 | if(llret<0)return(OV_ENOTVORBIS); | ||
309 | og_ptr=&og; | ||
310 | } | ||
311 | |||
312 | vorbis_info_init(vi); | ||
313 | /* vorbis_comment_init(vc); */ | ||
314 | vf->ready_state=OPENED; | ||
315 | |||
316 | /* extract the serialnos of all BOS pages + the first set of vorbis | ||
317 | headers we see in the link */ | ||
318 | |||
319 | while(ogg_page_bos(og_ptr)){ | ||
320 | if(serialno_list){ | ||
321 | if(_lookup_page_serialno(og_ptr,*serialno_list,*serialno_n)){ | ||
322 | /* a dupe serialnumber in an initial header packet set == invalid stream */ | ||
323 | if(*serialno_list)_ogg_free(*serialno_list); | ||
324 | *serialno_list=0; | ||
325 | *serialno_n=0; | ||
326 | ret=OV_EBADHEADER; | ||
327 | goto bail_header; | ||
328 | } | ||
329 | |||
330 | _add_serialno(og_ptr,serialno_list,serialno_n); | ||
331 | } | ||
332 | |||
333 | if(vf->ready_state<STREAMSET){ | ||
334 | /* we don't have a vorbis stream in this link yet, so begin | ||
335 | prospective stream setup. We need a stream to get packets */ | ||
336 | ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr)); | ||
337 | ogg_stream_pagein(&vf->os,og_ptr,true); | ||
338 | |||
339 | if(ogg_stream_packetout(&vf->os,&op) > 0 && | ||
340 | vorbis_synthesis_idheader(&op)){ | ||
341 | /* vorbis header; continue setup */ | ||
342 | vf->ready_state=STREAMSET; | ||
343 | if((ret=vorbis_synthesis_headerin(vi,&op))){ | ||
344 | ret=OV_EBADHEADER; | ||
345 | goto bail_header; | ||
346 | } | ||
347 | } | ||
348 | } | ||
349 | |||
350 | /* get next page */ | ||
351 | { | ||
352 | ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE); | ||
353 | if(llret==OV_EREAD){ | ||
354 | ret=OV_EREAD; | ||
355 | goto bail_header; | ||
356 | } | ||
357 | if(llret<0){ | ||
358 | ret=OV_ENOTVORBIS; | ||
359 | goto bail_header; | ||
360 | } | ||
361 | |||
362 | /* if this page also belongs to our vorbis stream, submit it and break */ | ||
363 | if(vf->ready_state==STREAMSET && | ||
364 | vf->os.serialno == ogg_page_serialno(og_ptr)){ | ||
365 | ogg_stream_pagein(&vf->os,og_ptr,true); | ||
366 | break; | ||
367 | } | ||
368 | } | ||
369 | } | ||
370 | |||
371 | if(vf->ready_state!=STREAMSET){ | ||
372 | ret = OV_ENOTVORBIS; | ||
373 | goto bail_header; | ||
374 | } | ||
375 | |||
376 | while(1){ | ||
377 | |||
378 | i=0; | ||
379 | /* discard comment packet */ | ||
380 | if(ogg_stream_discard_packet(vf,og_ptr,CHUNKSIZE) < 0){ | ||
381 | ret=OV_EBADHEADER; | ||
382 | goto bail_header; | ||
383 | } | ||
384 | i++; | ||
385 | |||
386 | while(i<2){ /* get a page loop */ | ||
387 | |||
388 | while(i<2){ /* get a packet loop */ | ||
389 | int result=ogg_stream_packetout(&vf->os,&op); | ||
390 | if(result==0)break; | ||
391 | if(result==-1){ | ||
392 | ret=OV_EBADHEADER; | ||
393 | goto bail_header; | ||
394 | } | ||
395 | |||
396 | if((ret=vorbis_synthesis_headerin(vi,&op))) | ||
397 | goto bail_header; | ||
398 | |||
399 | i++; | ||
400 | } | ||
401 | |||
402 | while(i<2){ | ||
403 | if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){ | ||
404 | ret=OV_EBADHEADER; | ||
405 | goto bail_header; | ||
406 | } | ||
407 | |||
408 | /* if this page belongs to the correct stream, go parse it */ | ||
409 | if(vf->os.serialno == ogg_page_serialno(og_ptr)){ | ||
410 | ogg_stream_pagein(&vf->os,og_ptr,true); | ||
411 | break; | ||
412 | } | ||
413 | |||
414 | /* if we never see the final vorbis headers before the link | ||
415 | ends, abort */ | ||
416 | if(ogg_page_bos(og_ptr)){ | ||
417 | if(allbos){ | ||
418 | ret = OV_EBADHEADER; | ||
419 | goto bail_header; | ||
420 | }else | ||
421 | allbos=1; | ||
422 | } | ||
423 | |||
424 | /* otherwise, keep looking */ | ||
425 | } | ||
426 | } | ||
427 | |||
428 | return 0; | ||
429 | } | ||
430 | |||
431 | bail_header: | ||
432 | vorbis_info_clear(vi); | ||
433 | /* vorbis_comment_clear(vc); */ | ||
434 | vf->ready_state=OPENED; | ||
435 | |||
436 | return ret; | ||
437 | } | ||
438 | |||
439 | /* Starting from current cursor position, get initial PCM offset of | ||
440 | next page. Consumes the page in the process without decoding | ||
441 | audio, however this is only called during stream parsing upon | ||
442 | seekable open. */ | ||
443 | static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){ | ||
444 | ogg_page og; | ||
445 | ogg_int64_t accumulated=0; | ||
446 | long lastblock=-1; | ||
447 | int result; | ||
448 | ogg_uint32_t serialno = vf->os.serialno; | ||
449 | |||
450 | while(1){ | ||
451 | ogg_packet op; | ||
452 | if(_get_next_page(vf,&og,-1)<0) | ||
453 | break; /* should not be possible unless the file is truncated/mangled */ | ||
454 | |||
455 | if(ogg_page_bos(&og)) break; | ||
456 | if(ogg_page_serialno(&og)!= serialno) continue; | ||
457 | |||
458 | /* count blocksizes of all frames in the page */ | ||
459 | ogg_stream_pagein(&vf->os,&og,true); | ||
460 | while((result=ogg_stream_packetout(&vf->os,&op))){ | ||
461 | if(result>0){ /* ignore holes */ | ||
462 | long thisblock=vorbis_packet_blocksize(vi,&op); | ||
463 | if(lastblock!=-1) | ||
464 | accumulated+=(lastblock+thisblock)>>2; | ||
465 | lastblock=thisblock; | ||
466 | } | ||
467 | } | ||
468 | |||
469 | if(ogg_page_granulepos(&og)!=-1){ | ||
470 | /* pcm offset of last packet on the first audio page */ | ||
471 | accumulated= ogg_page_granulepos(&og)-accumulated; | ||
472 | break; | ||
473 | } | ||
474 | } | ||
475 | |||
476 | /* less than zero? This is a stream with samples trimmed off | ||
477 | the beginning, a normal occurrence; set the offset to zero */ | ||
478 | if(accumulated<0)accumulated=0; | ||
479 | |||
480 | return accumulated; | ||
481 | } | ||
482 | |||
483 | /* finds each bitstream link one at a time using a bisection search | ||
484 | (has to begin by knowing the offset of the lb's initial page). | ||
485 | Recurses for each link so it can alloc the link storage after | ||
486 | finding them all, then unroll and fill the cache at the same time */ | ||
487 | static int _bisect_forward_serialno(OggVorbis_File *vf, | ||
488 | ogg_int64_t begin, | ||
489 | ogg_int64_t searched, | ||
490 | ogg_int64_t end, | ||
491 | ogg_int64_t endgran, | ||
492 | int endserial, | ||
493 | ogg_uint32_t *currentno_list, | ||
494 | int currentnos, | ||
495 | long m){ | ||
496 | ogg_int64_t pcmoffset; | ||
497 | ogg_int64_t dataoffset=searched; | ||
498 | ogg_int64_t endsearched=end; | ||
499 | ogg_int64_t next=end; | ||
500 | ogg_int64_t searchgran=-1; | ||
501 | ogg_page og; | ||
502 | ogg_int64_t ret,last; | ||
503 | int serialno = vf->os.serialno; | ||
504 | |||
505 | /* invariants: | ||
506 | we have the headers and serialnos for the link beginning at 'begin' | ||
507 | we have the offset and granpos of the last page in the file (potentially | ||
508 | not a page we care about) | ||
509 | */ | ||
510 | |||
511 | /* Is the last page in our list of current serialnumbers? */ | ||
512 | if(_lookup_serialno(endserial,currentno_list,currentnos)){ | ||
513 | |||
514 | /* last page is in the starting serialno list, so we've bisected | ||
515 | down to (or just started with) a single link. Now we need to | ||
516 | find the last vorbis page belonging to the first vorbis stream | ||
517 | for this link. */ | ||
518 | |||
519 | while(endserial != serialno){ | ||
520 | endserial = serialno; | ||
521 | vf->offset=_get_prev_page_serial(vf,currentno_list,currentnos,&endserial,&endgran); | ||
522 | } | ||
523 | |||
524 | vf->links=m+1; | ||
525 | if(vf->offsets)_ogg_free(vf->offsets); | ||
526 | if(vf->serialnos)_ogg_free(vf->serialnos); | ||
527 | if(vf->dataoffsets)_ogg_free(vf->dataoffsets); | ||
528 | |||
529 | vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets)); | ||
530 | vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi)); | ||
531 | /* vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));*/ | ||
532 | vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos)); | ||
533 | vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets)); | ||
534 | vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths)); | ||
535 | |||
536 | vf->offsets[m+1]=end; | ||
537 | vf->offsets[m]=begin; | ||
538 | vf->pcmlengths[m*2+1]=endgran; | ||
539 | |||
540 | }else{ | ||
541 | |||
542 | ogg_uint32_t *next_serialno_list=NULL; | ||
543 | int next_serialnos=0; | ||
544 | vorbis_info vi; | ||
545 | /* vorbis_comment vc; */ | ||
546 | |||
547 | /* the below guards against garbage seperating the last and | ||
548 | first pages of two links. */ | ||
549 | while(searched<endsearched){ | ||
550 | ogg_int64_t bisect; | ||
551 | |||
552 | if(endsearched-searched<CHUNKSIZE){ | ||
553 | bisect=searched; | ||
554 | }else{ | ||
555 | bisect=(searched+endsearched)/2; | ||
556 | } | ||
557 | |||
558 | if(bisect != vf->offset){ | ||
559 | ret=_seek_helper(vf,bisect); | ||
560 | if(ret)return(ret); | ||
561 | } | ||
562 | |||
563 | last=_get_next_page(vf,&og,-1); | ||
564 | if(last==OV_EREAD)return(OV_EREAD); | ||
565 | if(last<0 || !_lookup_page_serialno(&og,currentno_list,currentnos)){ | ||
566 | endsearched=bisect; | ||
567 | if(last>=0)next=last; | ||
568 | }else{ | ||
569 | searched=vf->offset; | ||
570 | } | ||
571 | } | ||
572 | |||
573 | /* Bisection point found */ | ||
574 | |||
575 | /* for the time being, fetch end PCM offset the simple way */ | ||
576 | { | ||
577 | int testserial = serialno+1; | ||
578 | vf->offset = next; | ||
579 | while(testserial != serialno){ | ||
580 | testserial = serialno; | ||
581 | vf->offset=_get_prev_page_serial(vf,currentno_list,currentnos,&testserial,&searchgran); | ||
582 | } | ||
583 | } | ||
584 | |||
585 | if(vf->offset!=next){ | ||
586 | ret=_seek_helper(vf,next); | ||
587 | if(ret)return(ret); | ||
588 | } | ||
589 | |||
590 | ret=_fetch_headers(vf,&vi,&next_serialno_list,&next_serialnos,NULL); | ||
591 | if(ret)return(ret); | ||
592 | serialno = vf->os.serialno; | ||
593 | dataoffset = vf->offset; | ||
594 | |||
595 | /* this will consume a page, however the next bistection always | ||
596 | starts with a raw seek */ | ||
597 | pcmoffset = _initial_pcmoffset(vf,&vi); | ||
598 | |||
599 | ret=_bisect_forward_serialno(vf,next,vf->offset,end,endgran,endserial, | ||
600 | next_serialno_list,next_serialnos,m+1); | ||
601 | if(ret)return(ret); | ||
602 | |||
603 | if(next_serialno_list)_ogg_free(next_serialno_list); | ||
604 | |||
605 | vf->offsets[m+1]=next; | ||
606 | vf->serialnos[m+1]=serialno; | ||
607 | vf->dataoffsets[m+1]=dataoffset; | ||
608 | |||
609 | vf->vi[m+1]=vi; | ||
610 | /* vf->vc[m+1]=vc; */ | ||
611 | |||
612 | vf->pcmlengths[m*2+1]=searchgran; | ||
613 | vf->pcmlengths[m*2+2]=pcmoffset; | ||
614 | vf->pcmlengths[m*2+3]-=pcmoffset; | ||
615 | |||
616 | } | ||
617 | return(0); | ||
618 | } | ||
619 | |||
620 | static int _make_decode_ready(OggVorbis_File *vf){ | ||
621 | if(vf->ready_state>STREAMSET)return 0; | ||
622 | if(vf->ready_state<STREAMSET)return OV_EFAULT; | ||
623 | if(vf->seekable){ | ||
624 | if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link)) | ||
625 | return OV_EBADLINK; | ||
626 | }else{ | ||
627 | if(vorbis_synthesis_init(&vf->vd,vf->vi)) | ||
628 | return OV_EBADLINK; | ||
629 | } | ||
630 | vorbis_block_init(&vf->vd,&vf->vb); | ||
631 | vf->ready_state=INITSET; | ||
632 | vf->bittrack=0; | ||
633 | vf->samptrack=0; | ||
634 | return 0; | ||
635 | } | ||
636 | |||
637 | static int _open_seekable2(OggVorbis_File *vf){ | ||
638 | ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1; | ||
639 | int endserial=vf->os.serialno; | ||
640 | int serialno=vf->os.serialno; | ||
641 | |||
642 | /* we're partially open and have a first link header state in | ||
643 | storage in vf */ | ||
644 | |||
645 | /* fetch initial PCM offset */ | ||
646 | ogg_int64_t pcmoffset = _initial_pcmoffset(vf,vf->vi); | ||
647 | |||
648 | /* we can seek, so set out learning all about this file */ | ||
649 | if(vf->callbacks.seek_func && vf->callbacks.tell_func){ | ||
650 | (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END); | ||
651 | vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource); | ||
652 | }else{ | ||
653 | vf->offset=vf->end=-1; | ||
654 | } | ||
655 | |||
656 | /* If seek_func is implemented, tell_func must also be implemented */ | ||
657 | if(vf->end==-1) return(OV_EINVAL); | ||
658 | |||
659 | /* Get the offset of the last page of the physical bitstream, or, if | ||
660 | we're lucky the last vorbis page of this link as most OggVorbis | ||
661 | files will contain a single logical bitstream */ | ||
662 | end=_get_prev_page_serial(vf,vf->serialnos+2,vf->serialnos[1],&endserial,&endgran); | ||
663 | if(end<0)return(end); | ||
664 | |||
665 | /* now determine bitstream structure recursively */ | ||
666 | if(_bisect_forward_serialno(vf,0,dataoffset,vf->offset,endgran,endserial, | ||
667 | vf->serialnos+2,vf->serialnos[1],0)<0)return(OV_EREAD); | ||
668 | |||
669 | vf->offsets[0]=0; | ||
670 | vf->serialnos[0]=serialno; | ||
671 | vf->dataoffsets[0]=dataoffset; | ||
672 | vf->pcmlengths[0]=pcmoffset; | ||
673 | vf->pcmlengths[1]-=pcmoffset; | ||
674 | |||
675 | return(ov_raw_seek(vf,dataoffset)); | ||
676 | } | ||
677 | |||
678 | /* clear out the current logical bitstream decoder */ | ||
679 | static void _decode_clear(OggVorbis_File *vf){ | ||
680 | vorbis_dsp_clear(&vf->vd); | ||
681 | vorbis_block_clear(&vf->vb); | ||
682 | vf->ready_state=OPENED; | ||
683 | } | ||
684 | |||
685 | /* fetch and process a packet. Handles the case where we're at a | ||
686 | bitstream boundary and dumps the decoding machine. If the decoding | ||
687 | machine is unloaded, it loads it. It also keeps pcm_offset up to | ||
688 | date (seek and read both use this. seek uses a special hack with | ||
689 | readp). | ||
690 | |||
691 | return: <0) error, OV_HOLE (lost packet) or OV_EOF | ||
692 | 0) need more data (only if readp==0) | ||
693 | 1) got a packet | ||
694 | */ | ||
695 | |||
696 | static int _fetch_and_process_packet(OggVorbis_File *vf, | ||
697 | ogg_packet *op_in, | ||
698 | int readp, | ||
699 | int spanp){ | ||
700 | ogg_page og; | ||
701 | |||
702 | /* handle one packet. Try to fetch it from current stream state */ | ||
703 | /* extract packets from page */ | ||
704 | while(1){ | ||
705 | |||
706 | if(vf->ready_state==STREAMSET){ | ||
707 | int ret=_make_decode_ready(vf); | ||
708 | if(ret<0)return ret; | ||
709 | } | ||
710 | |||
711 | /* process a packet if we can. If the machine isn't loaded, | ||
712 | neither is a page */ | ||
713 | if(vf->ready_state==INITSET){ | ||
714 | while(1) { | ||
715 | ogg_packet op; | ||
716 | ogg_packet *op_ptr=(op_in?op_in:&op); | ||
717 | int result=ogg_stream_packetout(&vf->os,op_ptr); | ||
718 | ogg_int64_t granulepos; | ||
719 | |||
720 | op_in=NULL; | ||
721 | if(result==-1)return(OV_HOLE); /* hole in the data. */ | ||
722 | if(result>0){ | ||
723 | /* got a packet. process it */ | ||
724 | granulepos=op_ptr->granulepos; | ||
725 | if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy | ||
726 | header handling. The | ||
727 | header packets aren't | ||
728 | audio, so if/when we | ||
729 | submit them, | ||
730 | vorbis_synthesis will | ||
731 | reject them */ | ||
732 | |||
733 | /* suck in the synthesis data and track bitrate */ | ||
734 | { | ||
735 | int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL); | ||
736 | /* for proper use of libvorbis within libvorbisfile, | ||
737 | oldsamples will always be zero. */ | ||
738 | if(oldsamples)return(OV_EFAULT); | ||
739 | |||
740 | vorbis_synthesis_blockin(&vf->vd,&vf->vb); | ||
741 | vf->samptrack+=vorbis_synthesis_pcmout(&vf->vd,NULL)-oldsamples; | ||
742 | vf->bittrack+=op_ptr->bytes*8; | ||
743 | } | ||
744 | |||
745 | /* update the pcm offset. */ | ||
746 | if(granulepos!=-1 && !op_ptr->e_o_s){ | ||
747 | int link=(vf->seekable?vf->current_link:0); | ||
748 | int i,samples; | ||
749 | |||
750 | /* this packet has a pcm_offset on it (the last packet | ||
751 | completed on a page carries the offset) After processing | ||
752 | (above), we know the pcm position of the *last* sample | ||
753 | ready to be returned. Find the offset of the *first* | ||
754 | |||
755 | As an aside, this trick is inaccurate if we begin | ||
756 | reading anew right at the last page; the end-of-stream | ||
757 | granulepos declares the last frame in the stream, and the | ||
758 | last packet of the last page may be a partial frame. | ||
759 | So, we need a previous granulepos from an in-sequence page | ||
760 | to have a reference point. Thus the !op_ptr->e_o_s clause | ||
761 | above */ | ||
762 | |||
763 | if(vf->seekable && link>0) | ||
764 | granulepos-=vf->pcmlengths[link*2]; | ||
765 | if(granulepos<0)granulepos=0; /* actually, this | ||
766 | shouldn't be possible | ||
767 | here unless the stream | ||
768 | is very broken */ | ||
769 | |||
770 | samples=vorbis_synthesis_pcmout(&vf->vd,NULL); | ||
771 | |||
772 | granulepos-=samples; | ||
773 | for(i=0;i<link;i++) | ||
774 | granulepos+=vf->pcmlengths[i*2+1]; | ||
775 | vf->pcm_offset=granulepos; | ||
776 | } | ||
777 | return(1); | ||
778 | } | ||
779 | } | ||
780 | else | ||
781 | break; | ||
782 | } | ||
783 | } | ||
784 | |||
785 | if(vf->ready_state>=OPENED){ | ||
786 | ogg_int64_t ret; | ||
787 | |||
788 | while(1){ | ||
789 | /* the loop is not strictly necessary, but there's no sense in | ||
790 | doing the extra checks of the larger loop for the common | ||
791 | case in a multiplexed bistream where the page is simply | ||
792 | part of a different logical bitstream; keep reading until | ||
793 | we get one with the correct serialno */ | ||
794 | |||
795 | if(!readp)return(0); | ||
796 | if((ret=_get_next_page(vf,&og,-1))<0){ | ||
797 | return(OV_EOF); /* eof. leave unitialized */ | ||
798 | } | ||
799 | |||
800 | /* bitrate tracking; add the header's bytes here, the body bytes | ||
801 | are done by packet above */ | ||
802 | vf->bittrack+=og.header_len*8; | ||
803 | |||
804 | if(vf->ready_state==INITSET){ | ||
805 | if(vf->current_serialno!=ogg_page_serialno(&og)){ | ||
806 | |||
807 | /* two possibilities: | ||
808 | 1) our decoding just traversed a bitstream boundary | ||
809 | 2) another stream is multiplexed into this logical section */ | ||
810 | |||
811 | if(ogg_page_bos(&og)){ | ||
812 | /* boundary case */ | ||
813 | if(!spanp) | ||
814 | return(OV_EOF); | ||
815 | |||
816 | _decode_clear(vf); | ||
817 | |||
818 | if(!vf->seekable){ | ||
819 | vorbis_info_clear(vf->vi); | ||
820 | /* vorbis_comment_clear(vf->vc); */ | ||
821 | } | ||
822 | break; | ||
823 | |||
824 | }else | ||
825 | continue; /* possibility #2 */ | ||
826 | } | ||
827 | } | ||
828 | |||
829 | break; | ||
830 | } | ||
831 | } | ||
832 | |||
833 | /* Do we need to load a new machine before submitting the page? */ | ||
834 | /* This is different in the seekable and non-seekable cases. | ||
835 | |||
836 | In the seekable case, we already have all the header | ||
837 | information loaded and cached; we just initialize the machine | ||
838 | with it and continue on our merry way. | ||
839 | |||
840 | In the non-seekable (streaming) case, we'll only be at a | ||
841 | boundary if we just left the previous logical bitstream and | ||
842 | we're now nominally at the header of the next bitstream | ||
843 | */ | ||
844 | |||
845 | if(vf->ready_state!=INITSET){ | ||
846 | int link; | ||
847 | |||
848 | if(vf->ready_state<STREAMSET){ | ||
849 | if(vf->seekable){ | ||
850 | ogg_uint32_t serialno = ogg_page_serialno(&og); | ||
851 | |||
852 | /* match the serialno to bitstream section. We use this rather than | ||
853 | offset positions to avoid problems near logical bitstream | ||
854 | boundaries */ | ||
855 | |||
856 | for(link=0;link<vf->links;link++) | ||
857 | if(vf->serialnos[link]==serialno)break; | ||
858 | |||
859 | if(link==vf->links) continue; /* not the desired Vorbis | ||
860 | bitstream section; keep | ||
861 | trying */ | ||
862 | |||
863 | vf->current_serialno=serialno; | ||
864 | vf->current_link=link; | ||
865 | |||
866 | ogg_stream_reset_serialno(&vf->os,vf->current_serialno); | ||
867 | vf->ready_state=STREAMSET; | ||
868 | |||
869 | }else{ | ||
870 | /* we're streaming */ | ||
871 | /* fetch the three header packets, build the info struct */ | ||
872 | |||
873 | int ret=_fetch_headers(vf,vf->vi,NULL,NULL,&og); | ||
874 | if(ret)return(ret); | ||
875 | vf->current_serialno=vf->os.serialno; | ||
876 | vf->current_link++; | ||
877 | link=0; | ||
878 | } | ||
879 | } | ||
880 | } | ||
881 | |||
882 | /* the buffered page is the data we want, and we're ready for it; | ||
883 | add it to the stream state */ | ||
884 | ogg_stream_pagein(&vf->os,&og,true); | ||
885 | |||
886 | } | ||
887 | } | ||
888 | |||
889 | static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial, | ||
890 | long ibytes, ov_callbacks callbacks){ | ||
891 | int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1); | ||
892 | ogg_uint32_t *serialno_list=NULL; | ||
893 | int serialno_list_size=0; | ||
894 | int ret; | ||
895 | |||
896 | memset(vf,0,sizeof(*vf)); | ||
897 | vf->datasource=f; | ||
898 | vf->callbacks = callbacks; | ||
899 | |||
900 | /* init the framing state */ | ||
901 | ogg_sync_init(&vf->oy); | ||
902 | |||
903 | /* perhaps some data was previously read into a buffer for testing | ||
904 | against other stream types. Allow initialization from this | ||
905 | previously read data (especially as we may be reading from a | ||
906 | non-seekable stream) */ | ||
907 | if(initial){ | ||
908 | char *buffer=ogg_sync_buffer(&vf->oy,ibytes); | ||
909 | memcpy(buffer,initial,ibytes); | ||
910 | ogg_sync_wrote(&vf->oy,ibytes); | ||
911 | } | ||
912 | |||
913 | /* can we seek? Stevens suggests the seek test was portable */ | ||
914 | if(offsettest!=-1)vf->seekable=1; | ||
915 | |||
916 | /* No seeking yet; Set up a 'single' (current) logical bitstream | ||
917 | entry for partial open */ | ||
918 | vf->links=1; | ||
919 | vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi)); | ||
920 | /* vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc)); */ | ||
921 | ogg_stream_init(&vf->os,-1); /* fill in the serialno later */ | ||
922 | |||
923 | /* Fetch all BOS pages, store the vorbis header and all seen serial | ||
924 | numbers, load subsequent vorbis setup headers */ | ||
925 | if((ret=_fetch_headers(vf,vf->vi,&serialno_list,&serialno_list_size,NULL))<0){ | ||
926 | vf->datasource=NULL; | ||
927 | ov_clear(vf); | ||
928 | }else{ | ||
929 | /* serial number list for first link needs to be held somewhere | ||
930 | for second stage of seekable stream open; this saves having to | ||
931 | seek/reread first link's serialnumber data then. */ | ||
932 | vf->serialnos=_ogg_calloc(serialno_list_size+2,sizeof(*vf->serialnos)); | ||
933 | vf->serialnos[0]=vf->current_serialno=vf->os.serialno; | ||
934 | vf->serialnos[1]=serialno_list_size; | ||
935 | memcpy(vf->serialnos+2,serialno_list,serialno_list_size*sizeof(*vf->serialnos)); | ||
936 | |||
937 | vf->offsets=_ogg_calloc(1,sizeof(*vf->offsets)); | ||
938 | vf->dataoffsets=_ogg_calloc(1,sizeof(*vf->dataoffsets)); | ||
939 | vf->offsets[0]=0; | ||
940 | vf->dataoffsets[0]=vf->offset; | ||
941 | |||
942 | vf->ready_state=PARTOPEN; | ||
943 | } | ||
944 | if(serialno_list)_ogg_free(serialno_list); | ||
945 | return(ret); | ||
946 | } | ||
947 | |||
948 | static int _ov_open2(OggVorbis_File *vf){ | ||
949 | if(vf->ready_state != PARTOPEN) return OV_EINVAL; | ||
950 | vf->ready_state=OPENED; | ||
951 | if(vf->seekable){ | ||
952 | int ret=_open_seekable2(vf); | ||
953 | if(ret){ | ||
954 | vf->datasource=NULL; | ||
955 | ov_clear(vf); | ||
956 | } | ||
957 | return(ret); | ||
958 | }else | ||
959 | vf->ready_state=STREAMSET; | ||
960 | |||
961 | return 0; | ||
962 | } | ||
963 | |||
964 | |||
965 | /* clear out the OggVorbis_File struct */ | ||
966 | int ov_clear(OggVorbis_File *vf){ | ||
967 | if(vf){ | ||
968 | vorbis_block_clear(&vf->vb); | ||
969 | vorbis_dsp_clear(&vf->vd); | ||
970 | ogg_stream_clear(&vf->os); | ||
971 | |||
972 | if(vf->vi && vf->links){ | ||
973 | int i; | ||
974 | for(i=0;i<vf->links;i++){ | ||
975 | vorbis_info_clear(vf->vi+i); | ||
976 | /* vorbis_comment_clear(vf->vc+i); */ | ||
977 | } | ||
978 | _ogg_free(vf->vi); | ||
979 | /* _ogg_free(vf->vc); */ | ||
980 | } | ||
981 | if(vf->dataoffsets)_ogg_free(vf->dataoffsets); | ||
982 | if(vf->pcmlengths)_ogg_free(vf->pcmlengths); | ||
983 | if(vf->serialnos)_ogg_free(vf->serialnos); | ||
984 | if(vf->offsets)_ogg_free(vf->offsets); | ||
985 | ogg_sync_clear(&vf->oy); | ||
986 | if(vf->datasource && vf->callbacks.close_func) | ||
987 | (vf->callbacks.close_func)(vf->datasource); | ||
988 | memset(vf,0,sizeof(*vf)); | ||
989 | } | ||
990 | #ifdef DEBUG_LEAKS | ||
991 | _VDBG_dump(); | ||
992 | #endif | ||
993 | return(0); | ||
994 | } | ||
995 | |||
996 | /* inspects the OggVorbis file and finds/documents all the logical | ||
997 | bitstreams contained in it. Tries to be tolerant of logical | ||
998 | bitstream sections that are truncated/woogie. | ||
999 | |||
1000 | return: -1) error | ||
1001 | 0) OK | ||
1002 | */ | ||
1003 | |||
1004 | int ov_open_callbacks(void *f,OggVorbis_File *vf, | ||
1005 | const char *initial,long ibytes,ov_callbacks callbacks){ | ||
1006 | #if defined(CPU_COLDFIRE) | ||
1007 | /* this seems to be the closest we get to an init function, let's init emac | ||
1008 | here. rounding is disabled because of MULT31_SHIFT15, which will be | ||
1009 | inaccurate with rounding in its current incarnation */ | ||
1010 | coldfire_set_macsr(EMAC_FRACTIONAL | EMAC_SATURATE); | ||
1011 | #endif | ||
1012 | int ret=_ov_open1(f,vf,initial,ibytes,callbacks); | ||
1013 | if(ret)return ret; | ||
1014 | return _ov_open2(vf); | ||
1015 | } | ||
1016 | |||
1017 | /* returns: total PCM length (samples) of content if i==-1 PCM length | ||
1018 | (samples) of that logical bitstream for i==0 to n | ||
1019 | OV_EINVAL if the stream is not seekable (we can't know the | ||
1020 | length) or only partially open | ||
1021 | */ | ||
1022 | ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){ | ||
1023 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1024 | if(!vf->seekable || i>=vf->links)return(OV_EINVAL); | ||
1025 | if(i<0){ | ||
1026 | ogg_int64_t acc=0; | ||
1027 | int i; | ||
1028 | for(i=0;i<vf->links;i++) | ||
1029 | acc+=ov_pcm_total(vf,i); | ||
1030 | return(acc); | ||
1031 | }else{ | ||
1032 | return(vf->pcmlengths[i*2+1]); | ||
1033 | } | ||
1034 | } | ||
1035 | |||
1036 | /* returns: total milliseconds of content if i==-1 | ||
1037 | milliseconds in that logical bitstream for i==0 to n | ||
1038 | OV_EINVAL if the stream is not seekable (we can't know the | ||
1039 | length) or only partially open | ||
1040 | */ | ||
1041 | ogg_int64_t ov_time_total(OggVorbis_File *vf,int i){ | ||
1042 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1043 | if(!vf->seekable || i>=vf->links)return(OV_EINVAL); | ||
1044 | if(i<0){ | ||
1045 | ogg_int64_t acc=0; | ||
1046 | int i; | ||
1047 | for(i=0;i<vf->links;i++) | ||
1048 | acc+=ov_time_total(vf,i); | ||
1049 | return(acc); | ||
1050 | }else{ | ||
1051 | return(((ogg_int64_t)vf->pcmlengths[i*2+1])*1000/vf->vi[i].rate); | ||
1052 | } | ||
1053 | } | ||
1054 | |||
1055 | /* seek to an offset relative to the *compressed* data. This also | ||
1056 | scans packets to update the PCM cursor. It will cross a logical | ||
1057 | bitstream boundary, but only if it can't get any packets out of the | ||
1058 | tail of the bitstream we seek to (so no surprises). | ||
1059 | |||
1060 | returns zero on success, nonzero on failure */ | ||
1061 | |||
1062 | int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){ | ||
1063 | ogg_stream_state work_os; | ||
1064 | int ret; | ||
1065 | |||
1066 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1067 | if(!vf->seekable) | ||
1068 | return(OV_ENOSEEK); /* don't dump machine if we can't seek */ | ||
1069 | |||
1070 | if(pos<0 || pos>vf->end)return(OV_EINVAL); | ||
1071 | |||
1072 | /* is the seek position outside our current link [if any]? */ | ||
1073 | if(vf->ready_state>=STREAMSET){ | ||
1074 | if(pos<vf->offsets[vf->current_link] || pos>=vf->offsets[vf->current_link+1]) | ||
1075 | _decode_clear(vf); /* clear out stream state */ | ||
1076 | } | ||
1077 | |||
1078 | /* don't yet clear out decoding machine (if it's initialized), in | ||
1079 | the case we're in the same link. Restart the decode lapping, and | ||
1080 | let _fetch_and_process_packet deal with a potential bitstream | ||
1081 | boundary */ | ||
1082 | vf->pcm_offset=-1; | ||
1083 | ogg_stream_reset_serialno(&vf->os, | ||
1084 | vf->current_serialno); /* must set serialno */ | ||
1085 | vorbis_synthesis_restart(&vf->vd); | ||
1086 | |||
1087 | ret=_seek_helper(vf,pos); | ||
1088 | if(ret)goto seek_error; | ||
1089 | |||
1090 | /* we need to make sure the pcm_offset is set, but we don't want to | ||
1091 | advance the raw cursor past good packets just to get to the first | ||
1092 | with a granulepos. That's not equivalent behavior to beginning | ||
1093 | decoding as immediately after the seek position as possible. | ||
1094 | |||
1095 | So, a hack. We use two stream states; a local scratch state and | ||
1096 | the shared vf->os stream state. We use the local state to | ||
1097 | scan, and the shared state as a buffer for later decode. | ||
1098 | |||
1099 | Unfortuantely, on the last page we still advance to last packet | ||
1100 | because the granulepos on the last page is not necessarily on a | ||
1101 | packet boundary, and we need to make sure the granpos is | ||
1102 | correct. | ||
1103 | */ | ||
1104 | |||
1105 | { | ||
1106 | ogg_page og; | ||
1107 | ogg_packet op; | ||
1108 | int lastblock=0; | ||
1109 | int accblock=0; | ||
1110 | int thisblock=0; | ||
1111 | int lastflag=0; | ||
1112 | int firstflag=0; | ||
1113 | ogg_int64_t pagepos=-1; | ||
1114 | |||
1115 | ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */ | ||
1116 | ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE | ||
1117 | return from not necessarily | ||
1118 | starting from the beginning */ | ||
1119 | |||
1120 | while(1){ | ||
1121 | if(vf->ready_state>=STREAMSET){ | ||
1122 | /* snarf/scan a packet if we can */ | ||
1123 | int result=ogg_stream_packetout(&work_os,&op); | ||
1124 | |||
1125 | if(result>0){ | ||
1126 | |||
1127 | if(vf->vi[vf->current_link].codec_setup){ | ||
1128 | thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op); | ||
1129 | if(thisblock<0){ | ||
1130 | ogg_stream_packetout(&vf->os,NULL); | ||
1131 | thisblock=0; | ||
1132 | }else{ | ||
1133 | |||
1134 | /* We can't get a guaranteed correct pcm position out of the | ||
1135 | last page in a stream because it might have a 'short' | ||
1136 | granpos, which can only be detected in the presence of a | ||
1137 | preceding page. However, if the last page is also the first | ||
1138 | page, the granpos rules of a first page take precedence. Not | ||
1139 | only that, but for first==last, the EOS page must be treated | ||
1140 | as if its a normal first page for the stream to open/play. */ | ||
1141 | if(lastflag && !firstflag) | ||
1142 | ogg_stream_packetout(&vf->os,NULL); | ||
1143 | else | ||
1144 | if(lastblock)accblock+=(lastblock+thisblock)>>2; | ||
1145 | } | ||
1146 | |||
1147 | if(op.granulepos!=-1){ | ||
1148 | int i,link=vf->current_link; | ||
1149 | ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2]; | ||
1150 | if(granulepos<0)granulepos=0; | ||
1151 | |||
1152 | for(i=0;i<link;i++) | ||
1153 | granulepos+=vf->pcmlengths[i*2+1]; | ||
1154 | vf->pcm_offset=granulepos-accblock; | ||
1155 | if(vf->pcm_offset<0)vf->pcm_offset=0; | ||
1156 | break; | ||
1157 | } | ||
1158 | lastblock=thisblock; | ||
1159 | continue; | ||
1160 | }else | ||
1161 | ogg_stream_packetout(&vf->os,NULL); | ||
1162 | } | ||
1163 | } | ||
1164 | |||
1165 | if(!lastblock){ | ||
1166 | pagepos=_get_next_page(vf,&og,-1); | ||
1167 | if(pagepos<0){ | ||
1168 | vf->pcm_offset=ov_pcm_total(vf,-1); | ||
1169 | break; | ||
1170 | } | ||
1171 | }else{ | ||
1172 | /* huh? Bogus stream with packets but no granulepos */ | ||
1173 | vf->pcm_offset=-1; | ||
1174 | break; | ||
1175 | } | ||
1176 | |||
1177 | /* has our decoding just traversed a bitstream boundary? */ | ||
1178 | if(vf->ready_state>=STREAMSET){ | ||
1179 | if(vf->current_serialno!=ogg_page_serialno(&og)){ | ||
1180 | |||
1181 | /* two possibilities: | ||
1182 | 1) our decoding just traversed a bitstream boundary | ||
1183 | 2) another stream is multiplexed into this logical section? */ | ||
1184 | |||
1185 | if(ogg_page_bos(&og)){ | ||
1186 | /* we traversed */ | ||
1187 | _decode_clear(vf); /* clear out stream state */ | ||
1188 | ogg_stream_clear(&work_os); | ||
1189 | } /* else, do nothing; next loop will scoop another page */ | ||
1190 | } | ||
1191 | } | ||
1192 | |||
1193 | if(vf->ready_state<STREAMSET){ | ||
1194 | int link; | ||
1195 | ogg_uint32_t serialno = ogg_page_serialno(&og); | ||
1196 | |||
1197 | for(link=0;link<vf->links;link++) | ||
1198 | if(vf->serialnos[link]==serialno)break; | ||
1199 | |||
1200 | if(link==vf->links) continue; /* not the desired Vorbis | ||
1201 | bitstream section; keep | ||
1202 | trying */ | ||
1203 | vf->current_link=link; | ||
1204 | vf->current_serialno=serialno; | ||
1205 | ogg_stream_reset_serialno(&vf->os,serialno); | ||
1206 | ogg_stream_reset_serialno(&work_os,serialno); | ||
1207 | vf->ready_state=STREAMSET; | ||
1208 | firstflag=(pagepos<=vf->dataoffsets[link]); | ||
1209 | } | ||
1210 | |||
1211 | ogg_stream_pagein(&vf->os,&og,true); | ||
1212 | ogg_stream_pagein(&work_os,&og,true); | ||
1213 | lastflag=ogg_page_eos(&og); | ||
1214 | |||
1215 | } | ||
1216 | } | ||
1217 | |||
1218 | ogg_stream_clear(&work_os); | ||
1219 | vf->bittrack=0; | ||
1220 | vf->samptrack=0; | ||
1221 | return(0); | ||
1222 | |||
1223 | seek_error: | ||
1224 | /* dump the machine so we're in a known state */ | ||
1225 | vf->pcm_offset=-1; | ||
1226 | ogg_stream_clear(&work_os); | ||
1227 | _decode_clear(vf); | ||
1228 | return OV_EBADLINK; | ||
1229 | } | ||
1230 | |||
1231 | /* rescales the number x from the range of [0,from] to [0,to] | ||
1232 | x is in the range [0,from] | ||
1233 | from, to are in the range [1, 1<<62-1] */ | ||
1234 | ogg_int64_t rescale64(ogg_int64_t x, ogg_int64_t from, ogg_int64_t to){ | ||
1235 | ogg_int64_t frac=0; | ||
1236 | ogg_int64_t ret=0; | ||
1237 | int i; | ||
1238 | if(x >= from) return to; | ||
1239 | if(x <= 0) return 0; | ||
1240 | |||
1241 | for(i=0;i<64;i++){ | ||
1242 | if(x>=from){ | ||
1243 | frac|=1; | ||
1244 | x-=from; | ||
1245 | } | ||
1246 | x<<=1; | ||
1247 | frac<<=1; | ||
1248 | } | ||
1249 | |||
1250 | for(i=0;i<64;i++){ | ||
1251 | if(frac & 1){ | ||
1252 | ret+=to; | ||
1253 | } | ||
1254 | frac>>=1; | ||
1255 | ret>>=1; | ||
1256 | } | ||
1257 | |||
1258 | return ret; | ||
1259 | } | ||
1260 | |||
1261 | /* Page granularity seek (faster than sample granularity because we | ||
1262 | don't do the last bit of decode to find a specific sample). | ||
1263 | |||
1264 | Seek to the last [granule marked] page preceding the specified pos | ||
1265 | location, such that decoding past the returned point will quickly | ||
1266 | arrive at the requested position. */ | ||
1267 | int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ | ||
1268 | int link=-1; | ||
1269 | ogg_int64_t result=0; | ||
1270 | ogg_int64_t total=ov_pcm_total(vf,-1); | ||
1271 | |||
1272 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1273 | if(!vf->seekable)return(OV_ENOSEEK); | ||
1274 | |||
1275 | if(pos<0 || pos>total)return(OV_EINVAL); | ||
1276 | |||
1277 | /* which bitstream section does this pcm offset occur in? */ | ||
1278 | for(link=vf->links-1;link>=0;link--){ | ||
1279 | total-=vf->pcmlengths[link*2+1]; | ||
1280 | if(pos>=total)break; | ||
1281 | } | ||
1282 | |||
1283 | /* search within the logical bitstream for the page with the highest | ||
1284 | pcm_pos preceding (or equal to) pos. There is a danger here; | ||
1285 | missing pages or incorrect frame number information in the | ||
1286 | bitstream could make our task impossible. Account for that (it | ||
1287 | would be an error condition) */ | ||
1288 | |||
1289 | /* new search algorithm by HB (Nicholas Vinen) */ | ||
1290 | { | ||
1291 | ogg_int64_t end=vf->offsets[link+1]; | ||
1292 | ogg_int64_t begin=vf->offsets[link]; | ||
1293 | ogg_int64_t begintime = vf->pcmlengths[link*2]; | ||
1294 | ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime; | ||
1295 | ogg_int64_t target=pos-total+begintime; | ||
1296 | ogg_int64_t best=begin; | ||
1297 | |||
1298 | ogg_page og; | ||
1299 | while(begin<end){ | ||
1300 | ogg_int64_t bisect; | ||
1301 | |||
1302 | if(end-begin<CHUNKSIZE){ | ||
1303 | bisect=begin; | ||
1304 | }else{ | ||
1305 | /* take a (pretty decent) guess. */ | ||
1306 | bisect=begin + rescale64(target-begintime, | ||
1307 | endtime-begintime, | ||
1308 | end-begin) - CHUNKSIZE; | ||
1309 | if(bisect<begin+CHUNKSIZE) | ||
1310 | bisect=begin; | ||
1311 | } | ||
1312 | |||
1313 | if(bisect!=vf->offset){ | ||
1314 | result=_seek_helper(vf,bisect); | ||
1315 | if(result) goto seek_error; | ||
1316 | } | ||
1317 | |||
1318 | while(begin<end){ | ||
1319 | result=_get_next_page(vf,&og,end-vf->offset); | ||
1320 | if(result==OV_EREAD) goto seek_error; | ||
1321 | if(result<0){ | ||
1322 | if(bisect<=begin+1) | ||
1323 | end=begin; /* found it */ | ||
1324 | else{ | ||
1325 | if(bisect==0) goto seek_error; | ||
1326 | bisect-=CHUNKSIZE; | ||
1327 | if(bisect<=begin)bisect=begin+1; | ||
1328 | result=_seek_helper(vf,bisect); | ||
1329 | if(result) goto seek_error; | ||
1330 | } | ||
1331 | }else{ | ||
1332 | ogg_int64_t granulepos; | ||
1333 | |||
1334 | if(ogg_page_serialno(&og)!=vf->serialnos[link]) | ||
1335 | continue; | ||
1336 | |||
1337 | granulepos=ogg_page_granulepos(&og); | ||
1338 | if(granulepos==-1)continue; | ||
1339 | |||
1340 | if(granulepos<target){ | ||
1341 | best=result; /* raw offset of packet with granulepos */ | ||
1342 | begin=vf->offset; /* raw offset of next page */ | ||
1343 | begintime=granulepos; | ||
1344 | |||
1345 | if(target-begintime>44100)break; | ||
1346 | bisect=begin; /* *not* begin + 1 */ | ||
1347 | }else{ | ||
1348 | if(bisect<=begin+1) | ||
1349 | end=begin; /* found it */ | ||
1350 | else{ | ||
1351 | if(end==vf->offset){ /* we're pretty close - we'd be stuck in */ | ||
1352 | end=result; | ||
1353 | bisect-=CHUNKSIZE; /* an endless loop otherwise. */ | ||
1354 | if(bisect<=begin)bisect=begin+1; | ||
1355 | result=_seek_helper(vf,bisect); | ||
1356 | if(result) goto seek_error; | ||
1357 | }else{ | ||
1358 | end=bisect; | ||
1359 | endtime=granulepos; | ||
1360 | break; | ||
1361 | } | ||
1362 | } | ||
1363 | } | ||
1364 | } | ||
1365 | } | ||
1366 | } | ||
1367 | |||
1368 | /* found our page. seek to it, update pcm offset. Easier case than | ||
1369 | raw_seek, don't keep packets preceding granulepos. */ | ||
1370 | { | ||
1371 | ogg_page og; | ||
1372 | ogg_packet op; | ||
1373 | |||
1374 | /* seek */ | ||
1375 | result=_seek_helper(vf,best); | ||
1376 | vf->pcm_offset=-1; | ||
1377 | if(result) goto seek_error; | ||
1378 | result=_get_next_page(vf,&og,-1); | ||
1379 | if(result<0) goto seek_error; | ||
1380 | |||
1381 | if(link!=vf->current_link){ | ||
1382 | /* Different link; dump entire decode machine */ | ||
1383 | _decode_clear(vf); | ||
1384 | |||
1385 | vf->current_link=link; | ||
1386 | vf->current_serialno=vf->serialnos[link]; | ||
1387 | vf->ready_state=STREAMSET; | ||
1388 | |||
1389 | }else{ | ||
1390 | vorbis_synthesis_restart(&vf->vd); | ||
1391 | } | ||
1392 | |||
1393 | ogg_stream_reset_serialno(&vf->os,vf->current_serialno); | ||
1394 | ogg_stream_pagein(&vf->os,&og,true); | ||
1395 | |||
1396 | /* pull out all but last packet; the one with granulepos */ | ||
1397 | while(1){ | ||
1398 | result=ogg_stream_packetpeek(&vf->os,&op); | ||
1399 | if(result==0){ | ||
1400 | /* !!! the packet finishing this page originated on a | ||
1401 | preceding page. Keep fetching previous pages until we | ||
1402 | get one with a granulepos or without the 'continued' flag | ||
1403 | set. Then just use raw_seek for simplicity. */ | ||
1404 | |||
1405 | result=_seek_helper(vf,best); | ||
1406 | if(result<0) goto seek_error; | ||
1407 | |||
1408 | while(1){ | ||
1409 | result=_get_prev_page(vf,&og); | ||
1410 | if(result<0) goto seek_error; | ||
1411 | if(ogg_page_serialno(&og)==vf->current_serialno && | ||
1412 | (ogg_page_granulepos(&og)>-1 || | ||
1413 | !ogg_page_continued(&og))){ | ||
1414 | return ov_raw_seek(vf,result); | ||
1415 | } | ||
1416 | vf->offset=result; | ||
1417 | } | ||
1418 | } | ||
1419 | if(result<0){ | ||
1420 | result = OV_EBADPACKET; | ||
1421 | goto seek_error; | ||
1422 | } | ||
1423 | if(op.granulepos!=-1){ | ||
1424 | vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2]; | ||
1425 | if(vf->pcm_offset<0)vf->pcm_offset=0; | ||
1426 | vf->pcm_offset+=total; | ||
1427 | break; | ||
1428 | }else | ||
1429 | result=ogg_stream_packetout(&vf->os,NULL); | ||
1430 | } | ||
1431 | } | ||
1432 | } | ||
1433 | |||
1434 | /* verify result */ | ||
1435 | if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){ | ||
1436 | result=OV_EFAULT; | ||
1437 | goto seek_error; | ||
1438 | } | ||
1439 | vf->bittrack=0; | ||
1440 | vf->samptrack=0; | ||
1441 | return(0); | ||
1442 | |||
1443 | seek_error: | ||
1444 | /* dump machine so we're in a known state */ | ||
1445 | vf->pcm_offset=-1; | ||
1446 | _decode_clear(vf); | ||
1447 | return (int)result; | ||
1448 | } | ||
1449 | |||
1450 | /* seek to a sample offset relative to the decompressed pcm stream | ||
1451 | returns zero on success, nonzero on failure */ | ||
1452 | |||
1453 | int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){ | ||
1454 | int thisblock,lastblock=0; | ||
1455 | int ret=ov_pcm_seek_page(vf,pos); | ||
1456 | if(ret<0)return(ret); | ||
1457 | if((ret=_make_decode_ready(vf)))return ret; | ||
1458 | |||
1459 | /* discard leading packets we don't need for the lapping of the | ||
1460 | position we want; don't decode them */ | ||
1461 | |||
1462 | while(1){ | ||
1463 | ogg_packet op; | ||
1464 | ogg_page og; | ||
1465 | |||
1466 | int ret=ogg_stream_packetpeek(&vf->os,&op); | ||
1467 | if(ret>0){ | ||
1468 | thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op); | ||
1469 | if(thisblock<0){ | ||
1470 | ogg_stream_packetout(&vf->os,NULL); | ||
1471 | continue; /* non audio packet */ | ||
1472 | } | ||
1473 | if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2; | ||
1474 | |||
1475 | if(vf->pcm_offset+((thisblock+ | ||
1476 | vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break; | ||
1477 | |||
1478 | /* remove the packet from packet queue and track its granulepos */ | ||
1479 | ogg_stream_packetout(&vf->os,NULL); | ||
1480 | vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with | ||
1481 | only tracking, no | ||
1482 | pcm_decode */ | ||
1483 | vorbis_synthesis_blockin(&vf->vd,&vf->vb); | ||
1484 | |||
1485 | /* end of logical stream case is hard, especially with exact | ||
1486 | length positioning. */ | ||
1487 | |||
1488 | if(op.granulepos>-1){ | ||
1489 | int i; | ||
1490 | /* always believe the stream markers */ | ||
1491 | vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2]; | ||
1492 | if(vf->pcm_offset<0)vf->pcm_offset=0; | ||
1493 | for(i=0;i<vf->current_link;i++) | ||
1494 | vf->pcm_offset+=vf->pcmlengths[i*2+1]; | ||
1495 | } | ||
1496 | |||
1497 | lastblock=thisblock; | ||
1498 | |||
1499 | }else{ | ||
1500 | if(ret<0 && ret!=OV_HOLE)break; | ||
1501 | |||
1502 | /* suck in a new page */ | ||
1503 | if(_get_next_page(vf,&og,-1)<0)break; | ||
1504 | if(ogg_page_bos(&og))_decode_clear(vf); | ||
1505 | |||
1506 | if(vf->ready_state<STREAMSET){ | ||
1507 | long serialno=ogg_page_serialno(&og); | ||
1508 | int link; | ||
1509 | |||
1510 | for(link=0;link<vf->links;link++) | ||
1511 | if(vf->serialnos[link]==(ogg_uint32_t) serialno)break; | ||
1512 | if(link==vf->links) continue; | ||
1513 | vf->current_link=link; | ||
1514 | |||
1515 | vf->ready_state=STREAMSET; | ||
1516 | vf->current_serialno=ogg_page_serialno(&og); | ||
1517 | ogg_stream_reset_serialno(&vf->os,serialno); | ||
1518 | ret=_make_decode_ready(vf); | ||
1519 | if(ret)return ret; | ||
1520 | lastblock=0; | ||
1521 | } | ||
1522 | |||
1523 | ogg_stream_pagein(&vf->os,&og,true); | ||
1524 | } | ||
1525 | } | ||
1526 | |||
1527 | vf->bittrack=0; | ||
1528 | vf->samptrack=0; | ||
1529 | /* discard samples until we reach the desired position. Crossing a | ||
1530 | logical bitstream boundary with abandon is OK. */ | ||
1531 | while(vf->pcm_offset<pos){ | ||
1532 | ogg_int64_t target=pos-vf->pcm_offset; | ||
1533 | long samples=vorbis_synthesis_pcmout(&vf->vd,NULL); | ||
1534 | |||
1535 | if(samples>target)samples=target; | ||
1536 | vorbis_synthesis_read(&vf->vd,samples); | ||
1537 | vf->pcm_offset+=samples; | ||
1538 | |||
1539 | if(samples<target) | ||
1540 | if(_fetch_and_process_packet(vf,NULL,1,1)<=0) | ||
1541 | vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */ | ||
1542 | } | ||
1543 | return 0; | ||
1544 | } | ||
1545 | |||
1546 | /* seek to a playback time relative to the decompressed pcm stream | ||
1547 | returns zero on success, nonzero on failure */ | ||
1548 | int ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){ | ||
1549 | /* translate time to PCM position and call ov_pcm_seek */ | ||
1550 | |||
1551 | int link=-1; | ||
1552 | ogg_int64_t pcm_total=0; | ||
1553 | ogg_int64_t time_total=0; | ||
1554 | |||
1555 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1556 | if(!vf->seekable)return(OV_ENOSEEK); | ||
1557 | if(milliseconds<0)return(OV_EINVAL); | ||
1558 | |||
1559 | /* which bitstream section does this time offset occur in? */ | ||
1560 | for(link=0;link<vf->links;link++){ | ||
1561 | ogg_int64_t addsec = ov_time_total(vf,link); | ||
1562 | if(milliseconds<time_total+addsec)break; | ||
1563 | time_total+=addsec; | ||
1564 | pcm_total+=vf->pcmlengths[link*2+1]; | ||
1565 | } | ||
1566 | |||
1567 | if(link==vf->links)return(OV_EINVAL); | ||
1568 | |||
1569 | /* enough information to convert time offset to pcm offset */ | ||
1570 | { | ||
1571 | ogg_int64_t target=pcm_total+(milliseconds-time_total)*vf->vi[link].rate/1000; | ||
1572 | return(ov_pcm_seek(vf,target)); | ||
1573 | } | ||
1574 | } | ||
1575 | |||
1576 | /* tell the current stream offset cursor. Note that seek followed by | ||
1577 | tell will likely not give the set offset due to caching */ | ||
1578 | ogg_int64_t ov_raw_tell(OggVorbis_File *vf){ | ||
1579 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1580 | return(vf->offset); | ||
1581 | } | ||
1582 | |||
1583 | /* return time offset (milliseconds) of next PCM sample to be read */ | ||
1584 | ogg_int64_t ov_time_tell(OggVorbis_File *vf){ | ||
1585 | int link=0; | ||
1586 | ogg_int64_t pcm_total=0; | ||
1587 | ogg_int64_t time_total=0; | ||
1588 | |||
1589 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1590 | if(vf->seekable){ | ||
1591 | pcm_total=ov_pcm_total(vf,-1); | ||
1592 | time_total=ov_time_total(vf,-1); | ||
1593 | |||
1594 | /* which bitstream section does this time offset occur in? */ | ||
1595 | for(link=vf->links-1;link>=0;link--){ | ||
1596 | pcm_total-=vf->pcmlengths[link*2+1]; | ||
1597 | time_total-=ov_time_total(vf,link); | ||
1598 | if(vf->pcm_offset>=pcm_total)break; | ||
1599 | } | ||
1600 | } | ||
1601 | |||
1602 | return(time_total+(1000*vf->pcm_offset-pcm_total)/vf->vi[link].rate); | ||
1603 | } | ||
1604 | |||
1605 | /* link: -1) return the vorbis_info struct for the bitstream section | ||
1606 | currently being decoded | ||
1607 | 0-n) to request information for a specific bitstream section | ||
1608 | |||
1609 | In the case of a non-seekable bitstream, any call returns the | ||
1610 | current bitstream. NULL in the case that the machine is not | ||
1611 | initialized */ | ||
1612 | |||
1613 | vorbis_info *ov_info(OggVorbis_File *vf,int link){ | ||
1614 | if(vf->seekable){ | ||
1615 | if(link<0) | ||
1616 | if(vf->ready_state>=STREAMSET) | ||
1617 | return vf->vi+vf->current_link; | ||
1618 | else | ||
1619 | return vf->vi; | ||
1620 | else | ||
1621 | if(link>=vf->links) | ||
1622 | return NULL; | ||
1623 | else | ||
1624 | return vf->vi+link; | ||
1625 | }else{ | ||
1626 | return vf->vi; | ||
1627 | } | ||
1628 | } | ||
1629 | |||
1630 | /* input values: pcm_channels) a float vector per channel of output | ||
1631 | length) the sample length being read by the app | ||
1632 | |||
1633 | return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL) | ||
1634 | 0) EOF | ||
1635 | n) number of samples of PCM actually returned. The | ||
1636 | below works on a packet-by-packet basis, so the | ||
1637 | return length is not related to the 'length' passed | ||
1638 | in, just guaranteed to fit. | ||
1639 | |||
1640 | *section) set to the logical bitstream number */ | ||
1641 | |||
1642 | long ov_read_fixed(OggVorbis_File *vf,ogg_int32_t ***pcm_channels,int length, | ||
1643 | int *bitstream){ | ||
1644 | if(vf->ready_state<OPENED)return(OV_EINVAL); | ||
1645 | |||
1646 | while(1){ | ||
1647 | if(vf->ready_state==INITSET){ | ||
1648 | ogg_int32_t **pcm; | ||
1649 | long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm); | ||
1650 | if(samples){ | ||
1651 | if(pcm_channels)*pcm_channels=pcm; | ||
1652 | if(samples>length)samples=length; | ||
1653 | vorbis_synthesis_read(&vf->vd,samples); | ||
1654 | vf->pcm_offset+=samples; | ||
1655 | if(bitstream)*bitstream=vf->current_link; | ||
1656 | return samples; | ||
1657 | |||
1658 | } | ||
1659 | } | ||
1660 | |||
1661 | /* suck in another packet */ | ||
1662 | { | ||
1663 | int ret=_fetch_and_process_packet(vf,NULL,1,1); | ||
1664 | if(ret==OV_EOF) | ||
1665 | return(0); | ||
1666 | if(ret<=0) | ||
1667 | return(ret); | ||
1668 | } | ||
1669 | } | ||
1670 | } | ||
1671 | |||
diff --git a/lib/rbcodec/codecs/libtremor/window.c b/lib/rbcodec/codecs/libtremor/window.c new file mode 100644 index 0000000000..3bc947f0e5 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/window.c | |||
@@ -0,0 +1,82 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: window functions | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #include "config-tremor.h" | ||
19 | #include <string.h> | ||
20 | #include <math.h> | ||
21 | #include "os.h" | ||
22 | #include "misc.h" | ||
23 | #include "window.h" | ||
24 | #include "window_lookup.h" | ||
25 | |||
26 | const void *_vorbis_window(int type, int left){ | ||
27 | |||
28 | switch(type){ | ||
29 | case 0: | ||
30 | |||
31 | switch(left){ | ||
32 | case 32: | ||
33 | return vwin64; | ||
34 | case 64: | ||
35 | return vwin128; | ||
36 | case 128: | ||
37 | return vwin256; | ||
38 | case 256: | ||
39 | return vwin512; | ||
40 | case 512: | ||
41 | return vwin1024; | ||
42 | case 1024: | ||
43 | return vwin2048; | ||
44 | case 2048: | ||
45 | return vwin4096; | ||
46 | case 4096: | ||
47 | return vwin8192; | ||
48 | default: | ||
49 | return(0); | ||
50 | } | ||
51 | break; | ||
52 | default: | ||
53 | return(0); | ||
54 | } | ||
55 | } | ||
56 | #if 0 | ||
57 | void _vorbis_apply_window(ogg_int32_t *d,const void *window_p[2], | ||
58 | long *blocksizes, | ||
59 | int lW,int W,int nW){ | ||
60 | LOOKUP_T *window[2]={window_p[0],window_p[1]}; | ||
61 | long n=blocksizes[W]; | ||
62 | long ln=blocksizes[lW]; | ||
63 | long rn=blocksizes[nW]; | ||
64 | |||
65 | long leftbegin=n/4-ln/4; | ||
66 | long leftend=leftbegin+ln/2; | ||
67 | |||
68 | long rightbegin=n/2+n/4-rn/4; | ||
69 | long rightend=rightbegin+rn/2; | ||
70 | |||
71 | /* Following memset is not required - we are careful to only overlap/add the | ||
72 | regions that geniunely overlap in the window region, and the portions | ||
73 | outside that region are not added (so don't need to be zerod). see block.c | ||
74 | memset((void *)&d[0], 0, sizeof(ogg_int32_t)*leftbegin); */ | ||
75 | |||
76 | ogg_vect_mult_fw(&d[leftbegin], &window[lW][0], leftend-leftbegin); | ||
77 | ogg_vect_mult_bw(&d[rightbegin], &window[nW][rn/2-1], rightend-rightbegin); | ||
78 | |||
79 | /* Again - memset not needed | ||
80 | memset((void *)&d[rightend], 0, sizeof(ogg_int32_t)*(n-rightend)); */ | ||
81 | } | ||
82 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/window.h b/lib/rbcodec/codecs/libtremor/window.h new file mode 100644 index 0000000000..166d0b8e9c --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/window.h | |||
@@ -0,0 +1,27 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: window functions | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _V_WINDOW_ | ||
19 | #define _V_WINDOW_ | ||
20 | |||
21 | extern const void *_vorbis_window(int type,int left); | ||
22 | /*extern void _vorbis_apply_window(ogg_int32_t *d,const void *window[2], | ||
23 | long *blocksizes, | ||
24 | int lW,int W,int nW);*/ | ||
25 | |||
26 | |||
27 | #endif | ||
diff --git a/lib/rbcodec/codecs/libtremor/window_lookup.h b/lib/rbcodec/codecs/libtremor/window_lookup.h new file mode 100644 index 0000000000..5363b81042 --- /dev/null +++ b/lib/rbcodec/codecs/libtremor/window_lookup.h | |||
@@ -0,0 +1,2087 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: window lookup tables | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | |||
19 | #include "os_types.h" | ||
20 | |||
21 | /* libvorbis currently only use the window sizes 256 and 2048, so only put | ||
22 | * them in fast IRAM. | ||
23 | */ | ||
24 | static LOOKUP_T vwin64[32] = { | ||
25 | X(0x001f0003), X(0x01168c98), X(0x030333c8), X(0x05dfe3a4), | ||
26 | X(0x09a49562), X(0x0e45df18), X(0x13b47ef2), X(0x19dcf676), | ||
27 | X(0x20a74d83), X(0x27f7137c), X(0x2fabb05a), X(0x37a1105a), | ||
28 | X(0x3fb0ab28), X(0x47b2dcd1), X(0x4f807bc6), X(0x56f48e70), | ||
29 | X(0x5dedfc79), X(0x64511653), X(0x6a08cfff), X(0x6f079328), | ||
30 | X(0x734796f4), X(0x76cab7f2), X(0x7999d6e8), X(0x7bc3cf9f), | ||
31 | X(0x7d5c20c1), X(0x7e7961df), X(0x7f33a567), X(0x7fa2e1d0), | ||
32 | X(0x7fdd78a5), X(0x7ff6ec6d), X(0x7ffed0e9), X(0x7ffffc3f), | ||
33 | }; | ||
34 | |||
35 | static LOOKUP_T vwin128[64] = { | ||
36 | X(0x0007c04d), X(0x0045bb89), X(0x00c18b87), X(0x017ae294), | ||
37 | X(0x02714a4e), X(0x03a4217a), X(0x05129952), X(0x06bbb24f), | ||
38 | X(0x089e38a1), X(0x0ab8c073), X(0x0d09a228), X(0x0f8ef6bd), | ||
39 | X(0x12469488), X(0x152e0c7a), X(0x1842a81c), X(0x1b81686d), | ||
40 | X(0x1ee705d9), X(0x226ff15d), X(0x26185705), X(0x29dc21cc), | ||
41 | X(0x2db700fe), X(0x31a46f08), X(0x359fb9c1), X(0x39a40c0c), | ||
42 | X(0x3dac78b6), X(0x41b40674), X(0x45b5bcb0), X(0x49acb109), | ||
43 | X(0x4d94152b), X(0x516744bd), X(0x5521d320), X(0x58bf98a5), | ||
44 | X(0x5c3cbef4), X(0x5f95cc5d), X(0x62c7add7), X(0x65cfbf64), | ||
45 | X(0x68abd2ba), X(0x6b5a3405), X(0x6dd9acab), X(0x7029840d), | ||
46 | X(0x72497e38), X(0x7439d8ac), X(0x75fb4532), X(0x778ee30a), | ||
47 | X(0x78f6367e), X(0x7a331f1a), X(0x7b47cccd), X(0x7c36b416), | ||
48 | X(0x7d028192), X(0x7dae0d18), X(0x7e3c4caa), X(0x7eb04763), | ||
49 | X(0x7f0d08a7), X(0x7f5593b7), X(0x7f8cd7d5), X(0x7fb5a513), | ||
50 | X(0x7fd2a1fc), X(0x7fe64212), X(0x7ff2bd4c), X(0x7ffa0890), | ||
51 | X(0x7ffdcf39), X(0x7fff6dac), X(0x7fffed01), X(0x7fffffc4), | ||
52 | }; | ||
53 | |||
54 | static LOOKUP_T vwin256[128] = { | ||
55 | X(0x0001f018), X(0x00117066), X(0x00306e9e), X(0x005ee5f1), | ||
56 | X(0x009ccf26), X(0x00ea208b), X(0x0146cdea), X(0x01b2c87f), | ||
57 | X(0x022dfedf), X(0x02b85ced), X(0x0351cbbd), X(0x03fa317f), | ||
58 | X(0x04b17167), X(0x05776b90), X(0x064bfcdc), X(0x072efedd), | ||
59 | X(0x082047b4), X(0x091fa9f1), X(0x0a2cf477), X(0x0b47f25d), | ||
60 | X(0x0c706ad2), X(0x0da620ff), X(0x0ee8d3ef), X(0x10383e75), | ||
61 | X(0x11941716), X(0x12fc0ff6), X(0x146fd6c8), X(0x15ef14c2), | ||
62 | X(0x17796e8e), X(0x190e844f), X(0x1aadf196), X(0x1c574d6e), | ||
63 | X(0x1e0a2a62), X(0x1fc61688), X(0x218a9b9c), X(0x23573f12), | ||
64 | X(0x252b823d), X(0x2706e269), X(0x28e8d913), X(0x2ad0dc0e), | ||
65 | X(0x2cbe5dc1), X(0x2eb0cd60), X(0x30a79733), X(0x32a224d5), | ||
66 | X(0x349fdd8b), X(0x36a02690), X(0x38a2636f), X(0x3aa5f65e), | ||
67 | X(0x3caa409e), X(0x3eaea2df), X(0x40b27da6), X(0x42b531b8), | ||
68 | X(0x44b62086), X(0x46b4ac99), X(0x48b03a05), X(0x4aa82ed5), | ||
69 | X(0x4c9bf37d), X(0x4e8af349), X(0x50749ccb), X(0x52586246), | ||
70 | X(0x5435ba1c), X(0x560c1f31), X(0x57db1152), X(0x59a21591), | ||
71 | X(0x5b60b6a3), X(0x5d168535), X(0x5ec31839), X(0x60660d36), | ||
72 | X(0x61ff0886), X(0x638db595), X(0x6511c717), X(0x668af734), | ||
73 | X(0x67f907b0), X(0x695bc207), X(0x6ab2f787), X(0x6bfe815a), | ||
74 | X(0x6d3e4090), X(0x6e721e16), X(0x6f9a0ab5), X(0x70b5fef8), | ||
75 | X(0x71c5fb16), X(0x72ca06cd), X(0x73c2313d), X(0x74ae90b2), | ||
76 | X(0x758f4275), X(0x76646a85), X(0x772e335c), X(0x77eccda0), | ||
77 | X(0x78a06fd7), X(0x79495613), X(0x79e7c19c), X(0x7a7bf894), | ||
78 | X(0x7b064596), X(0x7b86f757), X(0x7bfe6044), X(0x7c6cd615), | ||
79 | X(0x7cd2b16e), X(0x7d304d71), X(0x7d860756), X(0x7dd43e06), | ||
80 | X(0x7e1b51ad), X(0x7e5ba355), X(0x7e95947e), X(0x7ec986bb), | ||
81 | X(0x7ef7db4a), X(0x7f20f2b9), X(0x7f452c7f), X(0x7f64e6a7), | ||
82 | X(0x7f807d71), X(0x7f984aff), X(0x7faca700), X(0x7fbde662), | ||
83 | X(0x7fcc5b04), X(0x7fd85372), X(0x7fe21a99), X(0x7fe9f791), | ||
84 | X(0x7ff02d58), X(0x7ff4fa9e), X(0x7ff89990), X(0x7ffb3faa), | ||
85 | X(0x7ffd1d8b), X(0x7ffe5ecc), X(0x7fff29e0), X(0x7fff9ff3), | ||
86 | X(0x7fffdcd2), X(0x7ffff6d6), X(0x7ffffed0), X(0x7ffffffc), | ||
87 | }; | ||
88 | |||
89 | static LOOKUP_T vwin512[256] = { | ||
90 | X(0x00007c06), X(0x00045c32), X(0x000c1c62), X(0x0017bc4c), | ||
91 | X(0x00273b7a), X(0x003a9955), X(0x0051d51c), X(0x006cede7), | ||
92 | X(0x008be2a9), X(0x00aeb22a), X(0x00d55b0d), X(0x00ffdbcc), | ||
93 | X(0x012e32b6), X(0x01605df5), X(0x01965b85), X(0x01d02939), | ||
94 | X(0x020dc4ba), X(0x024f2b83), X(0x02945ae6), X(0x02dd5004), | ||
95 | X(0x032a07d3), X(0x037a7f19), X(0x03ceb26e), X(0x04269e37), | ||
96 | X(0x04823eab), X(0x04e18fcc), X(0x05448d6d), X(0x05ab3329), | ||
97 | X(0x06157c68), X(0x0683645e), X(0x06f4e607), X(0x0769fc25), | ||
98 | X(0x07e2a146), X(0x085ecfbc), X(0x08de819f), X(0x0961b0cc), | ||
99 | X(0x09e856e3), X(0x0a726d46), X(0x0affed1d), X(0x0b90cf4c), | ||
100 | X(0x0c250c79), X(0x0cbc9d0b), X(0x0d577926), X(0x0df598aa), | ||
101 | X(0x0e96f337), X(0x0f3b8026), X(0x0fe3368f), X(0x108e0d42), | ||
102 | X(0x113bfaca), X(0x11ecf56b), X(0x12a0f324), X(0x1357e9ac), | ||
103 | X(0x1411ce70), X(0x14ce9698), X(0x158e3702), X(0x1650a444), | ||
104 | X(0x1715d2aa), X(0x17ddb638), X(0x18a842aa), X(0x19756b72), | ||
105 | X(0x1a4523b9), X(0x1b175e62), X(0x1bec0e04), X(0x1cc324f0), | ||
106 | X(0x1d9c9532), X(0x1e78508a), X(0x1f564876), X(0x20366e2e), | ||
107 | X(0x2118b2a2), X(0x21fd0681), X(0x22e35a37), X(0x23cb9dee), | ||
108 | X(0x24b5c18e), X(0x25a1b4c0), X(0x268f66f1), X(0x277ec74e), | ||
109 | X(0x286fc4cc), X(0x29624e23), X(0x2a5651d7), X(0x2b4bbe34), | ||
110 | X(0x2c428150), X(0x2d3a8913), X(0x2e33c332), X(0x2f2e1d35), | ||
111 | X(0x30298478), X(0x3125e62d), X(0x32232f61), X(0x33214cfc), | ||
112 | X(0x34202bc2), X(0x351fb85a), X(0x361fdf4f), X(0x37208d10), | ||
113 | X(0x3821adf7), X(0x39232e49), X(0x3a24fa3c), X(0x3b26fdf6), | ||
114 | X(0x3c292593), X(0x3d2b5d29), X(0x3e2d90c8), X(0x3f2fac7f), | ||
115 | X(0x40319c5f), X(0x41334c81), X(0x4234a905), X(0x43359e16), | ||
116 | X(0x443617f3), X(0x453602eb), X(0x46354b65), X(0x4733dde1), | ||
117 | X(0x4831a6ff), X(0x492e937f), X(0x4a2a9045), X(0x4b258a5f), | ||
118 | X(0x4c1f6f06), X(0x4d182ba2), X(0x4e0fadce), X(0x4f05e35b), | ||
119 | X(0x4ffaba53), X(0x50ee20fd), X(0x51e005e1), X(0x52d057ca), | ||
120 | X(0x53bf05ca), X(0x54abff3b), X(0x559733c7), X(0x56809365), | ||
121 | X(0x57680e62), X(0x584d955d), X(0x59311952), X(0x5a128b96), | ||
122 | X(0x5af1dddd), X(0x5bcf023a), X(0x5ca9eb27), X(0x5d828b81), | ||
123 | X(0x5e58d68d), X(0x5f2cbffc), X(0x5ffe3be9), X(0x60cd3edf), | ||
124 | X(0x6199bdda), X(0x6263ae45), X(0x632b0602), X(0x63efbb66), | ||
125 | X(0x64b1c53f), X(0x65711ad0), X(0x662db3d7), X(0x66e7888d), | ||
126 | X(0x679e91a5), X(0x6852c84e), X(0x69042635), X(0x69b2a582), | ||
127 | X(0x6a5e40dd), X(0x6b06f36c), X(0x6bacb8d2), X(0x6c4f8d30), | ||
128 | X(0x6cef6d26), X(0x6d8c55d4), X(0x6e2644d4), X(0x6ebd3840), | ||
129 | X(0x6f512ead), X(0x6fe2272e), X(0x7070214f), X(0x70fb1d17), | ||
130 | X(0x71831b06), X(0x72081c16), X(0x728a21b5), X(0x73092dc8), | ||
131 | X(0x738542a6), X(0x73fe631b), X(0x74749261), X(0x74e7d421), | ||
132 | X(0x75582c72), X(0x75c59fd5), X(0x76303333), X(0x7697ebdd), | ||
133 | X(0x76fccf85), X(0x775ee443), X(0x77be308a), X(0x781abb2e), | ||
134 | X(0x78748b59), X(0x78cba88e), X(0x79201aa7), X(0x7971e9cd), | ||
135 | X(0x79c11e79), X(0x7a0dc170), X(0x7a57dbc2), X(0x7a9f76c1), | ||
136 | X(0x7ae49c07), X(0x7b27556b), X(0x7b67ad02), X(0x7ba5ad1b), | ||
137 | X(0x7be1603a), X(0x7c1ad118), X(0x7c520a9e), X(0x7c8717e1), | ||
138 | X(0x7cba0421), X(0x7ceadac3), X(0x7d19a74f), X(0x7d46756e), | ||
139 | X(0x7d7150e5), X(0x7d9a4592), X(0x7dc15f69), X(0x7de6aa71), | ||
140 | X(0x7e0a32c0), X(0x7e2c0479), X(0x7e4c2bc7), X(0x7e6ab4db), | ||
141 | X(0x7e87abe9), X(0x7ea31d24), X(0x7ebd14be), X(0x7ed59edd), | ||
142 | X(0x7eecc7a3), X(0x7f029b21), X(0x7f17255a), X(0x7f2a723f), | ||
143 | X(0x7f3c8daa), X(0x7f4d835d), X(0x7f5d5f00), X(0x7f6c2c1b), | ||
144 | X(0x7f79f617), X(0x7f86c83a), X(0x7f92ada2), X(0x7f9db146), | ||
145 | X(0x7fa7ddf3), X(0x7fb13e46), X(0x7fb9dcb0), X(0x7fc1c36c), | ||
146 | X(0x7fc8fc83), X(0x7fcf91c7), X(0x7fd58cd2), X(0x7fdaf702), | ||
147 | X(0x7fdfd979), X(0x7fe43d1c), X(0x7fe82a8b), X(0x7febaa29), | ||
148 | X(0x7feec412), X(0x7ff1801c), X(0x7ff3e5d6), X(0x7ff5fc86), | ||
149 | X(0x7ff7cb29), X(0x7ff9586f), X(0x7ffaaaba), X(0x7ffbc81e), | ||
150 | X(0x7ffcb660), X(0x7ffd7af3), X(0x7ffe1afa), X(0x7ffe9b42), | ||
151 | X(0x7fff0047), X(0x7fff4e2f), X(0x7fff88c9), X(0x7fffb390), | ||
152 | X(0x7fffd1a6), X(0x7fffe5d7), X(0x7ffff296), X(0x7ffff9fd), | ||
153 | X(0x7ffffdcd), X(0x7fffff6d), X(0x7fffffed), X(0x7fffffff), | ||
154 | }; | ||
155 | |||
156 | static LOOKUP_T vwin1024[512] = { | ||
157 | X(0x00001f02), X(0x0001170e), X(0x00030724), X(0x0005ef40), | ||
158 | X(0x0009cf59), X(0x000ea767), X(0x0014775e), X(0x001b3f2e), | ||
159 | X(0x0022fec8), X(0x002bb618), X(0x00356508), X(0x00400b81), | ||
160 | X(0x004ba968), X(0x00583ea0), X(0x0065cb0a), X(0x00744e84), | ||
161 | X(0x0083c8ea), X(0x00943a14), X(0x00a5a1da), X(0x00b80010), | ||
162 | X(0x00cb5488), X(0x00df9f10), X(0x00f4df76), X(0x010b1584), | ||
163 | X(0x01224101), X(0x013a61b2), X(0x01537759), X(0x016d81b6), | ||
164 | X(0x01888087), X(0x01a47385), X(0x01c15a69), X(0x01df34e6), | ||
165 | X(0x01fe02b1), X(0x021dc377), X(0x023e76e7), X(0x02601ca9), | ||
166 | X(0x0282b466), X(0x02a63dc1), X(0x02cab85d), X(0x02f023d6), | ||
167 | X(0x03167fcb), X(0x033dcbd3), X(0x03660783), X(0x038f3270), | ||
168 | X(0x03b94c29), X(0x03e4543a), X(0x04104a2e), X(0x043d2d8b), | ||
169 | X(0x046afdd5), X(0x0499ba8c), X(0x04c9632d), X(0x04f9f734), | ||
170 | X(0x052b7615), X(0x055ddf46), X(0x05913237), X(0x05c56e53), | ||
171 | X(0x05fa9306), X(0x06309fb6), X(0x066793c5), X(0x069f6e93), | ||
172 | X(0x06d82f7c), X(0x0711d5d9), X(0x074c60fe), X(0x0787d03d), | ||
173 | X(0x07c422e4), X(0x0801583e), X(0x083f6f91), X(0x087e681f), | ||
174 | X(0x08be4129), X(0x08fef9ea), X(0x0940919a), X(0x0983076d), | ||
175 | X(0x09c65a92), X(0x0a0a8a38), X(0x0a4f9585), X(0x0a957b9f), | ||
176 | X(0x0adc3ba7), X(0x0b23d4b9), X(0x0b6c45ee), X(0x0bb58e5a), | ||
177 | X(0x0bffad0f), X(0x0c4aa11a), X(0x0c966982), X(0x0ce3054d), | ||
178 | X(0x0d30737b), X(0x0d7eb308), X(0x0dcdc2eb), X(0x0e1da21a), | ||
179 | X(0x0e6e4f83), X(0x0ebfca11), X(0x0f1210ad), X(0x0f652238), | ||
180 | X(0x0fb8fd91), X(0x100da192), X(0x10630d11), X(0x10b93ee0), | ||
181 | X(0x111035cb), X(0x1167f09a), X(0x11c06e13), X(0x1219acf5), | ||
182 | X(0x1273abfb), X(0x12ce69db), X(0x1329e54a), X(0x13861cf3), | ||
183 | X(0x13e30f80), X(0x1440bb97), X(0x149f1fd8), X(0x14fe3ade), | ||
184 | X(0x155e0b40), X(0x15be8f92), X(0x161fc662), X(0x1681ae38), | ||
185 | X(0x16e4459b), X(0x17478b0b), X(0x17ab7d03), X(0x181019fb), | ||
186 | X(0x18756067), X(0x18db4eb3), X(0x1941e34a), X(0x19a91c92), | ||
187 | X(0x1a10f8ea), X(0x1a7976af), X(0x1ae29439), X(0x1b4c4fda), | ||
188 | X(0x1bb6a7e2), X(0x1c219a9a), X(0x1c8d2649), X(0x1cf9492e), | ||
189 | X(0x1d660188), X(0x1dd34d8e), X(0x1e412b74), X(0x1eaf996a), | ||
190 | X(0x1f1e959b), X(0x1f8e1e2f), X(0x1ffe3146), X(0x206ecd01), | ||
191 | X(0x20dfef78), X(0x215196c2), X(0x21c3c0f0), X(0x22366c10), | ||
192 | X(0x22a9962a), X(0x231d3d45), X(0x23915f60), X(0x2405fa7a), | ||
193 | X(0x247b0c8c), X(0x24f09389), X(0x25668d65), X(0x25dcf80c), | ||
194 | X(0x2653d167), X(0x26cb175e), X(0x2742c7d0), X(0x27bae09e), | ||
195 | X(0x28335fa2), X(0x28ac42b3), X(0x292587a5), X(0x299f2c48), | ||
196 | X(0x2a192e69), X(0x2a938bd1), X(0x2b0e4247), X(0x2b894f8d), | ||
197 | X(0x2c04b164), X(0x2c806588), X(0x2cfc69b2), X(0x2d78bb9a), | ||
198 | X(0x2df558f4), X(0x2e723f6f), X(0x2eef6cbb), X(0x2f6cde83), | ||
199 | X(0x2fea9270), X(0x30688627), X(0x30e6b74e), X(0x31652385), | ||
200 | X(0x31e3c86b), X(0x3262a39e), X(0x32e1b2b8), X(0x3360f352), | ||
201 | X(0x33e06303), X(0x345fff5e), X(0x34dfc5f8), X(0x355fb462), | ||
202 | X(0x35dfc82a), X(0x365ffee0), X(0x36e0560f), X(0x3760cb43), | ||
203 | X(0x37e15c05), X(0x386205df), X(0x38e2c657), X(0x39639af5), | ||
204 | X(0x39e4813e), X(0x3a6576b6), X(0x3ae678e3), X(0x3b678547), | ||
205 | X(0x3be89965), X(0x3c69b2c1), X(0x3ceacedc), X(0x3d6beb37), | ||
206 | X(0x3ded0557), X(0x3e6e1abb), X(0x3eef28e6), X(0x3f702d5a), | ||
207 | X(0x3ff1259a), X(0x40720f29), X(0x40f2e789), X(0x4173ac3f), | ||
208 | X(0x41f45ad0), X(0x4274f0c2), X(0x42f56b9a), X(0x4375c8e0), | ||
209 | X(0x43f6061d), X(0x447620db), X(0x44f616a5), X(0x4575e509), | ||
210 | X(0x45f58994), X(0x467501d6), X(0x46f44b62), X(0x477363cb), | ||
211 | X(0x47f248a6), X(0x4870f78e), X(0x48ef6e1a), X(0x496da9e8), | ||
212 | X(0x49eba897), X(0x4a6967c8), X(0x4ae6e521), X(0x4b641e47), | ||
213 | X(0x4be110e5), X(0x4c5dbaa7), X(0x4cda193f), X(0x4d562a5f), | ||
214 | X(0x4dd1ebbd), X(0x4e4d5b15), X(0x4ec87623), X(0x4f433aa9), | ||
215 | X(0x4fbda66c), X(0x5037b734), X(0x50b16acf), X(0x512abf0e), | ||
216 | X(0x51a3b1c5), X(0x521c40ce), X(0x52946a06), X(0x530c2b50), | ||
217 | X(0x53838292), X(0x53fa6db8), X(0x5470eab3), X(0x54e6f776), | ||
218 | X(0x555c91fc), X(0x55d1b844), X(0x56466851), X(0x56baa02f), | ||
219 | X(0x572e5deb), X(0x57a19f98), X(0x58146352), X(0x5886a737), | ||
220 | X(0x58f8696d), X(0x5969a81c), X(0x59da6177), X(0x5a4a93b4), | ||
221 | X(0x5aba3d0f), X(0x5b295bcb), X(0x5b97ee30), X(0x5c05f28d), | ||
222 | X(0x5c736738), X(0x5ce04a8d), X(0x5d4c9aed), X(0x5db856c1), | ||
223 | X(0x5e237c78), X(0x5e8e0a89), X(0x5ef7ff6f), X(0x5f6159b0), | ||
224 | X(0x5fca17d4), X(0x6032386e), X(0x6099ba15), X(0x61009b69), | ||
225 | X(0x6166db11), X(0x61cc77b9), X(0x62317017), X(0x6295c2e7), | ||
226 | X(0x62f96eec), X(0x635c72f1), X(0x63becdc8), X(0x64207e4b), | ||
227 | X(0x6481835a), X(0x64e1dbde), X(0x654186c8), X(0x65a0830e), | ||
228 | X(0x65fecfb1), X(0x665c6bb7), X(0x66b95630), X(0x67158e30), | ||
229 | X(0x677112d7), X(0x67cbe34b), X(0x6825feb9), X(0x687f6456), | ||
230 | X(0x68d81361), X(0x69300b1e), X(0x69874ada), X(0x69ddd1ea), | ||
231 | X(0x6a339fab), X(0x6a88b382), X(0x6add0cdb), X(0x6b30ab2a), | ||
232 | X(0x6b838dec), X(0x6bd5b4a6), X(0x6c271ee2), X(0x6c77cc36), | ||
233 | X(0x6cc7bc3d), X(0x6d16ee9b), X(0x6d6562fb), X(0x6db31911), | ||
234 | X(0x6e001099), X(0x6e4c4955), X(0x6e97c311), X(0x6ee27d9f), | ||
235 | X(0x6f2c78d9), X(0x6f75b4a2), X(0x6fbe30e4), X(0x7005ed91), | ||
236 | X(0x704ceaa1), X(0x70932816), X(0x70d8a5f8), X(0x711d6457), | ||
237 | X(0x7161634b), X(0x71a4a2f3), X(0x71e72375), X(0x7228e500), | ||
238 | X(0x7269e7c8), X(0x72aa2c0a), X(0x72e9b209), X(0x73287a12), | ||
239 | X(0x73668476), X(0x73a3d18f), X(0x73e061bc), X(0x741c3566), | ||
240 | X(0x74574cfa), X(0x7491a8ee), X(0x74cb49be), X(0x75042fec), | ||
241 | X(0x753c5c03), X(0x7573ce92), X(0x75aa882f), X(0x75e08979), | ||
242 | X(0x7615d313), X(0x764a65a7), X(0x767e41e5), X(0x76b16884), | ||
243 | X(0x76e3da40), X(0x771597dc), X(0x7746a221), X(0x7776f9dd), | ||
244 | X(0x77a69fe6), X(0x77d59514), X(0x7803da49), X(0x7831706a), | ||
245 | X(0x785e5861), X(0x788a9320), X(0x78b6219c), X(0x78e104cf), | ||
246 | X(0x790b3dbb), X(0x7934cd64), X(0x795db4d5), X(0x7985f51d), | ||
247 | X(0x79ad8f50), X(0x79d48486), X(0x79fad5de), X(0x7a208478), | ||
248 | X(0x7a45917b), X(0x7a69fe12), X(0x7a8dcb6c), X(0x7ab0fabb), | ||
249 | X(0x7ad38d36), X(0x7af5841a), X(0x7b16e0a3), X(0x7b37a416), | ||
250 | X(0x7b57cfb8), X(0x7b7764d4), X(0x7b9664b6), X(0x7bb4d0b0), | ||
251 | X(0x7bd2aa14), X(0x7beff23b), X(0x7c0caa7f), X(0x7c28d43c), | ||
252 | X(0x7c4470d2), X(0x7c5f81a5), X(0x7c7a081a), X(0x7c940598), | ||
253 | X(0x7cad7b8b), X(0x7cc66b5e), X(0x7cded680), X(0x7cf6be64), | ||
254 | X(0x7d0e247b), X(0x7d250a3c), X(0x7d3b711c), X(0x7d515a95), | ||
255 | X(0x7d66c822), X(0x7d7bbb3c), X(0x7d903563), X(0x7da43814), | ||
256 | X(0x7db7c4d0), X(0x7dcadd16), X(0x7ddd826a), X(0x7defb64d), | ||
257 | X(0x7e017a44), X(0x7e12cfd3), X(0x7e23b87f), X(0x7e3435cc), | ||
258 | X(0x7e444943), X(0x7e53f467), X(0x7e6338c0), X(0x7e7217d5), | ||
259 | X(0x7e80932b), X(0x7e8eac49), X(0x7e9c64b7), X(0x7ea9bdf8), | ||
260 | X(0x7eb6b994), X(0x7ec35910), X(0x7ecf9def), X(0x7edb89b6), | ||
261 | X(0x7ee71de9), X(0x7ef25c09), X(0x7efd4598), X(0x7f07dc16), | ||
262 | X(0x7f122103), X(0x7f1c15dc), X(0x7f25bc1f), X(0x7f2f1547), | ||
263 | X(0x7f3822cd), X(0x7f40e62b), X(0x7f4960d6), X(0x7f519443), | ||
264 | X(0x7f5981e7), X(0x7f612b31), X(0x7f689191), X(0x7f6fb674), | ||
265 | X(0x7f769b45), X(0x7f7d416c), X(0x7f83aa51), X(0x7f89d757), | ||
266 | X(0x7f8fc9df), X(0x7f958348), X(0x7f9b04ef), X(0x7fa0502e), | ||
267 | X(0x7fa56659), X(0x7faa48c7), X(0x7faef8c7), X(0x7fb377a7), | ||
268 | X(0x7fb7c6b3), X(0x7fbbe732), X(0x7fbfda67), X(0x7fc3a196), | ||
269 | X(0x7fc73dfa), X(0x7fcab0ce), X(0x7fcdfb4a), X(0x7fd11ea0), | ||
270 | X(0x7fd41c00), X(0x7fd6f496), X(0x7fd9a989), X(0x7fdc3bff), | ||
271 | X(0x7fdead17), X(0x7fe0fdee), X(0x7fe32f9d), X(0x7fe54337), | ||
272 | X(0x7fe739ce), X(0x7fe9146c), X(0x7fead41b), X(0x7fec79dd), | ||
273 | X(0x7fee06b2), X(0x7fef7b94), X(0x7ff0d97b), X(0x7ff22158), | ||
274 | X(0x7ff35417), X(0x7ff472a3), X(0x7ff57de0), X(0x7ff676ac), | ||
275 | X(0x7ff75de3), X(0x7ff8345a), X(0x7ff8fae4), X(0x7ff9b24b), | ||
276 | X(0x7ffa5b58), X(0x7ffaf6cd), X(0x7ffb8568), X(0x7ffc07e2), | ||
277 | X(0x7ffc7eed), X(0x7ffceb38), X(0x7ffd4d6d), X(0x7ffda631), | ||
278 | X(0x7ffdf621), X(0x7ffe3dd8), X(0x7ffe7dea), X(0x7ffeb6e7), | ||
279 | X(0x7ffee959), X(0x7fff15c4), X(0x7fff3ca9), X(0x7fff5e80), | ||
280 | X(0x7fff7bc0), X(0x7fff94d6), X(0x7fffaa2d), X(0x7fffbc29), | ||
281 | X(0x7fffcb29), X(0x7fffd786), X(0x7fffe195), X(0x7fffe9a3), | ||
282 | X(0x7fffeffa), X(0x7ffff4dd), X(0x7ffff889), X(0x7ffffb37), | ||
283 | X(0x7ffffd1a), X(0x7ffffe5d), X(0x7fffff29), X(0x7fffffa0), | ||
284 | X(0x7fffffdd), X(0x7ffffff7), X(0x7fffffff), X(0x7fffffff), | ||
285 | }; | ||
286 | |||
287 | static LOOKUP_T vwin2048[1024] = { | ||
288 | X(0x000007c0), X(0x000045c4), X(0x0000c1ca), X(0x00017bd3), | ||
289 | X(0x000273de), X(0x0003a9eb), X(0x00051df9), X(0x0006d007), | ||
290 | X(0x0008c014), X(0x000aee1e), X(0x000d5a25), X(0x00100428), | ||
291 | X(0x0012ec23), X(0x00161216), X(0x001975fe), X(0x001d17da), | ||
292 | X(0x0020f7a8), X(0x00251564), X(0x0029710c), X(0x002e0a9e), | ||
293 | X(0x0032e217), X(0x0037f773), X(0x003d4ab0), X(0x0042dbca), | ||
294 | X(0x0048aabe), X(0x004eb788), X(0x00550224), X(0x005b8a8f), | ||
295 | X(0x006250c5), X(0x006954c1), X(0x0070967e), X(0x007815f9), | ||
296 | X(0x007fd32c), X(0x0087ce13), X(0x009006a9), X(0x00987ce9), | ||
297 | X(0x00a130cc), X(0x00aa224f), X(0x00b3516b), X(0x00bcbe1a), | ||
298 | X(0x00c66856), X(0x00d0501a), X(0x00da755f), X(0x00e4d81f), | ||
299 | X(0x00ef7853), X(0x00fa55f4), X(0x010570fc), X(0x0110c963), | ||
300 | X(0x011c5f22), X(0x01283232), X(0x0134428c), X(0x01409027), | ||
301 | X(0x014d1afb), X(0x0159e302), X(0x0166e831), X(0x01742a82), | ||
302 | X(0x0181a9ec), X(0x018f6665), X(0x019d5fe5), X(0x01ab9663), | ||
303 | X(0x01ba09d6), X(0x01c8ba34), X(0x01d7a775), X(0x01e6d18d), | ||
304 | X(0x01f63873), X(0x0205dc1e), X(0x0215bc82), X(0x0225d997), | ||
305 | X(0x02363350), X(0x0246c9a3), X(0x02579c86), X(0x0268abed), | ||
306 | X(0x0279f7cc), X(0x028b801a), X(0x029d44c9), X(0x02af45ce), | ||
307 | X(0x02c1831d), X(0x02d3fcaa), X(0x02e6b269), X(0x02f9a44c), | ||
308 | X(0x030cd248), X(0x03203c4f), X(0x0333e255), X(0x0347c44b), | ||
309 | X(0x035be225), X(0x03703bd5), X(0x0384d14d), X(0x0399a280), | ||
310 | X(0x03aeaf5e), X(0x03c3f7d9), X(0x03d97be4), X(0x03ef3b6e), | ||
311 | X(0x0405366a), X(0x041b6cc8), X(0x0431de78), X(0x04488b6c), | ||
312 | X(0x045f7393), X(0x047696dd), X(0x048df53b), X(0x04a58e9b), | ||
313 | X(0x04bd62ee), X(0x04d57223), X(0x04edbc28), X(0x050640ed), | ||
314 | X(0x051f0060), X(0x0537fa70), X(0x05512f0a), X(0x056a9e1e), | ||
315 | X(0x05844798), X(0x059e2b67), X(0x05b84978), X(0x05d2a1b8), | ||
316 | X(0x05ed3414), X(0x06080079), X(0x062306d3), X(0x063e470f), | ||
317 | X(0x0659c119), X(0x067574dd), X(0x06916247), X(0x06ad8941), | ||
318 | X(0x06c9e9b8), X(0x06e68397), X(0x070356c8), X(0x07206336), | ||
319 | X(0x073da8cb), X(0x075b2772), X(0x0778df15), X(0x0796cf9c), | ||
320 | X(0x07b4f8f3), X(0x07d35b01), X(0x07f1f5b1), X(0x0810c8eb), | ||
321 | X(0x082fd497), X(0x084f189e), X(0x086e94e9), X(0x088e495e), | ||
322 | X(0x08ae35e6), X(0x08ce5a68), X(0x08eeb6cc), X(0x090f4af8), | ||
323 | X(0x093016d3), X(0x09511a44), X(0x09725530), X(0x0993c77f), | ||
324 | X(0x09b57115), X(0x09d751d8), X(0x09f969ae), X(0x0a1bb87c), | ||
325 | X(0x0a3e3e26), X(0x0a60fa91), X(0x0a83eda2), X(0x0aa7173c), | ||
326 | X(0x0aca7743), X(0x0aee0d9b), X(0x0b11da28), X(0x0b35dccc), | ||
327 | X(0x0b5a156a), X(0x0b7e83e5), X(0x0ba3281f), X(0x0bc801fa), | ||
328 | X(0x0bed1159), X(0x0c12561c), X(0x0c37d025), X(0x0c5d7f55), | ||
329 | X(0x0c83638d), X(0x0ca97cae), X(0x0ccfca97), X(0x0cf64d2a), | ||
330 | X(0x0d1d0444), X(0x0d43efc7), X(0x0d6b0f92), X(0x0d926383), | ||
331 | X(0x0db9eb79), X(0x0de1a752), X(0x0e0996ee), X(0x0e31ba29), | ||
332 | X(0x0e5a10e2), X(0x0e829af6), X(0x0eab5841), X(0x0ed448a2), | ||
333 | X(0x0efd6bf4), X(0x0f26c214), X(0x0f504ade), X(0x0f7a062e), | ||
334 | X(0x0fa3f3df), X(0x0fce13cd), X(0x0ff865d2), X(0x1022e9ca), | ||
335 | X(0x104d9f8e), X(0x107886f9), X(0x10a39fe5), X(0x10ceea2c), | ||
336 | X(0x10fa65a6), X(0x1126122d), X(0x1151ef9a), X(0x117dfdc5), | ||
337 | X(0x11aa3c87), X(0x11d6abb6), X(0x12034b2c), X(0x12301ac0), | ||
338 | X(0x125d1a48), X(0x128a499b), X(0x12b7a891), X(0x12e536ff), | ||
339 | X(0x1312f4bb), X(0x1340e19c), X(0x136efd75), X(0x139d481e), | ||
340 | X(0x13cbc16a), X(0x13fa692f), X(0x14293f40), X(0x14584371), | ||
341 | X(0x14877597), X(0x14b6d585), X(0x14e6630d), X(0x15161e04), | ||
342 | X(0x1546063b), X(0x15761b85), X(0x15a65db3), X(0x15d6cc99), | ||
343 | X(0x16076806), X(0x16382fcd), X(0x166923bf), X(0x169a43ab), | ||
344 | X(0x16cb8f62), X(0x16fd06b5), X(0x172ea973), X(0x1760776b), | ||
345 | X(0x1792706e), X(0x17c49449), X(0x17f6e2cb), X(0x18295bc3), | ||
346 | X(0x185bfeff), X(0x188ecc4c), X(0x18c1c379), X(0x18f4e452), | ||
347 | X(0x19282ea4), X(0x195ba23c), X(0x198f3ee6), X(0x19c3046e), | ||
348 | X(0x19f6f2a1), X(0x1a2b094a), X(0x1a5f4833), X(0x1a93af28), | ||
349 | X(0x1ac83df3), X(0x1afcf460), X(0x1b31d237), X(0x1b66d744), | ||
350 | X(0x1b9c034e), X(0x1bd15621), X(0x1c06cf84), X(0x1c3c6f40), | ||
351 | X(0x1c72351e), X(0x1ca820e6), X(0x1cde3260), X(0x1d146953), | ||
352 | X(0x1d4ac587), X(0x1d8146c3), X(0x1db7eccd), X(0x1deeb76c), | ||
353 | X(0x1e25a667), X(0x1e5cb982), X(0x1e93f085), X(0x1ecb4b33), | ||
354 | X(0x1f02c953), X(0x1f3a6aaa), X(0x1f722efb), X(0x1faa160b), | ||
355 | X(0x1fe21f9e), X(0x201a4b79), X(0x2052995d), X(0x208b0910), | ||
356 | X(0x20c39a53), X(0x20fc4cea), X(0x21352097), X(0x216e151c), | ||
357 | X(0x21a72a3a), X(0x21e05fb5), X(0x2219b54d), X(0x22532ac3), | ||
358 | X(0x228cbfd8), X(0x22c6744d), X(0x230047e2), X(0x233a3a58), | ||
359 | X(0x23744b6d), X(0x23ae7ae3), X(0x23e8c878), X(0x242333ec), | ||
360 | X(0x245dbcfd), X(0x24986369), X(0x24d326f1), X(0x250e0750), | ||
361 | X(0x25490446), X(0x25841d90), X(0x25bf52ec), X(0x25faa417), | ||
362 | X(0x263610cd), X(0x267198cc), X(0x26ad3bcf), X(0x26e8f994), | ||
363 | X(0x2724d1d6), X(0x2760c451), X(0x279cd0c0), X(0x27d8f6e0), | ||
364 | X(0x2815366a), X(0x28518f1b), X(0x288e00ac), X(0x28ca8ad8), | ||
365 | X(0x29072d5a), X(0x2943e7eb), X(0x2980ba45), X(0x29bda422), | ||
366 | X(0x29faa53c), X(0x2a37bd4a), X(0x2a74ec07), X(0x2ab2312b), | ||
367 | X(0x2aef8c6f), X(0x2b2cfd8b), X(0x2b6a8437), X(0x2ba8202c), | ||
368 | X(0x2be5d120), X(0x2c2396cc), X(0x2c6170e7), X(0x2c9f5f29), | ||
369 | X(0x2cdd6147), X(0x2d1b76fa), X(0x2d599ff7), X(0x2d97dbf5), | ||
370 | X(0x2dd62aab), X(0x2e148bcf), X(0x2e52ff16), X(0x2e918436), | ||
371 | X(0x2ed01ae5), X(0x2f0ec2d9), X(0x2f4d7bc6), X(0x2f8c4562), | ||
372 | X(0x2fcb1f62), X(0x300a097a), X(0x3049035f), X(0x30880cc6), | ||
373 | X(0x30c72563), X(0x31064cea), X(0x3145830f), X(0x3184c786), | ||
374 | X(0x31c41a03), X(0x32037a39), X(0x3242e7dc), X(0x3282629f), | ||
375 | X(0x32c1ea36), X(0x33017e53), X(0x33411ea9), X(0x3380caec), | ||
376 | X(0x33c082ce), X(0x34004602), X(0x34401439), X(0x347fed27), | ||
377 | X(0x34bfd07e), X(0x34ffbdf0), X(0x353fb52e), X(0x357fb5ec), | ||
378 | X(0x35bfbfda), X(0x35ffd2aa), X(0x363fee0f), X(0x368011b9), | ||
379 | X(0x36c03d5a), X(0x370070a4), X(0x3740ab48), X(0x3780ecf7), | ||
380 | X(0x37c13562), X(0x3801843a), X(0x3841d931), X(0x388233f7), | ||
381 | X(0x38c2943d), X(0x3902f9b4), X(0x3943640d), X(0x3983d2f8), | ||
382 | X(0x39c44626), X(0x3a04bd48), X(0x3a45380e), X(0x3a85b62a), | ||
383 | X(0x3ac6374a), X(0x3b06bb20), X(0x3b47415c), X(0x3b87c9ae), | ||
384 | X(0x3bc853c7), X(0x3c08df57), X(0x3c496c0f), X(0x3c89f99f), | ||
385 | X(0x3cca87b6), X(0x3d0b1605), X(0x3d4ba43d), X(0x3d8c320e), | ||
386 | X(0x3dccbf27), X(0x3e0d4b3a), X(0x3e4dd5f6), X(0x3e8e5f0c), | ||
387 | X(0x3ecee62b), X(0x3f0f6b05), X(0x3f4fed49), X(0x3f906ca8), | ||
388 | X(0x3fd0e8d2), X(0x40116177), X(0x4051d648), X(0x409246f6), | ||
389 | X(0x40d2b330), X(0x41131aa7), X(0x41537d0c), X(0x4193da10), | ||
390 | X(0x41d43162), X(0x421482b4), X(0x4254cdb7), X(0x4295121b), | ||
391 | X(0x42d54f91), X(0x431585ca), X(0x4355b477), X(0x4395db49), | ||
392 | X(0x43d5f9f1), X(0x44161021), X(0x44561d8a), X(0x449621dd), | ||
393 | X(0x44d61ccc), X(0x45160e08), X(0x4555f544), X(0x4595d230), | ||
394 | X(0x45d5a47f), X(0x46156be3), X(0x4655280e), X(0x4694d8b2), | ||
395 | X(0x46d47d82), X(0x4714162f), X(0x4753a26d), X(0x479321ef), | ||
396 | X(0x47d29466), X(0x4811f987), X(0x48515104), X(0x48909a91), | ||
397 | X(0x48cfd5e1), X(0x490f02a7), X(0x494e2098), X(0x498d2f66), | ||
398 | X(0x49cc2ec7), X(0x4a0b1e6f), X(0x4a49fe11), X(0x4a88cd62), | ||
399 | X(0x4ac78c18), X(0x4b0639e6), X(0x4b44d683), X(0x4b8361a2), | ||
400 | X(0x4bc1dafa), X(0x4c004241), X(0x4c3e972c), X(0x4c7cd970), | ||
401 | X(0x4cbb08c5), X(0x4cf924e1), X(0x4d372d7a), X(0x4d752247), | ||
402 | X(0x4db30300), X(0x4df0cf5a), X(0x4e2e870f), X(0x4e6c29d6), | ||
403 | X(0x4ea9b766), X(0x4ee72f78), X(0x4f2491c4), X(0x4f61de02), | ||
404 | X(0x4f9f13ec), X(0x4fdc333b), X(0x50193ba8), X(0x50562ced), | ||
405 | X(0x509306c3), X(0x50cfc8e5), X(0x510c730d), X(0x514904f6), | ||
406 | X(0x51857e5a), X(0x51c1def5), X(0x51fe2682), X(0x523a54bc), | ||
407 | X(0x52766961), X(0x52b2642c), X(0x52ee44d9), X(0x532a0b26), | ||
408 | X(0x5365b6d0), X(0x53a14793), X(0x53dcbd2f), X(0x54181760), | ||
409 | X(0x545355e5), X(0x548e787d), X(0x54c97ee6), X(0x550468e1), | ||
410 | X(0x553f362c), X(0x5579e687), X(0x55b479b3), X(0x55eeef70), | ||
411 | X(0x5629477f), X(0x566381a1), X(0x569d9d97), X(0x56d79b24), | ||
412 | X(0x57117a0a), X(0x574b3a0a), X(0x5784dae9), X(0x57be5c69), | ||
413 | X(0x57f7be4d), X(0x5831005a), X(0x586a2254), X(0x58a32400), | ||
414 | X(0x58dc0522), X(0x5914c57f), X(0x594d64de), X(0x5985e305), | ||
415 | X(0x59be3fba), X(0x59f67ac3), X(0x5a2e93e9), X(0x5a668af2), | ||
416 | X(0x5a9e5fa6), X(0x5ad611ce), X(0x5b0da133), X(0x5b450d9d), | ||
417 | X(0x5b7c56d7), X(0x5bb37ca9), X(0x5bea7ede), X(0x5c215d41), | ||
418 | X(0x5c58179d), X(0x5c8eadbe), X(0x5cc51f6f), X(0x5cfb6c7c), | ||
419 | X(0x5d3194b2), X(0x5d6797de), X(0x5d9d75cf), X(0x5dd32e51), | ||
420 | X(0x5e08c132), X(0x5e3e2e43), X(0x5e737551), X(0x5ea8962d), | ||
421 | X(0x5edd90a7), X(0x5f12648e), X(0x5f4711b4), X(0x5f7b97ea), | ||
422 | X(0x5faff702), X(0x5fe42ece), X(0x60183f20), X(0x604c27cc), | ||
423 | X(0x607fe8a6), X(0x60b38180), X(0x60e6f22f), X(0x611a3a89), | ||
424 | X(0x614d5a62), X(0x61805190), X(0x61b31fe9), X(0x61e5c545), | ||
425 | X(0x62184179), X(0x624a945d), X(0x627cbdca), X(0x62aebd98), | ||
426 | X(0x62e0939f), X(0x63123fba), X(0x6343c1c1), X(0x6375198f), | ||
427 | X(0x63a646ff), X(0x63d749ec), X(0x64082232), X(0x6438cfad), | ||
428 | X(0x64695238), X(0x6499a9b3), X(0x64c9d5f9), X(0x64f9d6ea), | ||
429 | X(0x6529ac63), X(0x65595643), X(0x6588d46a), X(0x65b826b8), | ||
430 | X(0x65e74d0e), X(0x6616474b), X(0x66451552), X(0x6673b704), | ||
431 | X(0x66a22c44), X(0x66d074f4), X(0x66fe90f8), X(0x672c8033), | ||
432 | X(0x675a428a), X(0x6787d7e1), X(0x67b5401f), X(0x67e27b27), | ||
433 | X(0x680f88e1), X(0x683c6934), X(0x68691c05), X(0x6895a13e), | ||
434 | X(0x68c1f8c7), X(0x68ee2287), X(0x691a1e68), X(0x6945ec54), | ||
435 | X(0x69718c35), X(0x699cfdf5), X(0x69c8417f), X(0x69f356c0), | ||
436 | X(0x6a1e3da3), X(0x6a48f615), X(0x6a738002), X(0x6a9ddb5a), | ||
437 | X(0x6ac80808), X(0x6af205fd), X(0x6b1bd526), X(0x6b457575), | ||
438 | X(0x6b6ee6d8), X(0x6b982940), X(0x6bc13c9f), X(0x6bea20e5), | ||
439 | X(0x6c12d605), X(0x6c3b5bf1), X(0x6c63b29c), X(0x6c8bd9fb), | ||
440 | X(0x6cb3d200), X(0x6cdb9aa0), X(0x6d0333d0), X(0x6d2a9d86), | ||
441 | X(0x6d51d7b7), X(0x6d78e25a), X(0x6d9fbd67), X(0x6dc668d3), | ||
442 | X(0x6dece498), X(0x6e1330ad), X(0x6e394d0c), X(0x6e5f39ae), | ||
443 | X(0x6e84f68d), X(0x6eaa83a2), X(0x6ecfe0ea), X(0x6ef50e5e), | ||
444 | X(0x6f1a0bfc), X(0x6f3ed9bf), X(0x6f6377a4), X(0x6f87e5a8), | ||
445 | X(0x6fac23c9), X(0x6fd03206), X(0x6ff4105c), X(0x7017becc), | ||
446 | X(0x703b3d54), X(0x705e8bf5), X(0x7081aaaf), X(0x70a49984), | ||
447 | X(0x70c75874), X(0x70e9e783), X(0x710c46b2), X(0x712e7605), | ||
448 | X(0x7150757f), X(0x71724523), X(0x7193e4f6), X(0x71b554fd), | ||
449 | X(0x71d6953e), X(0x71f7a5bd), X(0x72188681), X(0x72393792), | ||
450 | X(0x7259b8f5), X(0x727a0ab2), X(0x729a2cd2), X(0x72ba1f5d), | ||
451 | X(0x72d9e25c), X(0x72f975d8), X(0x7318d9db), X(0x73380e6f), | ||
452 | X(0x735713a0), X(0x7375e978), X(0x73949003), X(0x73b3074c), | ||
453 | X(0x73d14f61), X(0x73ef684f), X(0x740d5222), X(0x742b0ce9), | ||
454 | X(0x744898b1), X(0x7465f589), X(0x74832381), X(0x74a022a8), | ||
455 | X(0x74bcf30e), X(0x74d994c3), X(0x74f607d8), X(0x75124c5f), | ||
456 | X(0x752e6268), X(0x754a4a05), X(0x7566034b), X(0x75818e4a), | ||
457 | X(0x759ceb16), X(0x75b819c4), X(0x75d31a66), X(0x75eded12), | ||
458 | X(0x760891dc), X(0x762308da), X(0x763d5221), X(0x76576dc8), | ||
459 | X(0x76715be4), X(0x768b1c8c), X(0x76a4afd9), X(0x76be15e0), | ||
460 | X(0x76d74ebb), X(0x76f05a82), X(0x7709394d), X(0x7721eb35), | ||
461 | X(0x773a7054), X(0x7752c8c4), X(0x776af49f), X(0x7782f400), | ||
462 | X(0x779ac701), X(0x77b26dbd), X(0x77c9e851), X(0x77e136d8), | ||
463 | X(0x77f8596f), X(0x780f5032), X(0x78261b3f), X(0x783cbab2), | ||
464 | X(0x78532eaa), X(0x78697745), X(0x787f94a0), X(0x789586db), | ||
465 | X(0x78ab4e15), X(0x78c0ea6d), X(0x78d65c03), X(0x78eba2f7), | ||
466 | X(0x7900bf68), X(0x7915b179), X(0x792a7949), X(0x793f16fb), | ||
467 | X(0x79538aaf), X(0x7967d488), X(0x797bf4a8), X(0x798feb31), | ||
468 | X(0x79a3b846), X(0x79b75c0a), X(0x79cad6a1), X(0x79de282e), | ||
469 | X(0x79f150d5), X(0x7a0450bb), X(0x7a172803), X(0x7a29d6d3), | ||
470 | X(0x7a3c5d50), X(0x7a4ebb9f), X(0x7a60f1e6), X(0x7a73004a), | ||
471 | X(0x7a84e6f2), X(0x7a96a604), X(0x7aa83da7), X(0x7ab9ae01), | ||
472 | X(0x7acaf73a), X(0x7adc1979), X(0x7aed14e6), X(0x7afde9a8), | ||
473 | X(0x7b0e97e8), X(0x7b1f1fcd), X(0x7b2f8182), X(0x7b3fbd2d), | ||
474 | X(0x7b4fd2f9), X(0x7b5fc30f), X(0x7b6f8d98), X(0x7b7f32bd), | ||
475 | X(0x7b8eb2a9), X(0x7b9e0d85), X(0x7bad437d), X(0x7bbc54b9), | ||
476 | X(0x7bcb4166), X(0x7bda09ae), X(0x7be8adbc), X(0x7bf72dbc), | ||
477 | X(0x7c0589d8), X(0x7c13c23d), X(0x7c21d716), X(0x7c2fc88f), | ||
478 | X(0x7c3d96d5), X(0x7c4b4214), X(0x7c58ca78), X(0x7c66302d), | ||
479 | X(0x7c737362), X(0x7c809443), X(0x7c8d92fc), X(0x7c9a6fbc), | ||
480 | X(0x7ca72aaf), X(0x7cb3c404), X(0x7cc03be8), X(0x7ccc9288), | ||
481 | X(0x7cd8c814), X(0x7ce4dcb9), X(0x7cf0d0a5), X(0x7cfca406), | ||
482 | X(0x7d08570c), X(0x7d13e9e5), X(0x7d1f5cbf), X(0x7d2aafca), | ||
483 | X(0x7d35e335), X(0x7d40f72e), X(0x7d4bebe4), X(0x7d56c188), | ||
484 | X(0x7d617848), X(0x7d6c1054), X(0x7d7689db), X(0x7d80e50e), | ||
485 | X(0x7d8b221b), X(0x7d954133), X(0x7d9f4286), X(0x7da92643), | ||
486 | X(0x7db2ec9b), X(0x7dbc95bd), X(0x7dc621da), X(0x7dcf9123), | ||
487 | X(0x7dd8e3c6), X(0x7de219f6), X(0x7deb33e2), X(0x7df431ba), | ||
488 | X(0x7dfd13af), X(0x7e05d9f2), X(0x7e0e84b4), X(0x7e171424), | ||
489 | X(0x7e1f8874), X(0x7e27e1d4), X(0x7e302074), X(0x7e384487), | ||
490 | X(0x7e404e3c), X(0x7e483dc4), X(0x7e501350), X(0x7e57cf11), | ||
491 | X(0x7e5f7138), X(0x7e66f9f4), X(0x7e6e6979), X(0x7e75bff5), | ||
492 | X(0x7e7cfd9a), X(0x7e842298), X(0x7e8b2f22), X(0x7e922366), | ||
493 | X(0x7e98ff97), X(0x7e9fc3e4), X(0x7ea6707f), X(0x7ead0598), | ||
494 | X(0x7eb38360), X(0x7eb9ea07), X(0x7ec039bf), X(0x7ec672b7), | ||
495 | X(0x7ecc9521), X(0x7ed2a12c), X(0x7ed8970a), X(0x7ede76ea), | ||
496 | X(0x7ee440fd), X(0x7ee9f573), X(0x7eef947d), X(0x7ef51e4b), | ||
497 | X(0x7efa930d), X(0x7efff2f2), X(0x7f053e2b), X(0x7f0a74e8), | ||
498 | X(0x7f0f9758), X(0x7f14a5ac), X(0x7f19a013), X(0x7f1e86bc), | ||
499 | X(0x7f2359d8), X(0x7f281995), X(0x7f2cc623), X(0x7f315fb1), | ||
500 | X(0x7f35e66e), X(0x7f3a5a8a), X(0x7f3ebc33), X(0x7f430b98), | ||
501 | X(0x7f4748e7), X(0x7f4b7450), X(0x7f4f8e01), X(0x7f539629), | ||
502 | X(0x7f578cf5), X(0x7f5b7293), X(0x7f5f4732), X(0x7f630b00), | ||
503 | X(0x7f66be2b), X(0x7f6a60df), X(0x7f6df34b), X(0x7f71759b), | ||
504 | X(0x7f74e7fe), X(0x7f784aa0), X(0x7f7b9daf), X(0x7f7ee156), | ||
505 | X(0x7f8215c3), X(0x7f853b22), X(0x7f88519f), X(0x7f8b5967), | ||
506 | X(0x7f8e52a6), X(0x7f913d87), X(0x7f941a36), X(0x7f96e8df), | ||
507 | X(0x7f99a9ad), X(0x7f9c5ccb), X(0x7f9f0265), X(0x7fa19aa5), | ||
508 | X(0x7fa425b5), X(0x7fa6a3c1), X(0x7fa914f3), X(0x7fab7974), | ||
509 | X(0x7fadd16f), X(0x7fb01d0d), X(0x7fb25c78), X(0x7fb48fd9), | ||
510 | X(0x7fb6b75a), X(0x7fb8d323), X(0x7fbae35d), X(0x7fbce831), | ||
511 | X(0x7fbee1c7), X(0x7fc0d047), X(0x7fc2b3d9), X(0x7fc48ca5), | ||
512 | X(0x7fc65ad3), X(0x7fc81e88), X(0x7fc9d7ee), X(0x7fcb872a), | ||
513 | X(0x7fcd2c63), X(0x7fcec7bf), X(0x7fd05966), X(0x7fd1e17c), | ||
514 | X(0x7fd36027), X(0x7fd4d58d), X(0x7fd641d3), X(0x7fd7a51e), | ||
515 | X(0x7fd8ff94), X(0x7fda5157), X(0x7fdb9a8e), X(0x7fdcdb5b), | ||
516 | X(0x7fde13e2), X(0x7fdf4448), X(0x7fe06caf), X(0x7fe18d3b), | ||
517 | X(0x7fe2a60e), X(0x7fe3b74b), X(0x7fe4c114), X(0x7fe5c38b), | ||
518 | X(0x7fe6bed2), X(0x7fe7b30a), X(0x7fe8a055), X(0x7fe986d4), | ||
519 | X(0x7fea66a7), X(0x7feb3ff0), X(0x7fec12cd), X(0x7fecdf5f), | ||
520 | X(0x7feda5c5), X(0x7fee6620), X(0x7fef208d), X(0x7fefd52c), | ||
521 | X(0x7ff0841c), X(0x7ff12d7a), X(0x7ff1d164), X(0x7ff26ff9), | ||
522 | X(0x7ff30955), X(0x7ff39d96), X(0x7ff42cd9), X(0x7ff4b739), | ||
523 | X(0x7ff53cd4), X(0x7ff5bdc5), X(0x7ff63a28), X(0x7ff6b217), | ||
524 | X(0x7ff725af), X(0x7ff7950a), X(0x7ff80043), X(0x7ff86773), | ||
525 | X(0x7ff8cab4), X(0x7ff92a21), X(0x7ff985d1), X(0x7ff9dddf), | ||
526 | X(0x7ffa3262), X(0x7ffa8374), X(0x7ffad12c), X(0x7ffb1ba1), | ||
527 | X(0x7ffb62ec), X(0x7ffba723), X(0x7ffbe85c), X(0x7ffc26b0), | ||
528 | X(0x7ffc6233), X(0x7ffc9afb), X(0x7ffcd11e), X(0x7ffd04b1), | ||
529 | X(0x7ffd35c9), X(0x7ffd647b), X(0x7ffd90da), X(0x7ffdbafa), | ||
530 | X(0x7ffde2f0), X(0x7ffe08ce), X(0x7ffe2ca7), X(0x7ffe4e8e), | ||
531 | X(0x7ffe6e95), X(0x7ffe8cce), X(0x7ffea94a), X(0x7ffec41b), | ||
532 | X(0x7ffedd52), X(0x7ffef4ff), X(0x7fff0b33), X(0x7fff1ffd), | ||
533 | X(0x7fff336e), X(0x7fff4593), X(0x7fff567d), X(0x7fff663a), | ||
534 | X(0x7fff74d8), X(0x7fff8265), X(0x7fff8eee), X(0x7fff9a81), | ||
535 | X(0x7fffa52b), X(0x7fffaef8), X(0x7fffb7f5), X(0x7fffc02d), | ||
536 | X(0x7fffc7ab), X(0x7fffce7c), X(0x7fffd4a9), X(0x7fffda3e), | ||
537 | X(0x7fffdf44), X(0x7fffe3c6), X(0x7fffe7cc), X(0x7fffeb60), | ||
538 | X(0x7fffee8a), X(0x7ffff153), X(0x7ffff3c4), X(0x7ffff5e3), | ||
539 | X(0x7ffff7b8), X(0x7ffff94b), X(0x7ffffaa1), X(0x7ffffbc1), | ||
540 | X(0x7ffffcb2), X(0x7ffffd78), X(0x7ffffe19), X(0x7ffffe9a), | ||
541 | X(0x7ffffeff), X(0x7fffff4e), X(0x7fffff89), X(0x7fffffb3), | ||
542 | X(0x7fffffd2), X(0x7fffffe6), X(0x7ffffff3), X(0x7ffffffa), | ||
543 | X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), | ||
544 | }; | ||
545 | |||
546 | static LOOKUP_T vwin4096[2048] = { | ||
547 | X(0x000001f0), X(0x00001171), X(0x00003072), X(0x00005ef5), | ||
548 | X(0x00009cf8), X(0x0000ea7c), X(0x00014780), X(0x0001b405), | ||
549 | X(0x0002300b), X(0x0002bb91), X(0x00035698), X(0x0004011e), | ||
550 | X(0x0004bb25), X(0x000584ac), X(0x00065db3), X(0x0007463a), | ||
551 | X(0x00083e41), X(0x000945c7), X(0x000a5ccc), X(0x000b8350), | ||
552 | X(0x000cb954), X(0x000dfed7), X(0x000f53d8), X(0x0010b857), | ||
553 | X(0x00122c55), X(0x0013afd1), X(0x001542ca), X(0x0016e541), | ||
554 | X(0x00189735), X(0x001a58a7), X(0x001c2995), X(0x001e09ff), | ||
555 | X(0x001ff9e6), X(0x0021f948), X(0x00240826), X(0x00262680), | ||
556 | X(0x00285454), X(0x002a91a3), X(0x002cde6c), X(0x002f3aaf), | ||
557 | X(0x0031a66b), X(0x003421a0), X(0x0036ac4f), X(0x00394675), | ||
558 | X(0x003bf014), X(0x003ea92a), X(0x004171b7), X(0x004449bb), | ||
559 | X(0x00473135), X(0x004a2824), X(0x004d2e8a), X(0x00504463), | ||
560 | X(0x005369b2), X(0x00569e74), X(0x0059e2aa), X(0x005d3652), | ||
561 | X(0x0060996d), X(0x00640bf9), X(0x00678df7), X(0x006b1f66), | ||
562 | X(0x006ec045), X(0x00727093), X(0x00763051), X(0x0079ff7d), | ||
563 | X(0x007dde16), X(0x0081cc1d), X(0x0085c991), X(0x0089d671), | ||
564 | X(0x008df2bc), X(0x00921e71), X(0x00965991), X(0x009aa41a), | ||
565 | X(0x009efe0c), X(0x00a36766), X(0x00a7e028), X(0x00ac6850), | ||
566 | X(0x00b0ffde), X(0x00b5a6d1), X(0x00ba5d28), X(0x00bf22e4), | ||
567 | X(0x00c3f802), X(0x00c8dc83), X(0x00cdd065), X(0x00d2d3a8), | ||
568 | X(0x00d7e64a), X(0x00dd084c), X(0x00e239ac), X(0x00e77a69), | ||
569 | X(0x00ecca83), X(0x00f229f9), X(0x00f798ca), X(0x00fd16f5), | ||
570 | X(0x0102a479), X(0x01084155), X(0x010ded89), X(0x0113a913), | ||
571 | X(0x011973f3), X(0x011f4e27), X(0x012537af), X(0x012b308a), | ||
572 | X(0x013138b7), X(0x01375035), X(0x013d7702), X(0x0143ad1f), | ||
573 | X(0x0149f289), X(0x01504741), X(0x0156ab44), X(0x015d1e92), | ||
574 | X(0x0163a12a), X(0x016a330b), X(0x0170d433), X(0x017784a3), | ||
575 | X(0x017e4458), X(0x01851351), X(0x018bf18e), X(0x0192df0d), | ||
576 | X(0x0199dbcd), X(0x01a0e7cd), X(0x01a8030c), X(0x01af2d89), | ||
577 | X(0x01b66743), X(0x01bdb038), X(0x01c50867), X(0x01cc6fd0), | ||
578 | X(0x01d3e670), X(0x01db6c47), X(0x01e30153), X(0x01eaa593), | ||
579 | X(0x01f25907), X(0x01fa1bac), X(0x0201ed81), X(0x0209ce86), | ||
580 | X(0x0211beb8), X(0x0219be17), X(0x0221cca2), X(0x0229ea56), | ||
581 | X(0x02321733), X(0x023a5337), X(0x02429e60), X(0x024af8af), | ||
582 | X(0x02536220), X(0x025bdab3), X(0x02646267), X(0x026cf93a), | ||
583 | X(0x02759f2a), X(0x027e5436), X(0x0287185d), X(0x028feb9d), | ||
584 | X(0x0298cdf4), X(0x02a1bf62), X(0x02aabfe5), X(0x02b3cf7b), | ||
585 | X(0x02bcee23), X(0x02c61bdb), X(0x02cf58a2), X(0x02d8a475), | ||
586 | X(0x02e1ff55), X(0x02eb693e), X(0x02f4e230), X(0x02fe6a29), | ||
587 | X(0x03080127), X(0x0311a729), X(0x031b5c2d), X(0x03252031), | ||
588 | X(0x032ef334), X(0x0338d534), X(0x0342c630), X(0x034cc625), | ||
589 | X(0x0356d512), X(0x0360f2f6), X(0x036b1fce), X(0x03755b99), | ||
590 | X(0x037fa655), X(0x038a0001), X(0x0394689a), X(0x039ee020), | ||
591 | X(0x03a9668f), X(0x03b3fbe6), X(0x03bea024), X(0x03c95347), | ||
592 | X(0x03d4154d), X(0x03dee633), X(0x03e9c5f9), X(0x03f4b49b), | ||
593 | X(0x03ffb219), X(0x040abe71), X(0x0415d9a0), X(0x042103a5), | ||
594 | X(0x042c3c7d), X(0x04378428), X(0x0442daa2), X(0x044e3fea), | ||
595 | X(0x0459b3fd), X(0x046536db), X(0x0470c880), X(0x047c68eb), | ||
596 | X(0x0488181a), X(0x0493d60b), X(0x049fa2bc), X(0x04ab7e2a), | ||
597 | X(0x04b76854), X(0x04c36137), X(0x04cf68d1), X(0x04db7f21), | ||
598 | X(0x04e7a424), X(0x04f3d7d8), X(0x05001a3b), X(0x050c6b4a), | ||
599 | X(0x0518cb04), X(0x05253966), X(0x0531b66e), X(0x053e421a), | ||
600 | X(0x054adc68), X(0x05578555), X(0x05643cdf), X(0x05710304), | ||
601 | X(0x057dd7c1), X(0x058abb15), X(0x0597acfd), X(0x05a4ad76), | ||
602 | X(0x05b1bc7f), X(0x05beda14), X(0x05cc0635), X(0x05d940dd), | ||
603 | X(0x05e68a0b), X(0x05f3e1bd), X(0x060147f0), X(0x060ebca1), | ||
604 | X(0x061c3fcf), X(0x0629d176), X(0x06377194), X(0x06452027), | ||
605 | X(0x0652dd2c), X(0x0660a8a2), X(0x066e8284), X(0x067c6ad1), | ||
606 | X(0x068a6186), X(0x069866a1), X(0x06a67a1e), X(0x06b49bfc), | ||
607 | X(0x06c2cc38), X(0x06d10acf), X(0x06df57bf), X(0x06edb304), | ||
608 | X(0x06fc1c9d), X(0x070a9487), X(0x07191abe), X(0x0727af40), | ||
609 | X(0x0736520b), X(0x0745031c), X(0x0753c270), X(0x07629004), | ||
610 | X(0x07716bd6), X(0x078055e2), X(0x078f4e26), X(0x079e549f), | ||
611 | X(0x07ad694b), X(0x07bc8c26), X(0x07cbbd2e), X(0x07dafc5f), | ||
612 | X(0x07ea49b7), X(0x07f9a533), X(0x08090ed1), X(0x0818868c), | ||
613 | X(0x08280c62), X(0x0837a051), X(0x08474255), X(0x0856f26b), | ||
614 | X(0x0866b091), X(0x08767cc3), X(0x088656fe), X(0x08963f3f), | ||
615 | X(0x08a63584), X(0x08b639c8), X(0x08c64c0a), X(0x08d66c45), | ||
616 | X(0x08e69a77), X(0x08f6d69d), X(0x090720b3), X(0x091778b7), | ||
617 | X(0x0927dea5), X(0x0938527a), X(0x0948d433), X(0x095963cc), | ||
618 | X(0x096a0143), X(0x097aac94), X(0x098b65bb), X(0x099c2cb6), | ||
619 | X(0x09ad0182), X(0x09bde41a), X(0x09ced47d), X(0x09dfd2a5), | ||
620 | X(0x09f0de90), X(0x0a01f83b), X(0x0a131fa3), X(0x0a2454c3), | ||
621 | X(0x0a359798), X(0x0a46e820), X(0x0a584656), X(0x0a69b237), | ||
622 | X(0x0a7b2bc0), X(0x0a8cb2ec), X(0x0a9e47ba), X(0x0aafea24), | ||
623 | X(0x0ac19a29), X(0x0ad357c3), X(0x0ae522ef), X(0x0af6fbab), | ||
624 | X(0x0b08e1f1), X(0x0b1ad5c0), X(0x0b2cd712), X(0x0b3ee5e5), | ||
625 | X(0x0b510234), X(0x0b632bfd), X(0x0b75633b), X(0x0b87a7eb), | ||
626 | X(0x0b99fa08), X(0x0bac5990), X(0x0bbec67e), X(0x0bd140cf), | ||
627 | X(0x0be3c87e), X(0x0bf65d89), X(0x0c08ffeb), X(0x0c1bafa1), | ||
628 | X(0x0c2e6ca6), X(0x0c4136f6), X(0x0c540e8f), X(0x0c66f36c), | ||
629 | X(0x0c79e588), X(0x0c8ce4e1), X(0x0c9ff172), X(0x0cb30b37), | ||
630 | X(0x0cc6322c), X(0x0cd9664d), X(0x0ceca797), X(0x0cfff605), | ||
631 | X(0x0d135193), X(0x0d26ba3d), X(0x0d3a2fff), X(0x0d4db2d5), | ||
632 | X(0x0d6142ba), X(0x0d74dfac), X(0x0d8889a5), X(0x0d9c40a1), | ||
633 | X(0x0db0049d), X(0x0dc3d593), X(0x0dd7b380), X(0x0deb9e60), | ||
634 | X(0x0dff962f), X(0x0e139ae7), X(0x0e27ac85), X(0x0e3bcb05), | ||
635 | X(0x0e4ff662), X(0x0e642e98), X(0x0e7873a2), X(0x0e8cc57d), | ||
636 | X(0x0ea12423), X(0x0eb58f91), X(0x0eca07c2), X(0x0ede8cb1), | ||
637 | X(0x0ef31e5b), X(0x0f07bcba), X(0x0f1c67cb), X(0x0f311f88), | ||
638 | X(0x0f45e3ee), X(0x0f5ab4f7), X(0x0f6f92a0), X(0x0f847ce3), | ||
639 | X(0x0f9973bc), X(0x0fae7726), X(0x0fc3871e), X(0x0fd8a39d), | ||
640 | X(0x0fedcca1), X(0x10030223), X(0x1018441f), X(0x102d9291), | ||
641 | X(0x1042ed74), X(0x105854c3), X(0x106dc879), X(0x10834892), | ||
642 | X(0x1098d508), X(0x10ae6dd8), X(0x10c412fc), X(0x10d9c46f), | ||
643 | X(0x10ef822d), X(0x11054c30), X(0x111b2274), X(0x113104f5), | ||
644 | X(0x1146f3ac), X(0x115cee95), X(0x1172f5ab), X(0x118908e9), | ||
645 | X(0x119f284a), X(0x11b553ca), X(0x11cb8b62), X(0x11e1cf0f), | ||
646 | X(0x11f81ecb), X(0x120e7a90), X(0x1224e25a), X(0x123b5624), | ||
647 | X(0x1251d5e9), X(0x126861a3), X(0x127ef94e), X(0x12959ce3), | ||
648 | X(0x12ac4c5f), X(0x12c307bb), X(0x12d9cef2), X(0x12f0a200), | ||
649 | X(0x130780df), X(0x131e6b8a), X(0x133561fa), X(0x134c642c), | ||
650 | X(0x1363721a), X(0x137a8bbe), X(0x1391b113), X(0x13a8e214), | ||
651 | X(0x13c01eba), X(0x13d76702), X(0x13eebae5), X(0x14061a5e), | ||
652 | X(0x141d8567), X(0x1434fbfb), X(0x144c7e14), X(0x14640bae), | ||
653 | X(0x147ba4c1), X(0x14934949), X(0x14aaf941), X(0x14c2b4a2), | ||
654 | X(0x14da7b67), X(0x14f24d8a), X(0x150a2b06), X(0x152213d5), | ||
655 | X(0x153a07f1), X(0x15520755), X(0x156a11fb), X(0x158227dd), | ||
656 | X(0x159a48f5), X(0x15b2753d), X(0x15caacb1), X(0x15e2ef49), | ||
657 | X(0x15fb3d01), X(0x161395d2), X(0x162bf9b6), X(0x164468a8), | ||
658 | X(0x165ce2a1), X(0x1675679c), X(0x168df793), X(0x16a69280), | ||
659 | X(0x16bf385c), X(0x16d7e922), X(0x16f0a4cc), X(0x17096b54), | ||
660 | X(0x17223cb4), X(0x173b18e5), X(0x1753ffe2), X(0x176cf1a5), | ||
661 | X(0x1785ee27), X(0x179ef562), X(0x17b80750), X(0x17d123eb), | ||
662 | X(0x17ea4b2d), X(0x18037d10), X(0x181cb98d), X(0x1836009e), | ||
663 | X(0x184f523c), X(0x1868ae63), X(0x1882150a), X(0x189b862c), | ||
664 | X(0x18b501c4), X(0x18ce87c9), X(0x18e81836), X(0x1901b305), | ||
665 | X(0x191b582f), X(0x193507ad), X(0x194ec17a), X(0x1968858f), | ||
666 | X(0x198253e5), X(0x199c2c75), X(0x19b60f3a), X(0x19cffc2d), | ||
667 | X(0x19e9f347), X(0x1a03f482), X(0x1a1dffd7), X(0x1a381540), | ||
668 | X(0x1a5234b5), X(0x1a6c5e31), X(0x1a8691ac), X(0x1aa0cf21), | ||
669 | X(0x1abb1687), X(0x1ad567da), X(0x1aefc311), X(0x1b0a2826), | ||
670 | X(0x1b249712), X(0x1b3f0fd0), X(0x1b599257), X(0x1b741ea1), | ||
671 | X(0x1b8eb4a7), X(0x1ba95462), X(0x1bc3fdcd), X(0x1bdeb0de), | ||
672 | X(0x1bf96d91), X(0x1c1433dd), X(0x1c2f03bc), X(0x1c49dd27), | ||
673 | X(0x1c64c017), X(0x1c7fac85), X(0x1c9aa269), X(0x1cb5a1be), | ||
674 | X(0x1cd0aa7c), X(0x1cebbc9c), X(0x1d06d816), X(0x1d21fce4), | ||
675 | X(0x1d3d2aff), X(0x1d586260), X(0x1d73a2fe), X(0x1d8eecd4), | ||
676 | X(0x1daa3fda), X(0x1dc59c09), X(0x1de1015a), X(0x1dfc6fc5), | ||
677 | X(0x1e17e743), X(0x1e3367cd), X(0x1e4ef15b), X(0x1e6a83e7), | ||
678 | X(0x1e861f6a), X(0x1ea1c3da), X(0x1ebd7133), X(0x1ed9276b), | ||
679 | X(0x1ef4e67c), X(0x1f10ae5e), X(0x1f2c7f0a), X(0x1f485879), | ||
680 | X(0x1f643aa2), X(0x1f80257f), X(0x1f9c1908), X(0x1fb81536), | ||
681 | X(0x1fd41a00), X(0x1ff02761), X(0x200c3d4f), X(0x20285bc3), | ||
682 | X(0x204482b7), X(0x2060b221), X(0x207ce9fb), X(0x20992a3e), | ||
683 | X(0x20b572e0), X(0x20d1c3dc), X(0x20ee1d28), X(0x210a7ebe), | ||
684 | X(0x2126e895), X(0x21435aa6), X(0x215fd4ea), X(0x217c5757), | ||
685 | X(0x2198e1e8), X(0x21b57493), X(0x21d20f51), X(0x21eeb21b), | ||
686 | X(0x220b5ce7), X(0x22280fb0), X(0x2244ca6c), X(0x22618d13), | ||
687 | X(0x227e579f), X(0x229b2a06), X(0x22b80442), X(0x22d4e649), | ||
688 | X(0x22f1d015), X(0x230ec19d), X(0x232bbad9), X(0x2348bbc1), | ||
689 | X(0x2365c44c), X(0x2382d474), X(0x239fec30), X(0x23bd0b78), | ||
690 | X(0x23da3244), X(0x23f7608b), X(0x24149646), X(0x2431d36c), | ||
691 | X(0x244f17f5), X(0x246c63da), X(0x2489b711), X(0x24a71193), | ||
692 | X(0x24c47358), X(0x24e1dc57), X(0x24ff4c88), X(0x251cc3e2), | ||
693 | X(0x253a425e), X(0x2557c7f4), X(0x2575549a), X(0x2592e848), | ||
694 | X(0x25b082f7), X(0x25ce249e), X(0x25ebcd34), X(0x26097cb2), | ||
695 | X(0x2627330e), X(0x2644f040), X(0x2662b441), X(0x26807f07), | ||
696 | X(0x269e5089), X(0x26bc28c1), X(0x26da07a4), X(0x26f7ed2b), | ||
697 | X(0x2715d94d), X(0x2733cc02), X(0x2751c540), X(0x276fc500), | ||
698 | X(0x278dcb39), X(0x27abd7e2), X(0x27c9eaf3), X(0x27e80463), | ||
699 | X(0x28062429), X(0x28244a3e), X(0x28427697), X(0x2860a92d), | ||
700 | X(0x287ee1f7), X(0x289d20eb), X(0x28bb6603), X(0x28d9b134), | ||
701 | X(0x28f80275), X(0x291659c0), X(0x2934b709), X(0x29531a49), | ||
702 | X(0x29718378), X(0x298ff28b), X(0x29ae677b), X(0x29cce23e), | ||
703 | X(0x29eb62cb), X(0x2a09e91b), X(0x2a287523), X(0x2a4706dc), | ||
704 | X(0x2a659e3c), X(0x2a843b39), X(0x2aa2ddcd), X(0x2ac185ec), | ||
705 | X(0x2ae0338f), X(0x2afee6ad), X(0x2b1d9f3c), X(0x2b3c5d33), | ||
706 | X(0x2b5b208b), X(0x2b79e939), X(0x2b98b734), X(0x2bb78a74), | ||
707 | X(0x2bd662ef), X(0x2bf5409d), X(0x2c142374), X(0x2c330b6b), | ||
708 | X(0x2c51f87a), X(0x2c70ea97), X(0x2c8fe1b9), X(0x2caeddd6), | ||
709 | X(0x2ccddee7), X(0x2cece4e1), X(0x2d0befbb), X(0x2d2aff6d), | ||
710 | X(0x2d4a13ec), X(0x2d692d31), X(0x2d884b32), X(0x2da76de4), | ||
711 | X(0x2dc69540), X(0x2de5c13d), X(0x2e04f1d0), X(0x2e2426f0), | ||
712 | X(0x2e436095), X(0x2e629eb4), X(0x2e81e146), X(0x2ea1283f), | ||
713 | X(0x2ec07398), X(0x2edfc347), X(0x2eff1742), X(0x2f1e6f80), | ||
714 | X(0x2f3dcbf8), X(0x2f5d2ca0), X(0x2f7c916f), X(0x2f9bfa5c), | ||
715 | X(0x2fbb675d), X(0x2fdad869), X(0x2ffa4d76), X(0x3019c67b), | ||
716 | X(0x3039436f), X(0x3058c448), X(0x307848fc), X(0x3097d183), | ||
717 | X(0x30b75dd3), X(0x30d6ede2), X(0x30f681a6), X(0x31161917), | ||
718 | X(0x3135b42b), X(0x315552d8), X(0x3174f514), X(0x31949ad7), | ||
719 | X(0x31b44417), X(0x31d3f0ca), X(0x31f3a0e6), X(0x32135462), | ||
720 | X(0x32330b35), X(0x3252c555), X(0x327282b7), X(0x32924354), | ||
721 | X(0x32b20720), X(0x32d1ce13), X(0x32f19823), X(0x33116546), | ||
722 | X(0x33313573), X(0x3351089f), X(0x3370dec2), X(0x3390b7d1), | ||
723 | X(0x33b093c3), X(0x33d0728f), X(0x33f05429), X(0x3410388a), | ||
724 | X(0x34301fa7), X(0x34500977), X(0x346ff5ef), X(0x348fe506), | ||
725 | X(0x34afd6b3), X(0x34cfcaeb), X(0x34efc1a5), X(0x350fbad7), | ||
726 | X(0x352fb678), X(0x354fb47d), X(0x356fb4dd), X(0x358fb78e), | ||
727 | X(0x35afbc86), X(0x35cfc3bc), X(0x35efcd25), X(0x360fd8b8), | ||
728 | X(0x362fe66c), X(0x364ff636), X(0x3670080c), X(0x36901be5), | ||
729 | X(0x36b031b7), X(0x36d04978), X(0x36f0631e), X(0x37107ea0), | ||
730 | X(0x37309bf3), X(0x3750bb0e), X(0x3770dbe6), X(0x3790fe73), | ||
731 | X(0x37b122aa), X(0x37d14881), X(0x37f16fee), X(0x381198e8), | ||
732 | X(0x3831c365), X(0x3851ef5a), X(0x38721cbe), X(0x38924b87), | ||
733 | X(0x38b27bac), X(0x38d2ad21), X(0x38f2dfde), X(0x391313d8), | ||
734 | X(0x39334906), X(0x39537f5d), X(0x3973b6d4), X(0x3993ef60), | ||
735 | X(0x39b428f9), X(0x39d46393), X(0x39f49f25), X(0x3a14dba6), | ||
736 | X(0x3a35190a), X(0x3a555748), X(0x3a759657), X(0x3a95d62c), | ||
737 | X(0x3ab616be), X(0x3ad65801), X(0x3af699ed), X(0x3b16dc78), | ||
738 | X(0x3b371f97), X(0x3b576341), X(0x3b77a76c), X(0x3b97ec0d), | ||
739 | X(0x3bb8311b), X(0x3bd8768b), X(0x3bf8bc55), X(0x3c19026d), | ||
740 | X(0x3c3948ca), X(0x3c598f62), X(0x3c79d62b), X(0x3c9a1d1b), | ||
741 | X(0x3cba6428), X(0x3cdaab48), X(0x3cfaf271), X(0x3d1b3999), | ||
742 | X(0x3d3b80b6), X(0x3d5bc7be), X(0x3d7c0ea8), X(0x3d9c5569), | ||
743 | X(0x3dbc9bf7), X(0x3ddce248), X(0x3dfd2852), X(0x3e1d6e0c), | ||
744 | X(0x3e3db36c), X(0x3e5df866), X(0x3e7e3cf2), X(0x3e9e8106), | ||
745 | X(0x3ebec497), X(0x3edf079b), X(0x3eff4a09), X(0x3f1f8bd7), | ||
746 | X(0x3f3fccfa), X(0x3f600d69), X(0x3f804d1a), X(0x3fa08c02), | ||
747 | X(0x3fc0ca19), X(0x3fe10753), X(0x400143a7), X(0x40217f0a), | ||
748 | X(0x4041b974), X(0x4061f2da), X(0x40822b32), X(0x40a26272), | ||
749 | X(0x40c29891), X(0x40e2cd83), X(0x41030140), X(0x412333bd), | ||
750 | X(0x414364f1), X(0x416394d2), X(0x4183c355), X(0x41a3f070), | ||
751 | X(0x41c41c1b), X(0x41e4464a), X(0x42046ef4), X(0x42249610), | ||
752 | X(0x4244bb92), X(0x4264df72), X(0x428501a5), X(0x42a52222), | ||
753 | X(0x42c540de), X(0x42e55dd0), X(0x430578ed), X(0x4325922d), | ||
754 | X(0x4345a985), X(0x4365beeb), X(0x4385d255), X(0x43a5e3ba), | ||
755 | X(0x43c5f30f), X(0x43e6004b), X(0x44060b65), X(0x44261451), | ||
756 | X(0x44461b07), X(0x44661f7c), X(0x448621a7), X(0x44a6217d), | ||
757 | X(0x44c61ef6), X(0x44e61a07), X(0x450612a6), X(0x452608ca), | ||
758 | X(0x4545fc69), X(0x4565ed79), X(0x4585dbf1), X(0x45a5c7c6), | ||
759 | X(0x45c5b0ef), X(0x45e59761), X(0x46057b15), X(0x46255bfe), | ||
760 | X(0x46453a15), X(0x4665154f), X(0x4684eda2), X(0x46a4c305), | ||
761 | X(0x46c4956e), X(0x46e464d3), X(0x4704312b), X(0x4723fa6c), | ||
762 | X(0x4743c08d), X(0x47638382), X(0x47834344), X(0x47a2ffc9), | ||
763 | X(0x47c2b906), X(0x47e26ef2), X(0x48022183), X(0x4821d0b1), | ||
764 | X(0x48417c71), X(0x486124b9), X(0x4880c981), X(0x48a06abe), | ||
765 | X(0x48c00867), X(0x48dfa272), X(0x48ff38d6), X(0x491ecb8a), | ||
766 | X(0x493e5a84), X(0x495de5b9), X(0x497d6d22), X(0x499cf0b4), | ||
767 | X(0x49bc7066), X(0x49dbec2e), X(0x49fb6402), X(0x4a1ad7db), | ||
768 | X(0x4a3a47ad), X(0x4a59b370), X(0x4a791b1a), X(0x4a987ea1), | ||
769 | X(0x4ab7ddfd), X(0x4ad73924), X(0x4af6900c), X(0x4b15e2ad), | ||
770 | X(0x4b3530fc), X(0x4b547af1), X(0x4b73c082), X(0x4b9301a6), | ||
771 | X(0x4bb23e53), X(0x4bd17681), X(0x4bf0aa25), X(0x4c0fd937), | ||
772 | X(0x4c2f03ae), X(0x4c4e297f), X(0x4c6d4aa3), X(0x4c8c670f), | ||
773 | X(0x4cab7eba), X(0x4cca919c), X(0x4ce99fab), X(0x4d08a8de), | ||
774 | X(0x4d27ad2c), X(0x4d46ac8b), X(0x4d65a6f3), X(0x4d849c5a), | ||
775 | X(0x4da38cb7), X(0x4dc27802), X(0x4de15e31), X(0x4e003f3a), | ||
776 | X(0x4e1f1b16), X(0x4e3df1ba), X(0x4e5cc31e), X(0x4e7b8f3a), | ||
777 | X(0x4e9a5603), X(0x4eb91771), X(0x4ed7d37b), X(0x4ef68a18), | ||
778 | X(0x4f153b3f), X(0x4f33e6e7), X(0x4f528d08), X(0x4f712d97), | ||
779 | X(0x4f8fc88e), X(0x4fae5de1), X(0x4fcced8a), X(0x4feb777f), | ||
780 | X(0x5009fbb6), X(0x50287a28), X(0x5046f2cc), X(0x50656598), | ||
781 | X(0x5083d284), X(0x50a23988), X(0x50c09a9a), X(0x50def5b1), | ||
782 | X(0x50fd4ac7), X(0x511b99d0), X(0x5139e2c5), X(0x5158259e), | ||
783 | X(0x51766251), X(0x519498d6), X(0x51b2c925), X(0x51d0f334), | ||
784 | X(0x51ef16fb), X(0x520d3473), X(0x522b4b91), X(0x52495c4e), | ||
785 | X(0x526766a2), X(0x52856a83), X(0x52a367e9), X(0x52c15ecd), | ||
786 | X(0x52df4f24), X(0x52fd38e8), X(0x531b1c10), X(0x5338f892), | ||
787 | X(0x5356ce68), X(0x53749d89), X(0x539265eb), X(0x53b02788), | ||
788 | X(0x53cde257), X(0x53eb964f), X(0x54094369), X(0x5426e99c), | ||
789 | X(0x544488df), X(0x5462212c), X(0x547fb279), X(0x549d3cbe), | ||
790 | X(0x54babff4), X(0x54d83c12), X(0x54f5b110), X(0x55131ee7), | ||
791 | X(0x5530858d), X(0x554de4fc), X(0x556b3d2a), X(0x55888e11), | ||
792 | X(0x55a5d7a8), X(0x55c319e7), X(0x55e054c7), X(0x55fd883f), | ||
793 | X(0x561ab447), X(0x5637d8d8), X(0x5654f5ea), X(0x56720b75), | ||
794 | X(0x568f1971), X(0x56ac1fd7), X(0x56c91e9e), X(0x56e615c0), | ||
795 | X(0x57030534), X(0x571fecf2), X(0x573cccf3), X(0x5759a530), | ||
796 | X(0x577675a0), X(0x57933e3c), X(0x57affefd), X(0x57ccb7db), | ||
797 | X(0x57e968ce), X(0x580611cf), X(0x5822b2d6), X(0x583f4bdd), | ||
798 | X(0x585bdcdb), X(0x587865c9), X(0x5894e69f), X(0x58b15f57), | ||
799 | X(0x58cdcfe9), X(0x58ea384e), X(0x5906987d), X(0x5922f071), | ||
800 | X(0x593f4022), X(0x595b8788), X(0x5977c69c), X(0x5993fd57), | ||
801 | X(0x59b02bb2), X(0x59cc51a6), X(0x59e86f2c), X(0x5a04843c), | ||
802 | X(0x5a2090d0), X(0x5a3c94e0), X(0x5a589065), X(0x5a748359), | ||
803 | X(0x5a906db4), X(0x5aac4f70), X(0x5ac82884), X(0x5ae3f8ec), | ||
804 | X(0x5affc09f), X(0x5b1b7f97), X(0x5b3735cd), X(0x5b52e33a), | ||
805 | X(0x5b6e87d8), X(0x5b8a239f), X(0x5ba5b689), X(0x5bc1408f), | ||
806 | X(0x5bdcc1aa), X(0x5bf839d5), X(0x5c13a907), X(0x5c2f0f3b), | ||
807 | X(0x5c4a6c6a), X(0x5c65c08d), X(0x5c810b9e), X(0x5c9c4d97), | ||
808 | X(0x5cb78670), X(0x5cd2b623), X(0x5ceddcaa), X(0x5d08f9ff), | ||
809 | X(0x5d240e1b), X(0x5d3f18f8), X(0x5d5a1a8f), X(0x5d7512da), | ||
810 | X(0x5d9001d3), X(0x5daae773), X(0x5dc5c3b5), X(0x5de09692), | ||
811 | X(0x5dfb6004), X(0x5e162004), X(0x5e30d68d), X(0x5e4b8399), | ||
812 | X(0x5e662721), X(0x5e80c11f), X(0x5e9b518e), X(0x5eb5d867), | ||
813 | X(0x5ed055a4), X(0x5eeac940), X(0x5f053334), X(0x5f1f937b), | ||
814 | X(0x5f39ea0f), X(0x5f5436ea), X(0x5f6e7a06), X(0x5f88b35d), | ||
815 | X(0x5fa2e2e9), X(0x5fbd08a6), X(0x5fd7248d), X(0x5ff13698), | ||
816 | X(0x600b3ec2), X(0x60253d05), X(0x603f315b), X(0x60591bc0), | ||
817 | X(0x6072fc2d), X(0x608cd29e), X(0x60a69f0b), X(0x60c06171), | ||
818 | X(0x60da19ca), X(0x60f3c80f), X(0x610d6c3d), X(0x6127064d), | ||
819 | X(0x6140963a), X(0x615a1bff), X(0x61739797), X(0x618d08fc), | ||
820 | X(0x61a67029), X(0x61bfcd1a), X(0x61d91fc8), X(0x61f2682f), | ||
821 | X(0x620ba64a), X(0x6224da13), X(0x623e0386), X(0x6257229d), | ||
822 | X(0x62703754), X(0x628941a6), X(0x62a2418e), X(0x62bb3706), | ||
823 | X(0x62d4220a), X(0x62ed0296), X(0x6305d8a3), X(0x631ea42f), | ||
824 | X(0x63376533), X(0x63501bab), X(0x6368c793), X(0x638168e5), | ||
825 | X(0x6399ff9e), X(0x63b28bb8), X(0x63cb0d2f), X(0x63e383ff), | ||
826 | X(0x63fbf022), X(0x64145195), X(0x642ca853), X(0x6444f457), | ||
827 | X(0x645d359e), X(0x64756c22), X(0x648d97e0), X(0x64a5b8d3), | ||
828 | X(0x64bdcef6), X(0x64d5da47), X(0x64eddabf), X(0x6505d05c), | ||
829 | X(0x651dbb19), X(0x65359af2), X(0x654d6fe3), X(0x656539e7), | ||
830 | X(0x657cf8fb), X(0x6594ad1b), X(0x65ac5643), X(0x65c3f46e), | ||
831 | X(0x65db8799), X(0x65f30fc0), X(0x660a8ce0), X(0x6621fef3), | ||
832 | X(0x663965f7), X(0x6650c1e7), X(0x666812c1), X(0x667f5880), | ||
833 | X(0x66969320), X(0x66adc29e), X(0x66c4e6f7), X(0x66dc0026), | ||
834 | X(0x66f30e28), X(0x670a10fa), X(0x67210898), X(0x6737f4ff), | ||
835 | X(0x674ed62b), X(0x6765ac19), X(0x677c76c5), X(0x6793362c), | ||
836 | X(0x67a9ea4b), X(0x67c0931f), X(0x67d730a3), X(0x67edc2d6), | ||
837 | X(0x680449b3), X(0x681ac538), X(0x68313562), X(0x68479a2d), | ||
838 | X(0x685df396), X(0x6874419b), X(0x688a8438), X(0x68a0bb6a), | ||
839 | X(0x68b6e72e), X(0x68cd0782), X(0x68e31c63), X(0x68f925cd), | ||
840 | X(0x690f23be), X(0x69251633), X(0x693afd29), X(0x6950d89e), | ||
841 | X(0x6966a88f), X(0x697c6cf8), X(0x699225d9), X(0x69a7d32d), | ||
842 | X(0x69bd74f3), X(0x69d30b27), X(0x69e895c8), X(0x69fe14d2), | ||
843 | X(0x6a138844), X(0x6a28f01b), X(0x6a3e4c54), X(0x6a539ced), | ||
844 | X(0x6a68e1e4), X(0x6a7e1b37), X(0x6a9348e3), X(0x6aa86ae6), | ||
845 | X(0x6abd813d), X(0x6ad28be7), X(0x6ae78ae2), X(0x6afc7e2b), | ||
846 | X(0x6b1165c0), X(0x6b26419f), X(0x6b3b11c7), X(0x6b4fd634), | ||
847 | X(0x6b648ee6), X(0x6b793bda), X(0x6b8ddd0e), X(0x6ba27281), | ||
848 | X(0x6bb6fc31), X(0x6bcb7a1b), X(0x6bdfec3e), X(0x6bf45299), | ||
849 | X(0x6c08ad29), X(0x6c1cfbed), X(0x6c313ee4), X(0x6c45760a), | ||
850 | X(0x6c59a160), X(0x6c6dc0e4), X(0x6c81d493), X(0x6c95dc6d), | ||
851 | X(0x6ca9d86f), X(0x6cbdc899), X(0x6cd1acea), X(0x6ce5855f), | ||
852 | X(0x6cf951f7), X(0x6d0d12b1), X(0x6d20c78c), X(0x6d347087), | ||
853 | X(0x6d480da0), X(0x6d5b9ed6), X(0x6d6f2427), X(0x6d829d94), | ||
854 | X(0x6d960b1a), X(0x6da96cb9), X(0x6dbcc270), X(0x6dd00c3c), | ||
855 | X(0x6de34a1f), X(0x6df67c16), X(0x6e09a221), X(0x6e1cbc3f), | ||
856 | X(0x6e2fca6e), X(0x6e42ccaf), X(0x6e55c300), X(0x6e68ad60), | ||
857 | X(0x6e7b8bd0), X(0x6e8e5e4d), X(0x6ea124d8), X(0x6eb3df70), | ||
858 | X(0x6ec68e13), X(0x6ed930c3), X(0x6eebc77d), X(0x6efe5242), | ||
859 | X(0x6f10d111), X(0x6f2343e9), X(0x6f35aacb), X(0x6f4805b5), | ||
860 | X(0x6f5a54a8), X(0x6f6c97a2), X(0x6f7ecea4), X(0x6f90f9ae), | ||
861 | X(0x6fa318be), X(0x6fb52bd6), X(0x6fc732f4), X(0x6fd92e19), | ||
862 | X(0x6feb1d44), X(0x6ffd0076), X(0x700ed7ad), X(0x7020a2eb), | ||
863 | X(0x7032622f), X(0x7044157a), X(0x7055bcca), X(0x70675821), | ||
864 | X(0x7078e77e), X(0x708a6ae2), X(0x709be24c), X(0x70ad4dbd), | ||
865 | X(0x70bead36), X(0x70d000b5), X(0x70e1483d), X(0x70f283cc), | ||
866 | X(0x7103b363), X(0x7114d704), X(0x7125eead), X(0x7136fa60), | ||
867 | X(0x7147fa1c), X(0x7158ede4), X(0x7169d5b6), X(0x717ab193), | ||
868 | X(0x718b817d), X(0x719c4573), X(0x71acfd76), X(0x71bda988), | ||
869 | X(0x71ce49a8), X(0x71deddd7), X(0x71ef6617), X(0x71ffe267), | ||
870 | X(0x721052ca), X(0x7220b73e), X(0x72310fc6), X(0x72415c62), | ||
871 | X(0x72519d14), X(0x7261d1db), X(0x7271faba), X(0x728217b1), | ||
872 | X(0x729228c0), X(0x72a22dea), X(0x72b22730), X(0x72c21491), | ||
873 | X(0x72d1f611), X(0x72e1cbaf), X(0x72f1956c), X(0x7301534c), | ||
874 | X(0x7311054d), X(0x7320ab72), X(0x733045bc), X(0x733fd42d), | ||
875 | X(0x734f56c5), X(0x735ecd86), X(0x736e3872), X(0x737d9789), | ||
876 | X(0x738ceacf), X(0x739c3243), X(0x73ab6de7), X(0x73ba9dbe), | ||
877 | X(0x73c9c1c8), X(0x73d8da08), X(0x73e7e67f), X(0x73f6e72e), | ||
878 | X(0x7405dc17), X(0x7414c53c), X(0x7423a29f), X(0x74327442), | ||
879 | X(0x74413a26), X(0x744ff44d), X(0x745ea2b9), X(0x746d456c), | ||
880 | X(0x747bdc68), X(0x748a67ae), X(0x7498e741), X(0x74a75b23), | ||
881 | X(0x74b5c356), X(0x74c41fdb), X(0x74d270b6), X(0x74e0b5e7), | ||
882 | X(0x74eeef71), X(0x74fd1d57), X(0x750b3f9a), X(0x7519563c), | ||
883 | X(0x75276140), X(0x753560a8), X(0x75435477), X(0x75513cae), | ||
884 | X(0x755f1951), X(0x756cea60), X(0x757aafdf), X(0x758869d1), | ||
885 | X(0x75961837), X(0x75a3bb14), X(0x75b1526a), X(0x75bede3c), | ||
886 | X(0x75cc5e8d), X(0x75d9d35f), X(0x75e73cb5), X(0x75f49a91), | ||
887 | X(0x7601ecf6), X(0x760f33e6), X(0x761c6f65), X(0x76299f74), | ||
888 | X(0x7636c417), X(0x7643dd51), X(0x7650eb24), X(0x765ded93), | ||
889 | X(0x766ae4a0), X(0x7677d050), X(0x7684b0a4), X(0x7691859f), | ||
890 | X(0x769e4f45), X(0x76ab0d98), X(0x76b7c09c), X(0x76c46852), | ||
891 | X(0x76d104bf), X(0x76dd95e6), X(0x76ea1bc9), X(0x76f6966b), | ||
892 | X(0x770305d0), X(0x770f69fb), X(0x771bc2ef), X(0x772810af), | ||
893 | X(0x7734533e), X(0x77408aa0), X(0x774cb6d7), X(0x7758d7e8), | ||
894 | X(0x7764edd5), X(0x7770f8a2), X(0x777cf852), X(0x7788ece8), | ||
895 | X(0x7794d668), X(0x77a0b4d5), X(0x77ac8833), X(0x77b85085), | ||
896 | X(0x77c40dce), X(0x77cfc013), X(0x77db6756), X(0x77e7039b), | ||
897 | X(0x77f294e6), X(0x77fe1b3b), X(0x7809969c), X(0x7815070e), | ||
898 | X(0x78206c93), X(0x782bc731), X(0x783716ea), X(0x78425bc3), | ||
899 | X(0x784d95be), X(0x7858c4e1), X(0x7863e92d), X(0x786f02a8), | ||
900 | X(0x787a1156), X(0x78851539), X(0x78900e56), X(0x789afcb1), | ||
901 | X(0x78a5e04d), X(0x78b0b92f), X(0x78bb875b), X(0x78c64ad4), | ||
902 | X(0x78d1039e), X(0x78dbb1be), X(0x78e65537), X(0x78f0ee0e), | ||
903 | X(0x78fb7c46), X(0x7905ffe4), X(0x791078ec), X(0x791ae762), | ||
904 | X(0x79254b4a), X(0x792fa4a7), X(0x7939f380), X(0x794437d7), | ||
905 | X(0x794e71b0), X(0x7958a111), X(0x7962c5fd), X(0x796ce078), | ||
906 | X(0x7976f087), X(0x7980f62f), X(0x798af173), X(0x7994e258), | ||
907 | X(0x799ec8e2), X(0x79a8a515), X(0x79b276f7), X(0x79bc3e8b), | ||
908 | X(0x79c5fbd6), X(0x79cfaedc), X(0x79d957a2), X(0x79e2f62c), | ||
909 | X(0x79ec8a7f), X(0x79f6149f), X(0x79ff9492), X(0x7a090a5a), | ||
910 | X(0x7a1275fe), X(0x7a1bd781), X(0x7a252ee9), X(0x7a2e7c39), | ||
911 | X(0x7a37bf77), X(0x7a40f8a7), X(0x7a4a27ce), X(0x7a534cf0), | ||
912 | X(0x7a5c6813), X(0x7a65793b), X(0x7a6e806d), X(0x7a777dad), | ||
913 | X(0x7a807100), X(0x7a895a6b), X(0x7a9239f4), X(0x7a9b0f9e), | ||
914 | X(0x7aa3db6f), X(0x7aac9d6b), X(0x7ab55597), X(0x7abe03f9), | ||
915 | X(0x7ac6a895), X(0x7acf4370), X(0x7ad7d48f), X(0x7ae05bf6), | ||
916 | X(0x7ae8d9ac), X(0x7af14db5), X(0x7af9b815), X(0x7b0218d2), | ||
917 | X(0x7b0a6ff2), X(0x7b12bd78), X(0x7b1b016a), X(0x7b233bce), | ||
918 | X(0x7b2b6ca7), X(0x7b3393fc), X(0x7b3bb1d1), X(0x7b43c62c), | ||
919 | X(0x7b4bd111), X(0x7b53d286), X(0x7b5bca90), X(0x7b63b935), | ||
920 | X(0x7b6b9e78), X(0x7b737a61), X(0x7b7b4cf3), X(0x7b831634), | ||
921 | X(0x7b8ad629), X(0x7b928cd8), X(0x7b9a3a45), X(0x7ba1de77), | ||
922 | X(0x7ba97972), X(0x7bb10b3c), X(0x7bb893d9), X(0x7bc01350), | ||
923 | X(0x7bc789a6), X(0x7bcef6e0), X(0x7bd65b03), X(0x7bddb616), | ||
924 | X(0x7be5081c), X(0x7bec511c), X(0x7bf3911b), X(0x7bfac81f), | ||
925 | X(0x7c01f62c), X(0x7c091b49), X(0x7c10377b), X(0x7c174ac7), | ||
926 | X(0x7c1e5532), X(0x7c2556c4), X(0x7c2c4f80), X(0x7c333f6c), | ||
927 | X(0x7c3a268e), X(0x7c4104ec), X(0x7c47da8a), X(0x7c4ea76f), | ||
928 | X(0x7c556ba1), X(0x7c5c2724), X(0x7c62d9fe), X(0x7c698435), | ||
929 | X(0x7c7025cf), X(0x7c76bed0), X(0x7c7d4f40), X(0x7c83d723), | ||
930 | X(0x7c8a567f), X(0x7c90cd5a), X(0x7c973bb9), X(0x7c9da1a2), | ||
931 | X(0x7ca3ff1b), X(0x7caa542a), X(0x7cb0a0d3), X(0x7cb6e51e), | ||
932 | X(0x7cbd210f), X(0x7cc354ac), X(0x7cc97ffc), X(0x7ccfa304), | ||
933 | X(0x7cd5bdc9), X(0x7cdbd051), X(0x7ce1daa3), X(0x7ce7dcc3), | ||
934 | X(0x7cedd6b8), X(0x7cf3c888), X(0x7cf9b238), X(0x7cff93cf), | ||
935 | X(0x7d056d51), X(0x7d0b3ec5), X(0x7d110830), X(0x7d16c99a), | ||
936 | X(0x7d1c8306), X(0x7d22347c), X(0x7d27de00), X(0x7d2d7f9a), | ||
937 | X(0x7d33194f), X(0x7d38ab24), X(0x7d3e351f), X(0x7d43b748), | ||
938 | X(0x7d4931a2), X(0x7d4ea435), X(0x7d540f06), X(0x7d59721b), | ||
939 | X(0x7d5ecd7b), X(0x7d64212a), X(0x7d696d2f), X(0x7d6eb190), | ||
940 | X(0x7d73ee53), X(0x7d79237e), X(0x7d7e5117), X(0x7d837723), | ||
941 | X(0x7d8895a9), X(0x7d8dacae), X(0x7d92bc3a), X(0x7d97c451), | ||
942 | X(0x7d9cc4f9), X(0x7da1be39), X(0x7da6b017), X(0x7dab9a99), | ||
943 | X(0x7db07dc4), X(0x7db5599e), X(0x7dba2e2f), X(0x7dbefb7b), | ||
944 | X(0x7dc3c189), X(0x7dc8805e), X(0x7dcd3802), X(0x7dd1e879), | ||
945 | X(0x7dd691ca), X(0x7ddb33fb), X(0x7ddfcf12), X(0x7de46315), | ||
946 | X(0x7de8f00a), X(0x7ded75f8), X(0x7df1f4e3), X(0x7df66cd3), | ||
947 | X(0x7dfaddcd), X(0x7dff47d7), X(0x7e03aaf8), X(0x7e080735), | ||
948 | X(0x7e0c5c95), X(0x7e10ab1e), X(0x7e14f2d5), X(0x7e1933c1), | ||
949 | X(0x7e1d6de8), X(0x7e21a150), X(0x7e25cdff), X(0x7e29f3fc), | ||
950 | X(0x7e2e134c), X(0x7e322bf5), X(0x7e363dfd), X(0x7e3a496b), | ||
951 | X(0x7e3e4e45), X(0x7e424c90), X(0x7e464454), X(0x7e4a3595), | ||
952 | X(0x7e4e205a), X(0x7e5204aa), X(0x7e55e289), X(0x7e59b9ff), | ||
953 | X(0x7e5d8b12), X(0x7e6155c7), X(0x7e651a24), X(0x7e68d831), | ||
954 | X(0x7e6c8ff2), X(0x7e70416e), X(0x7e73ecac), X(0x7e7791b0), | ||
955 | X(0x7e7b3082), X(0x7e7ec927), X(0x7e825ba6), X(0x7e85e804), | ||
956 | X(0x7e896e48), X(0x7e8cee77), X(0x7e906899), X(0x7e93dcb2), | ||
957 | X(0x7e974aca), X(0x7e9ab2e5), X(0x7e9e150b), X(0x7ea17141), | ||
958 | X(0x7ea4c78e), X(0x7ea817f7), X(0x7eab6283), X(0x7eaea737), | ||
959 | X(0x7eb1e61a), X(0x7eb51f33), X(0x7eb85285), X(0x7ebb8019), | ||
960 | X(0x7ebea7f4), X(0x7ec1ca1d), X(0x7ec4e698), X(0x7ec7fd6d), | ||
961 | X(0x7ecb0ea1), X(0x7ece1a3a), X(0x7ed1203f), X(0x7ed420b6), | ||
962 | X(0x7ed71ba4), X(0x7eda110f), X(0x7edd00ff), X(0x7edfeb78), | ||
963 | X(0x7ee2d081), X(0x7ee5b01f), X(0x7ee88a5a), X(0x7eeb5f36), | ||
964 | X(0x7eee2eba), X(0x7ef0f8ed), X(0x7ef3bdd3), X(0x7ef67d73), | ||
965 | X(0x7ef937d3), X(0x7efbecf9), X(0x7efe9ceb), X(0x7f0147ae), | ||
966 | X(0x7f03ed4a), X(0x7f068dc4), X(0x7f092922), X(0x7f0bbf69), | ||
967 | X(0x7f0e50a1), X(0x7f10dcce), X(0x7f1363f7), X(0x7f15e622), | ||
968 | X(0x7f186355), X(0x7f1adb95), X(0x7f1d4ee9), X(0x7f1fbd57), | ||
969 | X(0x7f2226e4), X(0x7f248b96), X(0x7f26eb74), X(0x7f294683), | ||
970 | X(0x7f2b9cc9), X(0x7f2dee4d), X(0x7f303b13), X(0x7f328322), | ||
971 | X(0x7f34c680), X(0x7f370533), X(0x7f393f40), X(0x7f3b74ad), | ||
972 | X(0x7f3da581), X(0x7f3fd1c1), X(0x7f41f972), X(0x7f441c9c), | ||
973 | X(0x7f463b43), X(0x7f48556d), X(0x7f4a6b21), X(0x7f4c7c64), | ||
974 | X(0x7f4e893c), X(0x7f5091ae), X(0x7f5295c1), X(0x7f54957a), | ||
975 | X(0x7f5690e0), X(0x7f5887f7), X(0x7f5a7ac5), X(0x7f5c6951), | ||
976 | X(0x7f5e53a0), X(0x7f6039b8), X(0x7f621b9e), X(0x7f63f958), | ||
977 | X(0x7f65d2ed), X(0x7f67a861), X(0x7f6979ba), X(0x7f6b46ff), | ||
978 | X(0x7f6d1034), X(0x7f6ed560), X(0x7f709687), X(0x7f7253b1), | ||
979 | X(0x7f740ce1), X(0x7f75c21f), X(0x7f777370), X(0x7f7920d8), | ||
980 | X(0x7f7aca5f), X(0x7f7c7008), X(0x7f7e11db), X(0x7f7fafdd), | ||
981 | X(0x7f814a13), X(0x7f82e082), X(0x7f847331), X(0x7f860224), | ||
982 | X(0x7f878d62), X(0x7f8914f0), X(0x7f8a98d4), X(0x7f8c1912), | ||
983 | X(0x7f8d95b0), X(0x7f8f0eb5), X(0x7f908425), X(0x7f91f605), | ||
984 | X(0x7f93645c), X(0x7f94cf2f), X(0x7f963683), X(0x7f979a5d), | ||
985 | X(0x7f98fac4), X(0x7f9a57bb), X(0x7f9bb14a), X(0x7f9d0775), | ||
986 | X(0x7f9e5a41), X(0x7f9fa9b4), X(0x7fa0f5d3), X(0x7fa23ea4), | ||
987 | X(0x7fa3842b), X(0x7fa4c66f), X(0x7fa60575), X(0x7fa74141), | ||
988 | X(0x7fa879d9), X(0x7fa9af42), X(0x7faae182), X(0x7fac109e), | ||
989 | X(0x7fad3c9a), X(0x7fae657d), X(0x7faf8b4c), X(0x7fb0ae0b), | ||
990 | X(0x7fb1cdc0), X(0x7fb2ea70), X(0x7fb40420), X(0x7fb51ad5), | ||
991 | X(0x7fb62e95), X(0x7fb73f64), X(0x7fb84d48), X(0x7fb95846), | ||
992 | X(0x7fba6062), X(0x7fbb65a2), X(0x7fbc680c), X(0x7fbd67a3), | ||
993 | X(0x7fbe646d), X(0x7fbf5e70), X(0x7fc055af), X(0x7fc14a31), | ||
994 | X(0x7fc23bf9), X(0x7fc32b0d), X(0x7fc41773), X(0x7fc5012e), | ||
995 | X(0x7fc5e844), X(0x7fc6ccba), X(0x7fc7ae94), X(0x7fc88dd8), | ||
996 | X(0x7fc96a8a), X(0x7fca44af), X(0x7fcb1c4c), X(0x7fcbf167), | ||
997 | X(0x7fccc403), X(0x7fcd9425), X(0x7fce61d3), X(0x7fcf2d11), | ||
998 | X(0x7fcff5e3), X(0x7fd0bc4f), X(0x7fd1805a), X(0x7fd24207), | ||
999 | X(0x7fd3015c), X(0x7fd3be5d), X(0x7fd47910), X(0x7fd53178), | ||
1000 | X(0x7fd5e79b), X(0x7fd69b7c), X(0x7fd74d21), X(0x7fd7fc8e), | ||
1001 | X(0x7fd8a9c8), X(0x7fd954d4), X(0x7fd9fdb5), X(0x7fdaa471), | ||
1002 | X(0x7fdb490b), X(0x7fdbeb89), X(0x7fdc8bef), X(0x7fdd2a42), | ||
1003 | X(0x7fddc685), X(0x7fde60be), X(0x7fdef8f0), X(0x7fdf8f20), | ||
1004 | X(0x7fe02353), X(0x7fe0b58d), X(0x7fe145d3), X(0x7fe1d428), | ||
1005 | X(0x7fe26091), X(0x7fe2eb12), X(0x7fe373b0), X(0x7fe3fa6f), | ||
1006 | X(0x7fe47f53), X(0x7fe50260), X(0x7fe5839b), X(0x7fe60308), | ||
1007 | X(0x7fe680ab), X(0x7fe6fc88), X(0x7fe776a4), X(0x7fe7ef02), | ||
1008 | X(0x7fe865a7), X(0x7fe8da97), X(0x7fe94dd6), X(0x7fe9bf68), | ||
1009 | X(0x7fea2f51), X(0x7fea9d95), X(0x7feb0a39), X(0x7feb7540), | ||
1010 | X(0x7febdeae), X(0x7fec4687), X(0x7fecaccf), X(0x7fed118b), | ||
1011 | X(0x7fed74be), X(0x7fedd66c), X(0x7fee3698), X(0x7fee9548), | ||
1012 | X(0x7feef27e), X(0x7fef4e3f), X(0x7fefa88e), X(0x7ff0016f), | ||
1013 | X(0x7ff058e7), X(0x7ff0aef8), X(0x7ff103a6), X(0x7ff156f6), | ||
1014 | X(0x7ff1a8eb), X(0x7ff1f988), X(0x7ff248d2), X(0x7ff296cc), | ||
1015 | X(0x7ff2e37a), X(0x7ff32edf), X(0x7ff378ff), X(0x7ff3c1de), | ||
1016 | X(0x7ff4097e), X(0x7ff44fe5), X(0x7ff49515), X(0x7ff4d911), | ||
1017 | X(0x7ff51bde), X(0x7ff55d7f), X(0x7ff59df7), X(0x7ff5dd4a), | ||
1018 | X(0x7ff61b7b), X(0x7ff6588d), X(0x7ff69485), X(0x7ff6cf65), | ||
1019 | X(0x7ff70930), X(0x7ff741eb), X(0x7ff77998), X(0x7ff7b03b), | ||
1020 | X(0x7ff7e5d7), X(0x7ff81a6f), X(0x7ff84e06), X(0x7ff880a1), | ||
1021 | X(0x7ff8b241), X(0x7ff8e2ea), X(0x7ff912a0), X(0x7ff94165), | ||
1022 | X(0x7ff96f3d), X(0x7ff99c2b), X(0x7ff9c831), X(0x7ff9f354), | ||
1023 | X(0x7ffa1d95), X(0x7ffa46f9), X(0x7ffa6f81), X(0x7ffa9731), | ||
1024 | X(0x7ffabe0d), X(0x7ffae416), X(0x7ffb0951), X(0x7ffb2dbf), | ||
1025 | X(0x7ffb5164), X(0x7ffb7442), X(0x7ffb965d), X(0x7ffbb7b8), | ||
1026 | X(0x7ffbd854), X(0x7ffbf836), X(0x7ffc175f), X(0x7ffc35d3), | ||
1027 | X(0x7ffc5394), X(0x7ffc70a5), X(0x7ffc8d09), X(0x7ffca8c2), | ||
1028 | X(0x7ffcc3d4), X(0x7ffcde3f), X(0x7ffcf809), X(0x7ffd1132), | ||
1029 | X(0x7ffd29be), X(0x7ffd41ae), X(0x7ffd5907), X(0x7ffd6fc9), | ||
1030 | X(0x7ffd85f9), X(0x7ffd9b97), X(0x7ffdb0a7), X(0x7ffdc52b), | ||
1031 | X(0x7ffdd926), X(0x7ffdec99), X(0x7ffdff88), X(0x7ffe11f4), | ||
1032 | X(0x7ffe23e0), X(0x7ffe354f), X(0x7ffe4642), X(0x7ffe56bc), | ||
1033 | X(0x7ffe66bf), X(0x7ffe764e), X(0x7ffe856a), X(0x7ffe9416), | ||
1034 | X(0x7ffea254), X(0x7ffeb026), X(0x7ffebd8e), X(0x7ffeca8f), | ||
1035 | X(0x7ffed72a), X(0x7ffee362), X(0x7ffeef38), X(0x7ffefaaf), | ||
1036 | X(0x7fff05c9), X(0x7fff1087), X(0x7fff1aec), X(0x7fff24f9), | ||
1037 | X(0x7fff2eb1), X(0x7fff3816), X(0x7fff4128), X(0x7fff49eb), | ||
1038 | X(0x7fff5260), X(0x7fff5a88), X(0x7fff6266), X(0x7fff69fc), | ||
1039 | X(0x7fff714b), X(0x7fff7854), X(0x7fff7f1a), X(0x7fff859f), | ||
1040 | X(0x7fff8be3), X(0x7fff91ea), X(0x7fff97b3), X(0x7fff9d41), | ||
1041 | X(0x7fffa296), X(0x7fffa7b3), X(0x7fffac99), X(0x7fffb14b), | ||
1042 | X(0x7fffb5c9), X(0x7fffba15), X(0x7fffbe31), X(0x7fffc21d), | ||
1043 | X(0x7fffc5dc), X(0x7fffc96f), X(0x7fffccd8), X(0x7fffd016), | ||
1044 | X(0x7fffd32d), X(0x7fffd61c), X(0x7fffd8e7), X(0x7fffdb8d), | ||
1045 | X(0x7fffde0f), X(0x7fffe071), X(0x7fffe2b1), X(0x7fffe4d2), | ||
1046 | X(0x7fffe6d5), X(0x7fffe8bb), X(0x7fffea85), X(0x7fffec34), | ||
1047 | X(0x7fffedc9), X(0x7fffef45), X(0x7ffff0aa), X(0x7ffff1f7), | ||
1048 | X(0x7ffff330), X(0x7ffff453), X(0x7ffff562), X(0x7ffff65f), | ||
1049 | X(0x7ffff749), X(0x7ffff823), X(0x7ffff8ec), X(0x7ffff9a6), | ||
1050 | X(0x7ffffa51), X(0x7ffffaee), X(0x7ffffb7e), X(0x7ffffc02), | ||
1051 | X(0x7ffffc7a), X(0x7ffffce7), X(0x7ffffd4a), X(0x7ffffda3), | ||
1052 | X(0x7ffffdf4), X(0x7ffffe3c), X(0x7ffffe7c), X(0x7ffffeb6), | ||
1053 | X(0x7ffffee8), X(0x7fffff15), X(0x7fffff3c), X(0x7fffff5e), | ||
1054 | X(0x7fffff7b), X(0x7fffff95), X(0x7fffffaa), X(0x7fffffbc), | ||
1055 | X(0x7fffffcb), X(0x7fffffd7), X(0x7fffffe2), X(0x7fffffea), | ||
1056 | X(0x7ffffff0), X(0x7ffffff5), X(0x7ffffff9), X(0x7ffffffb), | ||
1057 | X(0x7ffffffd), X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), | ||
1058 | X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), | ||
1059 | }; | ||
1060 | |||
1061 | static LOOKUP_T vwin8192[4096] = { | ||
1062 | X(0x0000007c), X(0x0000045c), X(0x00000c1d), X(0x000017bd), | ||
1063 | X(0x0000273e), X(0x00003a9f), X(0x000051e0), X(0x00006d02), | ||
1064 | X(0x00008c03), X(0x0000aee5), X(0x0000d5a7), X(0x00010049), | ||
1065 | X(0x00012ecb), X(0x0001612d), X(0x00019770), X(0x0001d193), | ||
1066 | X(0x00020f96), X(0x00025178), X(0x0002973c), X(0x0002e0df), | ||
1067 | X(0x00032e62), X(0x00037fc5), X(0x0003d509), X(0x00042e2c), | ||
1068 | X(0x00048b30), X(0x0004ec13), X(0x000550d7), X(0x0005b97a), | ||
1069 | X(0x000625fe), X(0x00069661), X(0x00070aa4), X(0x000782c8), | ||
1070 | X(0x0007fecb), X(0x00087eae), X(0x00090271), X(0x00098a14), | ||
1071 | X(0x000a1597), X(0x000aa4f9), X(0x000b383b), X(0x000bcf5d), | ||
1072 | X(0x000c6a5f), X(0x000d0941), X(0x000dac02), X(0x000e52a3), | ||
1073 | X(0x000efd23), X(0x000fab84), X(0x00105dc3), X(0x001113e3), | ||
1074 | X(0x0011cde2), X(0x00128bc0), X(0x00134d7e), X(0x0014131b), | ||
1075 | X(0x0014dc98), X(0x0015a9f4), X(0x00167b30), X(0x0017504a), | ||
1076 | X(0x00182945), X(0x0019061e), X(0x0019e6d7), X(0x001acb6f), | ||
1077 | X(0x001bb3e6), X(0x001ca03c), X(0x001d9071), X(0x001e8485), | ||
1078 | X(0x001f7c79), X(0x0020784b), X(0x002177fc), X(0x00227b8c), | ||
1079 | X(0x002382fb), X(0x00248e49), X(0x00259d76), X(0x0026b081), | ||
1080 | X(0x0027c76b), X(0x0028e234), X(0x002a00dc), X(0x002b2361), | ||
1081 | X(0x002c49c6), X(0x002d7409), X(0x002ea22a), X(0x002fd42a), | ||
1082 | X(0x00310a08), X(0x003243c5), X(0x00338160), X(0x0034c2d9), | ||
1083 | X(0x00360830), X(0x00375165), X(0x00389e78), X(0x0039ef6a), | ||
1084 | X(0x003b4439), X(0x003c9ce6), X(0x003df971), X(0x003f59da), | ||
1085 | X(0x0040be20), X(0x00422645), X(0x00439247), X(0x00450226), | ||
1086 | X(0x004675e3), X(0x0047ed7e), X(0x004968f5), X(0x004ae84b), | ||
1087 | X(0x004c6b7d), X(0x004df28d), X(0x004f7d7a), X(0x00510c44), | ||
1088 | X(0x00529eeb), X(0x00543570), X(0x0055cfd1), X(0x00576e0f), | ||
1089 | X(0x00591029), X(0x005ab621), X(0x005c5ff5), X(0x005e0da6), | ||
1090 | X(0x005fbf33), X(0x0061749d), X(0x00632de4), X(0x0064eb06), | ||
1091 | X(0x0066ac05), X(0x006870e0), X(0x006a3998), X(0x006c062b), | ||
1092 | X(0x006dd69b), X(0x006faae6), X(0x0071830d), X(0x00735f10), | ||
1093 | X(0x00753eef), X(0x007722a9), X(0x00790a3f), X(0x007af5b1), | ||
1094 | X(0x007ce4fe), X(0x007ed826), X(0x0080cf29), X(0x0082ca08), | ||
1095 | X(0x0084c8c2), X(0x0086cb57), X(0x0088d1c7), X(0x008adc11), | ||
1096 | X(0x008cea37), X(0x008efc37), X(0x00911212), X(0x00932bc7), | ||
1097 | X(0x00954957), X(0x00976ac2), X(0x00999006), X(0x009bb925), | ||
1098 | X(0x009de61e), X(0x00a016f1), X(0x00a24b9e), X(0x00a48425), | ||
1099 | X(0x00a6c086), X(0x00a900c0), X(0x00ab44d4), X(0x00ad8cc2), | ||
1100 | X(0x00afd889), X(0x00b22829), X(0x00b47ba2), X(0x00b6d2f5), | ||
1101 | X(0x00b92e21), X(0x00bb8d26), X(0x00bdf004), X(0x00c056ba), | ||
1102 | X(0x00c2c149), X(0x00c52fb1), X(0x00c7a1f1), X(0x00ca180a), | ||
1103 | X(0x00cc91fb), X(0x00cf0fc5), X(0x00d19166), X(0x00d416df), | ||
1104 | X(0x00d6a031), X(0x00d92d5a), X(0x00dbbe5b), X(0x00de5333), | ||
1105 | X(0x00e0ebe3), X(0x00e3886b), X(0x00e628c9), X(0x00e8ccff), | ||
1106 | X(0x00eb750c), X(0x00ee20f0), X(0x00f0d0ab), X(0x00f3843d), | ||
1107 | X(0x00f63ba5), X(0x00f8f6e4), X(0x00fbb5fa), X(0x00fe78e5), | ||
1108 | X(0x01013fa7), X(0x01040a3f), X(0x0106d8ae), X(0x0109aaf2), | ||
1109 | X(0x010c810c), X(0x010f5afb), X(0x011238c0), X(0x01151a5b), | ||
1110 | X(0x0117ffcb), X(0x011ae910), X(0x011dd62a), X(0x0120c719), | ||
1111 | X(0x0123bbdd), X(0x0126b476), X(0x0129b0e4), X(0x012cb126), | ||
1112 | X(0x012fb53c), X(0x0132bd27), X(0x0135c8e6), X(0x0138d879), | ||
1113 | X(0x013bebdf), X(0x013f031a), X(0x01421e28), X(0x01453d0a), | ||
1114 | X(0x01485fbf), X(0x014b8648), X(0x014eb0a4), X(0x0151ded2), | ||
1115 | X(0x015510d4), X(0x015846a8), X(0x015b8050), X(0x015ebdc9), | ||
1116 | X(0x0161ff15), X(0x01654434), X(0x01688d24), X(0x016bd9e6), | ||
1117 | X(0x016f2a7b), X(0x01727ee1), X(0x0175d718), X(0x01793321), | ||
1118 | X(0x017c92fc), X(0x017ff6a7), X(0x01835e24), X(0x0186c972), | ||
1119 | X(0x018a3890), X(0x018dab7f), X(0x0191223f), X(0x01949ccf), | ||
1120 | X(0x01981b2f), X(0x019b9d5f), X(0x019f235f), X(0x01a2ad2f), | ||
1121 | X(0x01a63acf), X(0x01a9cc3e), X(0x01ad617c), X(0x01b0fa8a), | ||
1122 | X(0x01b49767), X(0x01b83813), X(0x01bbdc8d), X(0x01bf84d6), | ||
1123 | X(0x01c330ee), X(0x01c6e0d4), X(0x01ca9488), X(0x01ce4c0b), | ||
1124 | X(0x01d2075b), X(0x01d5c679), X(0x01d98964), X(0x01dd501d), | ||
1125 | X(0x01e11aa3), X(0x01e4e8f6), X(0x01e8bb17), X(0x01ec9104), | ||
1126 | X(0x01f06abd), X(0x01f44844), X(0x01f82996), X(0x01fc0eb5), | ||
1127 | X(0x01fff7a0), X(0x0203e456), X(0x0207d4d9), X(0x020bc926), | ||
1128 | X(0x020fc140), X(0x0213bd24), X(0x0217bcd4), X(0x021bc04e), | ||
1129 | X(0x021fc793), X(0x0223d2a3), X(0x0227e17d), X(0x022bf421), | ||
1130 | X(0x02300a90), X(0x023424c8), X(0x023842ca), X(0x023c6495), | ||
1131 | X(0x02408a2a), X(0x0244b389), X(0x0248e0b0), X(0x024d11a0), | ||
1132 | X(0x02514659), X(0x02557eda), X(0x0259bb24), X(0x025dfb35), | ||
1133 | X(0x02623f0f), X(0x026686b1), X(0x026ad21a), X(0x026f214b), | ||
1134 | X(0x02737443), X(0x0277cb02), X(0x027c2588), X(0x028083d5), | ||
1135 | X(0x0284e5e9), X(0x02894bc2), X(0x028db562), X(0x029222c8), | ||
1136 | X(0x029693f4), X(0x029b08e6), X(0x029f819d), X(0x02a3fe19), | ||
1137 | X(0x02a87e5b), X(0x02ad0261), X(0x02b18a2c), X(0x02b615bb), | ||
1138 | X(0x02baa50f), X(0x02bf3827), X(0x02c3cf03), X(0x02c869a3), | ||
1139 | X(0x02cd0807), X(0x02d1aa2d), X(0x02d65017), X(0x02daf9c4), | ||
1140 | X(0x02dfa734), X(0x02e45866), X(0x02e90d5b), X(0x02edc612), | ||
1141 | X(0x02f2828b), X(0x02f742c6), X(0x02fc06c3), X(0x0300ce80), | ||
1142 | X(0x030599ff), X(0x030a6940), X(0x030f3c40), X(0x03141302), | ||
1143 | X(0x0318ed84), X(0x031dcbc6), X(0x0322adc8), X(0x0327938a), | ||
1144 | X(0x032c7d0c), X(0x03316a4c), X(0x03365b4d), X(0x033b500c), | ||
1145 | X(0x03404889), X(0x034544c6), X(0x034a44c0), X(0x034f4879), | ||
1146 | X(0x03544ff0), X(0x03595b24), X(0x035e6a16), X(0x03637cc5), | ||
1147 | X(0x03689331), X(0x036dad5a), X(0x0372cb40), X(0x0377ece2), | ||
1148 | X(0x037d1240), X(0x03823b5a), X(0x03876830), X(0x038c98c1), | ||
1149 | X(0x0391cd0e), X(0x03970516), X(0x039c40d8), X(0x03a18055), | ||
1150 | X(0x03a6c38d), X(0x03ac0a7f), X(0x03b1552b), X(0x03b6a390), | ||
1151 | X(0x03bbf5af), X(0x03c14b88), X(0x03c6a519), X(0x03cc0263), | ||
1152 | X(0x03d16366), X(0x03d6c821), X(0x03dc3094), X(0x03e19cc0), | ||
1153 | X(0x03e70ca2), X(0x03ec803d), X(0x03f1f78e), X(0x03f77296), | ||
1154 | X(0x03fcf155), X(0x040273cb), X(0x0407f9f7), X(0x040d83d9), | ||
1155 | X(0x04131170), X(0x0418a2bd), X(0x041e37c0), X(0x0423d077), | ||
1156 | X(0x04296ce4), X(0x042f0d04), X(0x0434b0da), X(0x043a5863), | ||
1157 | X(0x044003a0), X(0x0445b290), X(0x044b6534), X(0x04511b8b), | ||
1158 | X(0x0456d595), X(0x045c9352), X(0x046254c1), X(0x046819e1), | ||
1159 | X(0x046de2b4), X(0x0473af39), X(0x04797f6e), X(0x047f5355), | ||
1160 | X(0x04852aec), X(0x048b0635), X(0x0490e52d), X(0x0496c7d6), | ||
1161 | X(0x049cae2e), X(0x04a29836), X(0x04a885ed), X(0x04ae7753), | ||
1162 | X(0x04b46c68), X(0x04ba652b), X(0x04c0619d), X(0x04c661bc), | ||
1163 | X(0x04cc658a), X(0x04d26d04), X(0x04d8782c), X(0x04de8701), | ||
1164 | X(0x04e49983), X(0x04eaafb0), X(0x04f0c98a), X(0x04f6e710), | ||
1165 | X(0x04fd0842), X(0x05032d1e), X(0x050955a6), X(0x050f81d8), | ||
1166 | X(0x0515b1b5), X(0x051be53d), X(0x05221c6e), X(0x05285748), | ||
1167 | X(0x052e95cd), X(0x0534d7fa), X(0x053b1dd0), X(0x0541674e), | ||
1168 | X(0x0547b475), X(0x054e0544), X(0x055459bb), X(0x055ab1d9), | ||
1169 | X(0x05610d9e), X(0x05676d0a), X(0x056dd01c), X(0x057436d5), | ||
1170 | X(0x057aa134), X(0x05810f38), X(0x058780e2), X(0x058df631), | ||
1171 | X(0x05946f25), X(0x059aebbe), X(0x05a16bfa), X(0x05a7efdb), | ||
1172 | X(0x05ae775f), X(0x05b50287), X(0x05bb9152), X(0x05c223c0), | ||
1173 | X(0x05c8b9d0), X(0x05cf5382), X(0x05d5f0d6), X(0x05dc91cc), | ||
1174 | X(0x05e33663), X(0x05e9de9c), X(0x05f08a75), X(0x05f739ee), | ||
1175 | X(0x05fded07), X(0x0604a3c0), X(0x060b5e19), X(0x06121c11), | ||
1176 | X(0x0618dda8), X(0x061fa2dd), X(0x06266bb1), X(0x062d3822), | ||
1177 | X(0x06340831), X(0x063adbde), X(0x0641b328), X(0x06488e0e), | ||
1178 | X(0x064f6c91), X(0x06564eaf), X(0x065d346a), X(0x06641dc0), | ||
1179 | X(0x066b0ab1), X(0x0671fb3d), X(0x0678ef64), X(0x067fe724), | ||
1180 | X(0x0686e27f), X(0x068de173), X(0x0694e400), X(0x069bea27), | ||
1181 | X(0x06a2f3e6), X(0x06aa013d), X(0x06b1122c), X(0x06b826b3), | ||
1182 | X(0x06bf3ed1), X(0x06c65a86), X(0x06cd79d1), X(0x06d49cb3), | ||
1183 | X(0x06dbc32b), X(0x06e2ed38), X(0x06ea1adb), X(0x06f14c13), | ||
1184 | X(0x06f880df), X(0x06ffb940), X(0x0706f535), X(0x070e34bd), | ||
1185 | X(0x071577d9), X(0x071cbe88), X(0x072408c9), X(0x072b569d), | ||
1186 | X(0x0732a802), X(0x0739fcf9), X(0x07415582), X(0x0748b19b), | ||
1187 | X(0x07501145), X(0x0757747f), X(0x075edb49), X(0x076645a3), | ||
1188 | X(0x076db38c), X(0x07752503), X(0x077c9a09), X(0x0784129e), | ||
1189 | X(0x078b8ec0), X(0x07930e70), X(0x079a91ac), X(0x07a21876), | ||
1190 | X(0x07a9a2cc), X(0x07b130ad), X(0x07b8c21b), X(0x07c05714), | ||
1191 | X(0x07c7ef98), X(0x07cf8ba6), X(0x07d72b3f), X(0x07dece62), | ||
1192 | X(0x07e6750e), X(0x07ee1f43), X(0x07f5cd01), X(0x07fd7e48), | ||
1193 | X(0x08053316), X(0x080ceb6d), X(0x0814a74a), X(0x081c66af), | ||
1194 | X(0x0824299a), X(0x082bf00c), X(0x0833ba03), X(0x083b8780), | ||
1195 | X(0x08435882), X(0x084b2d09), X(0x08530514), X(0x085ae0a3), | ||
1196 | X(0x0862bfb6), X(0x086aa24c), X(0x08728865), X(0x087a7201), | ||
1197 | X(0x08825f1e), X(0x088a4fbe), X(0x089243de), X(0x089a3b80), | ||
1198 | X(0x08a236a2), X(0x08aa3545), X(0x08b23767), X(0x08ba3d09), | ||
1199 | X(0x08c2462a), X(0x08ca52c9), X(0x08d262e7), X(0x08da7682), | ||
1200 | X(0x08e28d9c), X(0x08eaa832), X(0x08f2c645), X(0x08fae7d4), | ||
1201 | X(0x09030cdf), X(0x090b3566), X(0x09136168), X(0x091b90e5), | ||
1202 | X(0x0923c3dc), X(0x092bfa4d), X(0x09343437), X(0x093c719b), | ||
1203 | X(0x0944b277), X(0x094cf6cc), X(0x09553e99), X(0x095d89dd), | ||
1204 | X(0x0965d899), X(0x096e2acb), X(0x09768073), X(0x097ed991), | ||
1205 | X(0x09873625), X(0x098f962e), X(0x0997f9ac), X(0x09a0609e), | ||
1206 | X(0x09a8cb04), X(0x09b138dd), X(0x09b9aa29), X(0x09c21ee8), | ||
1207 | X(0x09ca9719), X(0x09d312bc), X(0x09db91d0), X(0x09e41456), | ||
1208 | X(0x09ec9a4b), X(0x09f523b1), X(0x09fdb087), X(0x0a0640cc), | ||
1209 | X(0x0a0ed47f), X(0x0a176ba2), X(0x0a200632), X(0x0a28a42f), | ||
1210 | X(0x0a31459a), X(0x0a39ea72), X(0x0a4292b5), X(0x0a4b3e65), | ||
1211 | X(0x0a53ed80), X(0x0a5ca006), X(0x0a6555f7), X(0x0a6e0f51), | ||
1212 | X(0x0a76cc16), X(0x0a7f8c44), X(0x0a884fda), X(0x0a9116d9), | ||
1213 | X(0x0a99e140), X(0x0aa2af0e), X(0x0aab8043), X(0x0ab454df), | ||
1214 | X(0x0abd2ce1), X(0x0ac60849), X(0x0acee716), X(0x0ad7c948), | ||
1215 | X(0x0ae0aedf), X(0x0ae997d9), X(0x0af28437), X(0x0afb73f7), | ||
1216 | X(0x0b04671b), X(0x0b0d5da0), X(0x0b165788), X(0x0b1f54d0), | ||
1217 | X(0x0b285579), X(0x0b315983), X(0x0b3a60ec), X(0x0b436bb5), | ||
1218 | X(0x0b4c79dd), X(0x0b558b63), X(0x0b5ea048), X(0x0b67b88a), | ||
1219 | X(0x0b70d429), X(0x0b79f324), X(0x0b83157c), X(0x0b8c3b30), | ||
1220 | X(0x0b95643f), X(0x0b9e90a8), X(0x0ba7c06c), X(0x0bb0f38a), | ||
1221 | X(0x0bba2a01), X(0x0bc363d1), X(0x0bcca0f9), X(0x0bd5e17a), | ||
1222 | X(0x0bdf2552), X(0x0be86c81), X(0x0bf1b706), X(0x0bfb04e2), | ||
1223 | X(0x0c045613), X(0x0c0daa99), X(0x0c170274), X(0x0c205da3), | ||
1224 | X(0x0c29bc25), X(0x0c331dfb), X(0x0c3c8323), X(0x0c45eb9e), | ||
1225 | X(0x0c4f576a), X(0x0c58c688), X(0x0c6238f6), X(0x0c6baeb5), | ||
1226 | X(0x0c7527c3), X(0x0c7ea421), X(0x0c8823cd), X(0x0c91a6c8), | ||
1227 | X(0x0c9b2d10), X(0x0ca4b6a6), X(0x0cae4389), X(0x0cb7d3b8), | ||
1228 | X(0x0cc16732), X(0x0ccafdf8), X(0x0cd49809), X(0x0cde3564), | ||
1229 | X(0x0ce7d609), X(0x0cf179f7), X(0x0cfb212e), X(0x0d04cbad), | ||
1230 | X(0x0d0e7974), X(0x0d182a83), X(0x0d21ded8), X(0x0d2b9673), | ||
1231 | X(0x0d355154), X(0x0d3f0f7b), X(0x0d48d0e6), X(0x0d529595), | ||
1232 | X(0x0d5c5d88), X(0x0d6628be), X(0x0d6ff737), X(0x0d79c8f2), | ||
1233 | X(0x0d839dee), X(0x0d8d762c), X(0x0d9751aa), X(0x0da13068), | ||
1234 | X(0x0dab1266), X(0x0db4f7a3), X(0x0dbee01e), X(0x0dc8cbd8), | ||
1235 | X(0x0dd2bace), X(0x0ddcad02), X(0x0de6a272), X(0x0df09b1e), | ||
1236 | X(0x0dfa9705), X(0x0e049627), X(0x0e0e9883), X(0x0e189e19), | ||
1237 | X(0x0e22a6e8), X(0x0e2cb2f0), X(0x0e36c230), X(0x0e40d4a8), | ||
1238 | X(0x0e4aea56), X(0x0e55033b), X(0x0e5f1f56), X(0x0e693ea7), | ||
1239 | X(0x0e73612c), X(0x0e7d86e5), X(0x0e87afd3), X(0x0e91dbf3), | ||
1240 | X(0x0e9c0b47), X(0x0ea63dcc), X(0x0eb07383), X(0x0ebaac6b), | ||
1241 | X(0x0ec4e883), X(0x0ecf27cc), X(0x0ed96a44), X(0x0ee3afea), | ||
1242 | X(0x0eedf8bf), X(0x0ef844c2), X(0x0f0293f2), X(0x0f0ce64e), | ||
1243 | X(0x0f173bd6), X(0x0f21948a), X(0x0f2bf069), X(0x0f364f72), | ||
1244 | X(0x0f40b1a5), X(0x0f4b1701), X(0x0f557f86), X(0x0f5feb32), | ||
1245 | X(0x0f6a5a07), X(0x0f74cc02), X(0x0f7f4124), X(0x0f89b96b), | ||
1246 | X(0x0f9434d8), X(0x0f9eb369), X(0x0fa9351e), X(0x0fb3b9f7), | ||
1247 | X(0x0fbe41f3), X(0x0fc8cd11), X(0x0fd35b51), X(0x0fddecb2), | ||
1248 | X(0x0fe88134), X(0x0ff318d6), X(0x0ffdb397), X(0x10085177), | ||
1249 | X(0x1012f275), X(0x101d9691), X(0x10283dca), X(0x1032e81f), | ||
1250 | X(0x103d9591), X(0x1048461e), X(0x1052f9c5), X(0x105db087), | ||
1251 | X(0x10686a62), X(0x10732756), X(0x107de763), X(0x1088aa87), | ||
1252 | X(0x109370c2), X(0x109e3a14), X(0x10a9067c), X(0x10b3d5f9), | ||
1253 | X(0x10bea88b), X(0x10c97e31), X(0x10d456eb), X(0x10df32b8), | ||
1254 | X(0x10ea1197), X(0x10f4f387), X(0x10ffd889), X(0x110ac09b), | ||
1255 | X(0x1115abbe), X(0x112099ef), X(0x112b8b2f), X(0x11367f7d), | ||
1256 | X(0x114176d9), X(0x114c7141), X(0x11576eb6), X(0x11626f36), | ||
1257 | X(0x116d72c1), X(0x11787957), X(0x118382f6), X(0x118e8f9e), | ||
1258 | X(0x11999f4f), X(0x11a4b208), X(0x11afc7c7), X(0x11bae08e), | ||
1259 | X(0x11c5fc5a), X(0x11d11b2c), X(0x11dc3d02), X(0x11e761dd), | ||
1260 | X(0x11f289ba), X(0x11fdb49b), X(0x1208e27e), X(0x12141362), | ||
1261 | X(0x121f4748), X(0x122a7e2d), X(0x1235b812), X(0x1240f4f6), | ||
1262 | X(0x124c34d9), X(0x125777b9), X(0x1262bd96), X(0x126e0670), | ||
1263 | X(0x12795245), X(0x1284a115), X(0x128ff2e0), X(0x129b47a5), | ||
1264 | X(0x12a69f63), X(0x12b1fa19), X(0x12bd57c7), X(0x12c8b86c), | ||
1265 | X(0x12d41c08), X(0x12df829a), X(0x12eaec21), X(0x12f6589d), | ||
1266 | X(0x1301c80c), X(0x130d3a6f), X(0x1318afc4), X(0x1324280b), | ||
1267 | X(0x132fa344), X(0x133b216d), X(0x1346a286), X(0x1352268e), | ||
1268 | X(0x135dad85), X(0x1369376a), X(0x1374c43c), X(0x138053fb), | ||
1269 | X(0x138be6a5), X(0x13977c3b), X(0x13a314bc), X(0x13aeb026), | ||
1270 | X(0x13ba4e79), X(0x13c5efb5), X(0x13d193d9), X(0x13dd3ae4), | ||
1271 | X(0x13e8e4d6), X(0x13f491ad), X(0x1400416a), X(0x140bf40b), | ||
1272 | X(0x1417a98f), X(0x142361f7), X(0x142f1d41), X(0x143adb6d), | ||
1273 | X(0x14469c7a), X(0x14526067), X(0x145e2734), X(0x1469f0df), | ||
1274 | X(0x1475bd69), X(0x14818cd0), X(0x148d5f15), X(0x14993435), | ||
1275 | X(0x14a50c31), X(0x14b0e708), X(0x14bcc4b8), X(0x14c8a542), | ||
1276 | X(0x14d488a5), X(0x14e06edf), X(0x14ec57f1), X(0x14f843d9), | ||
1277 | X(0x15043297), X(0x1510242b), X(0x151c1892), X(0x15280fcd), | ||
1278 | X(0x153409dc), X(0x154006bc), X(0x154c066e), X(0x155808f1), | ||
1279 | X(0x15640e44), X(0x15701666), X(0x157c2157), X(0x15882f16), | ||
1280 | X(0x15943fa2), X(0x15a052fb), X(0x15ac691f), X(0x15b8820f), | ||
1281 | X(0x15c49dc8), X(0x15d0bc4c), X(0x15dcdd98), X(0x15e901ad), | ||
1282 | X(0x15f52888), X(0x1601522b), X(0x160d7e93), X(0x1619adc1), | ||
1283 | X(0x1625dfb3), X(0x16321469), X(0x163e4be2), X(0x164a861d), | ||
1284 | X(0x1656c31a), X(0x166302d8), X(0x166f4555), X(0x167b8a92), | ||
1285 | X(0x1687d28e), X(0x16941d47), X(0x16a06abe), X(0x16acbaf0), | ||
1286 | X(0x16b90ddf), X(0x16c56388), X(0x16d1bbeb), X(0x16de1708), | ||
1287 | X(0x16ea74dd), X(0x16f6d56a), X(0x170338ae), X(0x170f9ea8), | ||
1288 | X(0x171c0758), X(0x172872bd), X(0x1734e0d6), X(0x174151a2), | ||
1289 | X(0x174dc520), X(0x175a3b51), X(0x1766b432), X(0x17732fc4), | ||
1290 | X(0x177fae05), X(0x178c2ef4), X(0x1798b292), X(0x17a538dd), | ||
1291 | X(0x17b1c1d4), X(0x17be4d77), X(0x17cadbc5), X(0x17d76cbc), | ||
1292 | X(0x17e4005e), X(0x17f096a7), X(0x17fd2f98), X(0x1809cb31), | ||
1293 | X(0x1816696f), X(0x18230a53), X(0x182faddc), X(0x183c5408), | ||
1294 | X(0x1848fcd8), X(0x1855a849), X(0x1862565d), X(0x186f0711), | ||
1295 | X(0x187bba64), X(0x18887057), X(0x189528e9), X(0x18a1e418), | ||
1296 | X(0x18aea1e3), X(0x18bb624b), X(0x18c8254e), X(0x18d4eaeb), | ||
1297 | X(0x18e1b321), X(0x18ee7df1), X(0x18fb4b58), X(0x19081b57), | ||
1298 | X(0x1914edec), X(0x1921c317), X(0x192e9ad6), X(0x193b7529), | ||
1299 | X(0x19485210), X(0x19553189), X(0x19621393), X(0x196ef82e), | ||
1300 | X(0x197bdf59), X(0x1988c913), X(0x1995b55c), X(0x19a2a432), | ||
1301 | X(0x19af9595), X(0x19bc8983), X(0x19c97ffd), X(0x19d67900), | ||
1302 | X(0x19e3748e), X(0x19f072a3), X(0x19fd7341), X(0x1a0a7665), | ||
1303 | X(0x1a177c10), X(0x1a248440), X(0x1a318ef4), X(0x1a3e9c2c), | ||
1304 | X(0x1a4babe7), X(0x1a58be24), X(0x1a65d2e2), X(0x1a72ea20), | ||
1305 | X(0x1a8003de), X(0x1a8d201a), X(0x1a9a3ed5), X(0x1aa7600c), | ||
1306 | X(0x1ab483bf), X(0x1ac1a9ee), X(0x1aced297), X(0x1adbfdba), | ||
1307 | X(0x1ae92b56), X(0x1af65b69), X(0x1b038df4), X(0x1b10c2f5), | ||
1308 | X(0x1b1dfa6b), X(0x1b2b3456), X(0x1b3870b5), X(0x1b45af87), | ||
1309 | X(0x1b52f0ca), X(0x1b60347f), X(0x1b6d7aa4), X(0x1b7ac339), | ||
1310 | X(0x1b880e3c), X(0x1b955bad), X(0x1ba2ab8b), X(0x1baffdd5), | ||
1311 | X(0x1bbd528a), X(0x1bcaa9a9), X(0x1bd80332), X(0x1be55f24), | ||
1312 | X(0x1bf2bd7d), X(0x1c001e3d), X(0x1c0d8164), X(0x1c1ae6ef), | ||
1313 | X(0x1c284edf), X(0x1c35b932), X(0x1c4325e7), X(0x1c5094fe), | ||
1314 | X(0x1c5e0677), X(0x1c6b7a4f), X(0x1c78f086), X(0x1c86691b), | ||
1315 | X(0x1c93e40d), X(0x1ca1615c), X(0x1caee107), X(0x1cbc630c), | ||
1316 | X(0x1cc9e76b), X(0x1cd76e23), X(0x1ce4f733), X(0x1cf2829a), | ||
1317 | X(0x1d001057), X(0x1d0da06a), X(0x1d1b32d1), X(0x1d28c78c), | ||
1318 | X(0x1d365e9a), X(0x1d43f7f9), X(0x1d5193a9), X(0x1d5f31aa), | ||
1319 | X(0x1d6cd1f9), X(0x1d7a7497), X(0x1d881982), X(0x1d95c0ba), | ||
1320 | X(0x1da36a3d), X(0x1db1160a), X(0x1dbec422), X(0x1dcc7482), | ||
1321 | X(0x1dda272b), X(0x1de7dc1a), X(0x1df59350), X(0x1e034ccb), | ||
1322 | X(0x1e11088a), X(0x1e1ec68c), X(0x1e2c86d1), X(0x1e3a4958), | ||
1323 | X(0x1e480e20), X(0x1e55d527), X(0x1e639e6d), X(0x1e7169f1), | ||
1324 | X(0x1e7f37b2), X(0x1e8d07b0), X(0x1e9ad9e8), X(0x1ea8ae5b), | ||
1325 | X(0x1eb68507), X(0x1ec45dec), X(0x1ed23908), X(0x1ee0165b), | ||
1326 | X(0x1eedf5e4), X(0x1efbd7a1), X(0x1f09bb92), X(0x1f17a1b6), | ||
1327 | X(0x1f258a0d), X(0x1f337494), X(0x1f41614b), X(0x1f4f5032), | ||
1328 | X(0x1f5d4147), X(0x1f6b3489), X(0x1f7929f7), X(0x1f872192), | ||
1329 | X(0x1f951b56), X(0x1fa31744), X(0x1fb1155b), X(0x1fbf159a), | ||
1330 | X(0x1fcd17ff), X(0x1fdb1c8b), X(0x1fe9233b), X(0x1ff72c0f), | ||
1331 | X(0x20053706), X(0x20134420), X(0x2021535a), X(0x202f64b4), | ||
1332 | X(0x203d782e), X(0x204b8dc6), X(0x2059a57c), X(0x2067bf4e), | ||
1333 | X(0x2075db3b), X(0x2083f943), X(0x20921964), X(0x20a03b9e), | ||
1334 | X(0x20ae5fef), X(0x20bc8657), X(0x20caaed5), X(0x20d8d967), | ||
1335 | X(0x20e7060e), X(0x20f534c7), X(0x21036592), X(0x2111986e), | ||
1336 | X(0x211fcd59), X(0x212e0454), X(0x213c3d5d), X(0x214a7873), | ||
1337 | X(0x2158b594), X(0x2166f4c1), X(0x217535f8), X(0x21837938), | ||
1338 | X(0x2191be81), X(0x21a005d0), X(0x21ae4f26), X(0x21bc9a81), | ||
1339 | X(0x21cae7e0), X(0x21d93743), X(0x21e788a8), X(0x21f5dc0e), | ||
1340 | X(0x22043174), X(0x221288da), X(0x2220e23e), X(0x222f3da0), | ||
1341 | X(0x223d9afe), X(0x224bfa58), X(0x225a5bac), X(0x2268bef9), | ||
1342 | X(0x2277243f), X(0x22858b7d), X(0x2293f4b0), X(0x22a25fda), | ||
1343 | X(0x22b0ccf8), X(0x22bf3c09), X(0x22cdad0d), X(0x22dc2002), | ||
1344 | X(0x22ea94e8), X(0x22f90bbe), X(0x23078482), X(0x2315ff33), | ||
1345 | X(0x23247bd1), X(0x2332fa5b), X(0x23417acf), X(0x234ffd2c), | ||
1346 | X(0x235e8173), X(0x236d07a0), X(0x237b8fb4), X(0x238a19ae), | ||
1347 | X(0x2398a58c), X(0x23a7334d), X(0x23b5c2f1), X(0x23c45477), | ||
1348 | X(0x23d2e7dd), X(0x23e17d22), X(0x23f01446), X(0x23fead47), | ||
1349 | X(0x240d4825), X(0x241be4dd), X(0x242a8371), X(0x243923dd), | ||
1350 | X(0x2447c622), X(0x24566a3e), X(0x24651031), X(0x2473b7f8), | ||
1351 | X(0x24826194), X(0x24910d03), X(0x249fba44), X(0x24ae6957), | ||
1352 | X(0x24bd1a39), X(0x24cbccea), X(0x24da816a), X(0x24e937b7), | ||
1353 | X(0x24f7efcf), X(0x2506a9b3), X(0x25156560), X(0x252422d6), | ||
1354 | X(0x2532e215), X(0x2541a31a), X(0x255065e4), X(0x255f2a74), | ||
1355 | X(0x256df0c7), X(0x257cb8dd), X(0x258b82b4), X(0x259a4e4c), | ||
1356 | X(0x25a91ba4), X(0x25b7eaba), X(0x25c6bb8e), X(0x25d58e1e), | ||
1357 | X(0x25e46269), X(0x25f3386e), X(0x2602102d), X(0x2610e9a4), | ||
1358 | X(0x261fc4d3), X(0x262ea1b7), X(0x263d8050), X(0x264c609e), | ||
1359 | X(0x265b429e), X(0x266a2650), X(0x26790bb3), X(0x2687f2c6), | ||
1360 | X(0x2696db88), X(0x26a5c5f7), X(0x26b4b213), X(0x26c39fda), | ||
1361 | X(0x26d28f4c), X(0x26e18067), X(0x26f0732b), X(0x26ff6796), | ||
1362 | X(0x270e5da7), X(0x271d555d), X(0x272c4eb7), X(0x273b49b5), | ||
1363 | X(0x274a4654), X(0x27594495), X(0x27684475), X(0x277745f4), | ||
1364 | X(0x27864910), X(0x27954dc9), X(0x27a4541e), X(0x27b35c0d), | ||
1365 | X(0x27c26596), X(0x27d170b7), X(0x27e07d6f), X(0x27ef8bbd), | ||
1366 | X(0x27fe9ba0), X(0x280dad18), X(0x281cc022), X(0x282bd4be), | ||
1367 | X(0x283aeaeb), X(0x284a02a7), X(0x28591bf2), X(0x286836cb), | ||
1368 | X(0x28775330), X(0x28867120), X(0x2895909b), X(0x28a4b19e), | ||
1369 | X(0x28b3d42a), X(0x28c2f83d), X(0x28d21dd5), X(0x28e144f3), | ||
1370 | X(0x28f06d94), X(0x28ff97b8), X(0x290ec35d), X(0x291df082), | ||
1371 | X(0x292d1f27), X(0x293c4f4a), X(0x294b80eb), X(0x295ab407), | ||
1372 | X(0x2969e89e), X(0x29791eaf), X(0x29885639), X(0x29978f3b), | ||
1373 | X(0x29a6c9b3), X(0x29b605a0), X(0x29c54302), X(0x29d481d7), | ||
1374 | X(0x29e3c21e), X(0x29f303d6), X(0x2a0246fd), X(0x2a118b94), | ||
1375 | X(0x2a20d198), X(0x2a301909), X(0x2a3f61e6), X(0x2a4eac2c), | ||
1376 | X(0x2a5df7dc), X(0x2a6d44f4), X(0x2a7c9374), X(0x2a8be359), | ||
1377 | X(0x2a9b34a2), X(0x2aaa8750), X(0x2ab9db60), X(0x2ac930d1), | ||
1378 | X(0x2ad887a3), X(0x2ae7dfd3), X(0x2af73962), X(0x2b06944e), | ||
1379 | X(0x2b15f096), X(0x2b254e38), X(0x2b34ad34), X(0x2b440d89), | ||
1380 | X(0x2b536f34), X(0x2b62d236), X(0x2b72368d), X(0x2b819c38), | ||
1381 | X(0x2b910336), X(0x2ba06b86), X(0x2bafd526), X(0x2bbf4015), | ||
1382 | X(0x2bceac53), X(0x2bde19de), X(0x2bed88b5), X(0x2bfcf8d7), | ||
1383 | X(0x2c0c6a43), X(0x2c1bdcf7), X(0x2c2b50f3), X(0x2c3ac635), | ||
1384 | X(0x2c4a3cbd), X(0x2c59b488), X(0x2c692d97), X(0x2c78a7e7), | ||
1385 | X(0x2c882378), X(0x2c97a049), X(0x2ca71e58), X(0x2cb69da4), | ||
1386 | X(0x2cc61e2c), X(0x2cd59ff0), X(0x2ce522ed), X(0x2cf4a723), | ||
1387 | X(0x2d042c90), X(0x2d13b334), X(0x2d233b0d), X(0x2d32c41a), | ||
1388 | X(0x2d424e5a), X(0x2d51d9cc), X(0x2d61666e), X(0x2d70f440), | ||
1389 | X(0x2d808340), X(0x2d90136e), X(0x2d9fa4c7), X(0x2daf374c), | ||
1390 | X(0x2dbecafa), X(0x2dce5fd1), X(0x2dddf5cf), X(0x2ded8cf4), | ||
1391 | X(0x2dfd253d), X(0x2e0cbeab), X(0x2e1c593b), X(0x2e2bf4ed), | ||
1392 | X(0x2e3b91c0), X(0x2e4b2fb1), X(0x2e5acec1), X(0x2e6a6eee), | ||
1393 | X(0x2e7a1037), X(0x2e89b29b), X(0x2e995618), X(0x2ea8faad), | ||
1394 | X(0x2eb8a05a), X(0x2ec8471c), X(0x2ed7eef4), X(0x2ee797df), | ||
1395 | X(0x2ef741dc), X(0x2f06eceb), X(0x2f16990a), X(0x2f264639), | ||
1396 | X(0x2f35f475), X(0x2f45a3bd), X(0x2f555412), X(0x2f650570), | ||
1397 | X(0x2f74b7d8), X(0x2f846b48), X(0x2f941fbe), X(0x2fa3d53a), | ||
1398 | X(0x2fb38bbb), X(0x2fc3433f), X(0x2fd2fbc5), X(0x2fe2b54c), | ||
1399 | X(0x2ff26fd3), X(0x30022b58), X(0x3011e7db), X(0x3021a55a), | ||
1400 | X(0x303163d4), X(0x30412348), X(0x3050e3b5), X(0x3060a519), | ||
1401 | X(0x30706773), X(0x30802ac3), X(0x308fef06), X(0x309fb43d), | ||
1402 | X(0x30af7a65), X(0x30bf417d), X(0x30cf0985), X(0x30ded27a), | ||
1403 | X(0x30ee9c5d), X(0x30fe672b), X(0x310e32e3), X(0x311dff85), | ||
1404 | X(0x312dcd0f), X(0x313d9b80), X(0x314d6ad7), X(0x315d3b12), | ||
1405 | X(0x316d0c30), X(0x317cde31), X(0x318cb113), X(0x319c84d4), | ||
1406 | X(0x31ac5974), X(0x31bc2ef1), X(0x31cc054b), X(0x31dbdc7f), | ||
1407 | X(0x31ebb48e), X(0x31fb8d74), X(0x320b6733), X(0x321b41c7), | ||
1408 | X(0x322b1d31), X(0x323af96e), X(0x324ad67e), X(0x325ab45f), | ||
1409 | X(0x326a9311), X(0x327a7291), X(0x328a52e0), X(0x329a33fb), | ||
1410 | X(0x32aa15e1), X(0x32b9f892), X(0x32c9dc0c), X(0x32d9c04d), | ||
1411 | X(0x32e9a555), X(0x32f98b22), X(0x330971b4), X(0x33195909), | ||
1412 | X(0x3329411f), X(0x333929f6), X(0x3349138c), X(0x3358fde1), | ||
1413 | X(0x3368e8f2), X(0x3378d4c0), X(0x3388c147), X(0x3398ae89), | ||
1414 | X(0x33a89c82), X(0x33b88b32), X(0x33c87a98), X(0x33d86ab2), | ||
1415 | X(0x33e85b80), X(0x33f84d00), X(0x34083f30), X(0x34183210), | ||
1416 | X(0x3428259f), X(0x343819db), X(0x34480ec3), X(0x34580455), | ||
1417 | X(0x3467fa92), X(0x3477f176), X(0x3487e902), X(0x3497e134), | ||
1418 | X(0x34a7da0a), X(0x34b7d384), X(0x34c7cda0), X(0x34d7c85e), | ||
1419 | X(0x34e7c3bb), X(0x34f7bfb7), X(0x3507bc50), X(0x3517b985), | ||
1420 | X(0x3527b756), X(0x3537b5c0), X(0x3547b4c3), X(0x3557b45d), | ||
1421 | X(0x3567b48d), X(0x3577b552), X(0x3587b6aa), X(0x3597b895), | ||
1422 | X(0x35a7bb12), X(0x35b7be1e), X(0x35c7c1b9), X(0x35d7c5e1), | ||
1423 | X(0x35e7ca96), X(0x35f7cfd6), X(0x3607d5a0), X(0x3617dbf3), | ||
1424 | X(0x3627e2cd), X(0x3637ea2d), X(0x3647f212), X(0x3657fa7b), | ||
1425 | X(0x36680366), X(0x36780cd2), X(0x368816bf), X(0x3698212b), | ||
1426 | X(0x36a82c14), X(0x36b83779), X(0x36c8435a), X(0x36d84fb4), | ||
1427 | X(0x36e85c88), X(0x36f869d2), X(0x37087793), X(0x371885c9), | ||
1428 | X(0x37289473), X(0x3738a38f), X(0x3748b31d), X(0x3758c31a), | ||
1429 | X(0x3768d387), X(0x3778e461), X(0x3788f5a7), X(0x37990759), | ||
1430 | X(0x37a91975), X(0x37b92bf9), X(0x37c93ee4), X(0x37d95236), | ||
1431 | X(0x37e965ed), X(0x37f97a08), X(0x38098e85), X(0x3819a363), | ||
1432 | X(0x3829b8a2), X(0x3839ce3f), X(0x3849e43a), X(0x3859fa91), | ||
1433 | X(0x386a1143), X(0x387a284f), X(0x388a3fb4), X(0x389a5770), | ||
1434 | X(0x38aa6f83), X(0x38ba87ea), X(0x38caa0a5), X(0x38dab9b2), | ||
1435 | X(0x38ead311), X(0x38faecbf), X(0x390b06bc), X(0x391b2107), | ||
1436 | X(0x392b3b9e), X(0x393b5680), X(0x394b71ac), X(0x395b8d20), | ||
1437 | X(0x396ba8dc), X(0x397bc4dd), X(0x398be124), X(0x399bfdae), | ||
1438 | X(0x39ac1a7a), X(0x39bc3788), X(0x39cc54d5), X(0x39dc7261), | ||
1439 | X(0x39ec902a), X(0x39fcae2f), X(0x3a0ccc70), X(0x3a1ceaea), | ||
1440 | X(0x3a2d099c), X(0x3a3d2885), X(0x3a4d47a5), X(0x3a5d66f9), | ||
1441 | X(0x3a6d8680), X(0x3a7da63a), X(0x3a8dc625), X(0x3a9de63f), | ||
1442 | X(0x3aae0688), X(0x3abe26fe), X(0x3ace47a0), X(0x3ade686d), | ||
1443 | X(0x3aee8963), X(0x3afeaa82), X(0x3b0ecbc7), X(0x3b1eed32), | ||
1444 | X(0x3b2f0ec2), X(0x3b3f3075), X(0x3b4f524a), X(0x3b5f7440), | ||
1445 | X(0x3b6f9656), X(0x3b7fb889), X(0x3b8fdada), X(0x3b9ffd46), | ||
1446 | X(0x3bb01fce), X(0x3bc0426e), X(0x3bd06526), X(0x3be087f6), | ||
1447 | X(0x3bf0aada), X(0x3c00cdd4), X(0x3c10f0e0), X(0x3c2113fe), | ||
1448 | X(0x3c31372d), X(0x3c415a6b), X(0x3c517db7), X(0x3c61a110), | ||
1449 | X(0x3c71c475), X(0x3c81e7e4), X(0x3c920b5c), X(0x3ca22edc), | ||
1450 | X(0x3cb25262), X(0x3cc275ee), X(0x3cd2997e), X(0x3ce2bd11), | ||
1451 | X(0x3cf2e0a6), X(0x3d03043b), X(0x3d1327cf), X(0x3d234b61), | ||
1452 | X(0x3d336ef0), X(0x3d43927a), X(0x3d53b5ff), X(0x3d63d97c), | ||
1453 | X(0x3d73fcf1), X(0x3d84205c), X(0x3d9443bd), X(0x3da46711), | ||
1454 | X(0x3db48a58), X(0x3dc4ad91), X(0x3dd4d0ba), X(0x3de4f3d1), | ||
1455 | X(0x3df516d7), X(0x3e0539c9), X(0x3e155ca6), X(0x3e257f6d), | ||
1456 | X(0x3e35a21d), X(0x3e45c4b4), X(0x3e55e731), X(0x3e660994), | ||
1457 | X(0x3e762bda), X(0x3e864e03), X(0x3e96700d), X(0x3ea691f7), | ||
1458 | X(0x3eb6b3bf), X(0x3ec6d565), X(0x3ed6f6e8), X(0x3ee71845), | ||
1459 | X(0x3ef7397c), X(0x3f075a8c), X(0x3f177b73), X(0x3f279c30), | ||
1460 | X(0x3f37bcc2), X(0x3f47dd27), X(0x3f57fd5f), X(0x3f681d68), | ||
1461 | X(0x3f783d40), X(0x3f885ce7), X(0x3f987c5c), X(0x3fa89b9c), | ||
1462 | X(0x3fb8baa7), X(0x3fc8d97c), X(0x3fd8f819), X(0x3fe9167e), | ||
1463 | X(0x3ff934a8), X(0x40095296), X(0x40197049), X(0x40298dbd), | ||
1464 | X(0x4039aaf2), X(0x4049c7e7), X(0x4059e49a), X(0x406a010a), | ||
1465 | X(0x407a1d36), X(0x408a391d), X(0x409a54bd), X(0x40aa7015), | ||
1466 | X(0x40ba8b25), X(0x40caa5ea), X(0x40dac063), X(0x40eada90), | ||
1467 | X(0x40faf46e), X(0x410b0dfe), X(0x411b273d), X(0x412b402a), | ||
1468 | X(0x413b58c4), X(0x414b710a), X(0x415b88fa), X(0x416ba093), | ||
1469 | X(0x417bb7d5), X(0x418bcebe), X(0x419be54c), X(0x41abfb7e), | ||
1470 | X(0x41bc1153), X(0x41cc26ca), X(0x41dc3be2), X(0x41ec5099), | ||
1471 | X(0x41fc64ef), X(0x420c78e1), X(0x421c8c6f), X(0x422c9f97), | ||
1472 | X(0x423cb258), X(0x424cc4b2), X(0x425cd6a2), X(0x426ce827), | ||
1473 | X(0x427cf941), X(0x428d09ee), X(0x429d1a2c), X(0x42ad29fb), | ||
1474 | X(0x42bd3959), X(0x42cd4846), X(0x42dd56bf), X(0x42ed64c3), | ||
1475 | X(0x42fd7252), X(0x430d7f6a), X(0x431d8c0a), X(0x432d9831), | ||
1476 | X(0x433da3dd), X(0x434daf0d), X(0x435db9c0), X(0x436dc3f5), | ||
1477 | X(0x437dcdab), X(0x438dd6df), X(0x439ddf92), X(0x43ade7c1), | ||
1478 | X(0x43bdef6c), X(0x43cdf691), X(0x43ddfd2f), X(0x43ee0345), | ||
1479 | X(0x43fe08d2), X(0x440e0dd4), X(0x441e124b), X(0x442e1634), | ||
1480 | X(0x443e198f), X(0x444e1c5a), X(0x445e1e95), X(0x446e203e), | ||
1481 | X(0x447e2153), X(0x448e21d5), X(0x449e21c0), X(0x44ae2115), | ||
1482 | X(0x44be1fd1), X(0x44ce1df4), X(0x44de1b7d), X(0x44ee186a), | ||
1483 | X(0x44fe14ba), X(0x450e106b), X(0x451e0b7e), X(0x452e05ef), | ||
1484 | X(0x453dffbf), X(0x454df8eb), X(0x455df173), X(0x456de956), | ||
1485 | X(0x457de092), X(0x458dd726), X(0x459dcd10), X(0x45adc251), | ||
1486 | X(0x45bdb6e5), X(0x45cdaacd), X(0x45dd9e06), X(0x45ed9091), | ||
1487 | X(0x45fd826a), X(0x460d7392), X(0x461d6407), X(0x462d53c8), | ||
1488 | X(0x463d42d4), X(0x464d3129), X(0x465d1ec6), X(0x466d0baa), | ||
1489 | X(0x467cf7d3), X(0x468ce342), X(0x469ccdf3), X(0x46acb7e7), | ||
1490 | X(0x46bca11c), X(0x46cc8990), X(0x46dc7143), X(0x46ec5833), | ||
1491 | X(0x46fc3e5f), X(0x470c23c6), X(0x471c0867), X(0x472bec40), | ||
1492 | X(0x473bcf50), X(0x474bb196), X(0x475b9311), X(0x476b73c0), | ||
1493 | X(0x477b53a1), X(0x478b32b4), X(0x479b10f6), X(0x47aaee67), | ||
1494 | X(0x47bacb06), X(0x47caa6d1), X(0x47da81c7), X(0x47ea5be7), | ||
1495 | X(0x47fa3530), X(0x480a0da1), X(0x4819e537), X(0x4829bbf3), | ||
1496 | X(0x483991d3), X(0x484966d6), X(0x48593afb), X(0x48690e3f), | ||
1497 | X(0x4878e0a3), X(0x4888b225), X(0x489882c4), X(0x48a8527e), | ||
1498 | X(0x48b82153), X(0x48c7ef41), X(0x48d7bc47), X(0x48e78863), | ||
1499 | X(0x48f75396), X(0x49071ddc), X(0x4916e736), X(0x4926afa2), | ||
1500 | X(0x4936771f), X(0x49463dac), X(0x49560347), X(0x4965c7ef), | ||
1501 | X(0x49758ba4), X(0x49854e63), X(0x4995102c), X(0x49a4d0fe), | ||
1502 | X(0x49b490d7), X(0x49c44fb6), X(0x49d40d9a), X(0x49e3ca82), | ||
1503 | X(0x49f3866c), X(0x4a034159), X(0x4a12fb45), X(0x4a22b430), | ||
1504 | X(0x4a326c19), X(0x4a4222ff), X(0x4a51d8e1), X(0x4a618dbd), | ||
1505 | X(0x4a714192), X(0x4a80f45f), X(0x4a90a623), X(0x4aa056dd), | ||
1506 | X(0x4ab0068b), X(0x4abfb52c), X(0x4acf62c0), X(0x4adf0f44), | ||
1507 | X(0x4aeebab9), X(0x4afe651c), X(0x4b0e0e6c), X(0x4b1db6a9), | ||
1508 | X(0x4b2d5dd1), X(0x4b3d03e2), X(0x4b4ca8dd), X(0x4b5c4cbf), | ||
1509 | X(0x4b6bef88), X(0x4b7b9136), X(0x4b8b31c8), X(0x4b9ad13d), | ||
1510 | X(0x4baa6f93), X(0x4bba0ccb), X(0x4bc9a8e2), X(0x4bd943d7), | ||
1511 | X(0x4be8dda9), X(0x4bf87658), X(0x4c080de1), X(0x4c17a444), | ||
1512 | X(0x4c27397f), X(0x4c36cd92), X(0x4c46607b), X(0x4c55f239), | ||
1513 | X(0x4c6582cb), X(0x4c75122f), X(0x4c84a065), X(0x4c942d6c), | ||
1514 | X(0x4ca3b942), X(0x4cb343e6), X(0x4cc2cd57), X(0x4cd25594), | ||
1515 | X(0x4ce1dc9c), X(0x4cf1626d), X(0x4d00e707), X(0x4d106a68), | ||
1516 | X(0x4d1fec8f), X(0x4d2f6d7a), X(0x4d3eed2a), X(0x4d4e6b9d), | ||
1517 | X(0x4d5de8d1), X(0x4d6d64c5), X(0x4d7cdf79), X(0x4d8c58eb), | ||
1518 | X(0x4d9bd11a), X(0x4dab4804), X(0x4dbabdaa), X(0x4dca3209), | ||
1519 | X(0x4dd9a520), X(0x4de916ef), X(0x4df88774), X(0x4e07f6ae), | ||
1520 | X(0x4e17649c), X(0x4e26d13c), X(0x4e363c8f), X(0x4e45a692), | ||
1521 | X(0x4e550f44), X(0x4e6476a4), X(0x4e73dcb2), X(0x4e83416c), | ||
1522 | X(0x4e92a4d1), X(0x4ea206df), X(0x4eb16796), X(0x4ec0c6f5), | ||
1523 | X(0x4ed024fa), X(0x4edf81a5), X(0x4eeedcf3), X(0x4efe36e5), | ||
1524 | X(0x4f0d8f79), X(0x4f1ce6ad), X(0x4f2c3c82), X(0x4f3b90f4), | ||
1525 | X(0x4f4ae405), X(0x4f5a35b1), X(0x4f6985fa), X(0x4f78d4dc), | ||
1526 | X(0x4f882257), X(0x4f976e6a), X(0x4fa6b914), X(0x4fb60254), | ||
1527 | X(0x4fc54a28), X(0x4fd49090), X(0x4fe3d58b), X(0x4ff31917), | ||
1528 | X(0x50025b33), X(0x50119bde), X(0x5020db17), X(0x503018dd), | ||
1529 | X(0x503f552f), X(0x504e900b), X(0x505dc971), X(0x506d0160), | ||
1530 | X(0x507c37d7), X(0x508b6cd3), X(0x509aa055), X(0x50a9d25b), | ||
1531 | X(0x50b902e4), X(0x50c831ef), X(0x50d75f7b), X(0x50e68b87), | ||
1532 | X(0x50f5b612), X(0x5104df1a), X(0x5114069f), X(0x51232ca0), | ||
1533 | X(0x5132511a), X(0x5141740f), X(0x5150957b), X(0x515fb55f), | ||
1534 | X(0x516ed3b8), X(0x517df087), X(0x518d0bca), X(0x519c257f), | ||
1535 | X(0x51ab3da7), X(0x51ba543f), X(0x51c96947), X(0x51d87cbd), | ||
1536 | X(0x51e78ea1), X(0x51f69ef1), X(0x5205adad), X(0x5214bad3), | ||
1537 | X(0x5223c662), X(0x5232d05a), X(0x5241d8b9), X(0x5250df7d), | ||
1538 | X(0x525fe4a7), X(0x526ee835), X(0x527dea26), X(0x528cea78), | ||
1539 | X(0x529be92c), X(0x52aae63f), X(0x52b9e1b0), X(0x52c8db80), | ||
1540 | X(0x52d7d3ac), X(0x52e6ca33), X(0x52f5bf15), X(0x5304b251), | ||
1541 | X(0x5313a3e5), X(0x532293d0), X(0x53318212), X(0x53406ea8), | ||
1542 | X(0x534f5993), X(0x535e42d2), X(0x536d2a62), X(0x537c1043), | ||
1543 | X(0x538af475), X(0x5399d6f6), X(0x53a8b7c4), X(0x53b796e0), | ||
1544 | X(0x53c67447), X(0x53d54ffa), X(0x53e429f6), X(0x53f3023b), | ||
1545 | X(0x5401d8c8), X(0x5410ad9c), X(0x541f80b5), X(0x542e5213), | ||
1546 | X(0x543d21b5), X(0x544bef9a), X(0x545abbc0), X(0x54698627), | ||
1547 | X(0x54784ece), X(0x548715b3), X(0x5495dad6), X(0x54a49e35), | ||
1548 | X(0x54b35fd0), X(0x54c21fa6), X(0x54d0ddb5), X(0x54df99fd), | ||
1549 | X(0x54ee547c), X(0x54fd0d32), X(0x550bc41d), X(0x551a793d), | ||
1550 | X(0x55292c91), X(0x5537de16), X(0x55468dce), X(0x55553bb6), | ||
1551 | X(0x5563e7cd), X(0x55729213), X(0x55813a87), X(0x558fe127), | ||
1552 | X(0x559e85f2), X(0x55ad28e9), X(0x55bbca08), X(0x55ca6950), | ||
1553 | X(0x55d906c0), X(0x55e7a257), X(0x55f63c13), X(0x5604d3f4), | ||
1554 | X(0x561369f8), X(0x5621fe1f), X(0x56309067), X(0x563f20d1), | ||
1555 | X(0x564daf5a), X(0x565c3c02), X(0x566ac6c7), X(0x56794faa), | ||
1556 | X(0x5687d6a8), X(0x56965bc1), X(0x56a4def4), X(0x56b36040), | ||
1557 | X(0x56c1dfa4), X(0x56d05d1f), X(0x56ded8af), X(0x56ed5255), | ||
1558 | X(0x56fbca0f), X(0x570a3fdc), X(0x5718b3bc), X(0x572725ac), | ||
1559 | X(0x573595ad), X(0x574403bd), X(0x57526fdb), X(0x5760da07), | ||
1560 | X(0x576f423f), X(0x577da883), X(0x578c0cd1), X(0x579a6f29), | ||
1561 | X(0x57a8cf8a), X(0x57b72df2), X(0x57c58a61), X(0x57d3e4d6), | ||
1562 | X(0x57e23d50), X(0x57f093cd), X(0x57fee84e), X(0x580d3ad1), | ||
1563 | X(0x581b8b54), X(0x5829d9d8), X(0x5838265c), X(0x584670dd), | ||
1564 | X(0x5854b95c), X(0x5862ffd8), X(0x5871444f), X(0x587f86c1), | ||
1565 | X(0x588dc72c), X(0x589c0591), X(0x58aa41ed), X(0x58b87c40), | ||
1566 | X(0x58c6b489), X(0x58d4eac7), X(0x58e31ef9), X(0x58f1511f), | ||
1567 | X(0x58ff8137), X(0x590daf40), X(0x591bdb3a), X(0x592a0524), | ||
1568 | X(0x59382cfc), X(0x594652c2), X(0x59547675), X(0x59629815), | ||
1569 | X(0x5970b79f), X(0x597ed513), X(0x598cf071), X(0x599b09b7), | ||
1570 | X(0x59a920e5), X(0x59b735f9), X(0x59c548f4), X(0x59d359d2), | ||
1571 | X(0x59e16895), X(0x59ef753b), X(0x59fd7fc4), X(0x5a0b882d), | ||
1572 | X(0x5a198e77), X(0x5a2792a0), X(0x5a3594a9), X(0x5a43948e), | ||
1573 | X(0x5a519251), X(0x5a5f8df0), X(0x5a6d876a), X(0x5a7b7ebe), | ||
1574 | X(0x5a8973ec), X(0x5a9766f2), X(0x5aa557d0), X(0x5ab34685), | ||
1575 | X(0x5ac1330f), X(0x5acf1d6f), X(0x5add05a3), X(0x5aeaebaa), | ||
1576 | X(0x5af8cf84), X(0x5b06b12f), X(0x5b1490ab), X(0x5b226df7), | ||
1577 | X(0x5b304912), X(0x5b3e21fc), X(0x5b4bf8b2), X(0x5b59cd35), | ||
1578 | X(0x5b679f84), X(0x5b756f9e), X(0x5b833d82), X(0x5b91092e), | ||
1579 | X(0x5b9ed2a3), X(0x5bac99e0), X(0x5bba5ee3), X(0x5bc821ac), | ||
1580 | X(0x5bd5e23a), X(0x5be3a08c), X(0x5bf15ca1), X(0x5bff1679), | ||
1581 | X(0x5c0cce12), X(0x5c1a836c), X(0x5c283686), X(0x5c35e760), | ||
1582 | X(0x5c4395f7), X(0x5c51424c), X(0x5c5eec5e), X(0x5c6c942b), | ||
1583 | X(0x5c7a39b4), X(0x5c87dcf7), X(0x5c957df3), X(0x5ca31ca8), | ||
1584 | X(0x5cb0b915), X(0x5cbe5338), X(0x5ccbeb12), X(0x5cd980a1), | ||
1585 | X(0x5ce713e5), X(0x5cf4a4dd), X(0x5d023387), X(0x5d0fbfe4), | ||
1586 | X(0x5d1d49f2), X(0x5d2ad1b1), X(0x5d38571f), X(0x5d45da3c), | ||
1587 | X(0x5d535b08), X(0x5d60d981), X(0x5d6e55a7), X(0x5d7bcf78), | ||
1588 | X(0x5d8946f5), X(0x5d96bc1c), X(0x5da42eec), X(0x5db19f65), | ||
1589 | X(0x5dbf0d86), X(0x5dcc794e), X(0x5dd9e2bd), X(0x5de749d1), | ||
1590 | X(0x5df4ae8a), X(0x5e0210e7), X(0x5e0f70e7), X(0x5e1cce8a), | ||
1591 | X(0x5e2a29ce), X(0x5e3782b4), X(0x5e44d93a), X(0x5e522d5f), | ||
1592 | X(0x5e5f7f23), X(0x5e6cce85), X(0x5e7a1b85), X(0x5e876620), | ||
1593 | X(0x5e94ae58), X(0x5ea1f42a), X(0x5eaf3797), X(0x5ebc789d), | ||
1594 | X(0x5ec9b73c), X(0x5ed6f372), X(0x5ee42d41), X(0x5ef164a5), | ||
1595 | X(0x5efe999f), X(0x5f0bcc2f), X(0x5f18fc52), X(0x5f262a09), | ||
1596 | X(0x5f335553), X(0x5f407e2f), X(0x5f4da49d), X(0x5f5ac89b), | ||
1597 | X(0x5f67ea29), X(0x5f750946), X(0x5f8225f2), X(0x5f8f402b), | ||
1598 | X(0x5f9c57f2), X(0x5fa96d44), X(0x5fb68023), X(0x5fc3908c), | ||
1599 | X(0x5fd09e7f), X(0x5fdda9fc), X(0x5feab302), X(0x5ff7b990), | ||
1600 | X(0x6004bda5), X(0x6011bf40), X(0x601ebe62), X(0x602bbb09), | ||
1601 | X(0x6038b534), X(0x6045ace4), X(0x6052a216), X(0x605f94cb), | ||
1602 | X(0x606c8502), X(0x607972b9), X(0x60865df2), X(0x609346aa), | ||
1603 | X(0x60a02ce1), X(0x60ad1096), X(0x60b9f1c9), X(0x60c6d079), | ||
1604 | X(0x60d3aca5), X(0x60e0864d), X(0x60ed5d70), X(0x60fa320d), | ||
1605 | X(0x61070424), X(0x6113d3b4), X(0x6120a0bc), X(0x612d6b3c), | ||
1606 | X(0x613a3332), X(0x6146f89f), X(0x6153bb82), X(0x61607bd9), | ||
1607 | X(0x616d39a5), X(0x6179f4e5), X(0x6186ad98), X(0x619363bd), | ||
1608 | X(0x61a01753), X(0x61acc85b), X(0x61b976d3), X(0x61c622bc), | ||
1609 | X(0x61d2cc13), X(0x61df72d8), X(0x61ec170c), X(0x61f8b8ad), | ||
1610 | X(0x620557ba), X(0x6211f434), X(0x621e8e18), X(0x622b2568), | ||
1611 | X(0x6237ba21), X(0x62444c44), X(0x6250dbd0), X(0x625d68c4), | ||
1612 | X(0x6269f320), X(0x62767ae2), X(0x6283000b), X(0x628f829a), | ||
1613 | X(0x629c028e), X(0x62a87fe6), X(0x62b4faa2), X(0x62c172c2), | ||
1614 | X(0x62cde844), X(0x62da5b29), X(0x62e6cb6e), X(0x62f33915), | ||
1615 | X(0x62ffa41c), X(0x630c0c83), X(0x63187248), X(0x6324d56d), | ||
1616 | X(0x633135ef), X(0x633d93ce), X(0x6349ef0b), X(0x635647a3), | ||
1617 | X(0x63629d97), X(0x636ef0e6), X(0x637b418f), X(0x63878f92), | ||
1618 | X(0x6393daef), X(0x63a023a4), X(0x63ac69b1), X(0x63b8ad15), | ||
1619 | X(0x63c4edd1), X(0x63d12be3), X(0x63dd674b), X(0x63e9a008), | ||
1620 | X(0x63f5d61a), X(0x64020980), X(0x640e3a39), X(0x641a6846), | ||
1621 | X(0x642693a5), X(0x6432bc56), X(0x643ee258), X(0x644b05ab), | ||
1622 | X(0x6457264e), X(0x64634441), X(0x646f5f83), X(0x647b7814), | ||
1623 | X(0x64878df3), X(0x6493a120), X(0x649fb199), X(0x64abbf5f), | ||
1624 | X(0x64b7ca71), X(0x64c3d2ce), X(0x64cfd877), X(0x64dbdb69), | ||
1625 | X(0x64e7dba6), X(0x64f3d92b), X(0x64ffd3fa), X(0x650bcc11), | ||
1626 | X(0x6517c16f), X(0x6523b415), X(0x652fa402), X(0x653b9134), | ||
1627 | X(0x65477bad), X(0x6553636a), X(0x655f486d), X(0x656b2ab3), | ||
1628 | X(0x65770a3d), X(0x6582e70a), X(0x658ec11a), X(0x659a986d), | ||
1629 | X(0x65a66d00), X(0x65b23ed5), X(0x65be0deb), X(0x65c9da41), | ||
1630 | X(0x65d5a3d7), X(0x65e16aac), X(0x65ed2ebf), X(0x65f8f011), | ||
1631 | X(0x6604aea1), X(0x66106a6e), X(0x661c2377), X(0x6627d9be), | ||
1632 | X(0x66338d40), X(0x663f3dfd), X(0x664aebf5), X(0x66569728), | ||
1633 | X(0x66623f95), X(0x666de53b), X(0x6679881b), X(0x66852833), | ||
1634 | X(0x6690c583), X(0x669c600b), X(0x66a7f7ca), X(0x66b38cc0), | ||
1635 | X(0x66bf1eec), X(0x66caae4f), X(0x66d63ae6), X(0x66e1c4b3), | ||
1636 | X(0x66ed4bb4), X(0x66f8cfea), X(0x67045153), X(0x670fcfef), | ||
1637 | X(0x671b4bbe), X(0x6726c4bf), X(0x67323af3), X(0x673dae58), | ||
1638 | X(0x67491eee), X(0x67548cb5), X(0x675ff7ab), X(0x676b5fd2), | ||
1639 | X(0x6776c528), X(0x678227ad), X(0x678d8761), X(0x6798e443), | ||
1640 | X(0x67a43e52), X(0x67af958f), X(0x67bae9f9), X(0x67c63b8f), | ||
1641 | X(0x67d18a52), X(0x67dcd640), X(0x67e81f59), X(0x67f3659d), | ||
1642 | X(0x67fea90c), X(0x6809e9a5), X(0x68152768), X(0x68206254), | ||
1643 | X(0x682b9a68), X(0x6836cfa6), X(0x6842020b), X(0x684d3199), | ||
1644 | X(0x68585e4d), X(0x68638829), X(0x686eaf2b), X(0x6879d354), | ||
1645 | X(0x6884f4a2), X(0x68901316), X(0x689b2eb0), X(0x68a6476d), | ||
1646 | X(0x68b15d50), X(0x68bc7056), X(0x68c78080), X(0x68d28dcd), | ||
1647 | X(0x68dd983e), X(0x68e89fd0), X(0x68f3a486), X(0x68fea65d), | ||
1648 | X(0x6909a555), X(0x6914a16f), X(0x691f9aa9), X(0x692a9104), | ||
1649 | X(0x69358480), X(0x6940751b), X(0x694b62d5), X(0x69564daf), | ||
1650 | X(0x696135a7), X(0x696c1abe), X(0x6976fcf3), X(0x6981dc46), | ||
1651 | X(0x698cb8b6), X(0x69979243), X(0x69a268ed), X(0x69ad3cb4), | ||
1652 | X(0x69b80d97), X(0x69c2db96), X(0x69cda6b0), X(0x69d86ee5), | ||
1653 | X(0x69e33436), X(0x69edf6a1), X(0x69f8b626), X(0x6a0372c5), | ||
1654 | X(0x6a0e2c7e), X(0x6a18e350), X(0x6a23973c), X(0x6a2e4840), | ||
1655 | X(0x6a38f65d), X(0x6a43a191), X(0x6a4e49de), X(0x6a58ef42), | ||
1656 | X(0x6a6391be), X(0x6a6e3151), X(0x6a78cdfa), X(0x6a8367ba), | ||
1657 | X(0x6a8dfe90), X(0x6a98927c), X(0x6aa3237d), X(0x6aadb194), | ||
1658 | X(0x6ab83cc0), X(0x6ac2c500), X(0x6acd4a55), X(0x6ad7ccbf), | ||
1659 | X(0x6ae24c3c), X(0x6aecc8cd), X(0x6af74271), X(0x6b01b929), | ||
1660 | X(0x6b0c2cf4), X(0x6b169dd1), X(0x6b210bc1), X(0x6b2b76c2), | ||
1661 | X(0x6b35ded6), X(0x6b4043fc), X(0x6b4aa632), X(0x6b55057a), | ||
1662 | X(0x6b5f61d3), X(0x6b69bb3d), X(0x6b7411b7), X(0x6b7e6541), | ||
1663 | X(0x6b88b5db), X(0x6b930385), X(0x6b9d4e3f), X(0x6ba79607), | ||
1664 | X(0x6bb1dadf), X(0x6bbc1cc6), X(0x6bc65bbb), X(0x6bd097bf), | ||
1665 | X(0x6bdad0d0), X(0x6be506f0), X(0x6bef3a1d), X(0x6bf96a58), | ||
1666 | X(0x6c0397a0), X(0x6c0dc1f5), X(0x6c17e957), X(0x6c220dc6), | ||
1667 | X(0x6c2c2f41), X(0x6c364dc9), X(0x6c40695c), X(0x6c4a81fc), | ||
1668 | X(0x6c5497a7), X(0x6c5eaa5d), X(0x6c68ba1f), X(0x6c72c6eb), | ||
1669 | X(0x6c7cd0c3), X(0x6c86d7a6), X(0x6c90db92), X(0x6c9adc8a), | ||
1670 | X(0x6ca4da8b), X(0x6caed596), X(0x6cb8cdab), X(0x6cc2c2ca), | ||
1671 | X(0x6cccb4f2), X(0x6cd6a424), X(0x6ce0905e), X(0x6cea79a1), | ||
1672 | X(0x6cf45fee), X(0x6cfe4342), X(0x6d0823a0), X(0x6d120105), | ||
1673 | X(0x6d1bdb73), X(0x6d25b2e8), X(0x6d2f8765), X(0x6d3958ea), | ||
1674 | X(0x6d432777), X(0x6d4cf30a), X(0x6d56bba5), X(0x6d608147), | ||
1675 | X(0x6d6a43f0), X(0x6d7403a0), X(0x6d7dc056), X(0x6d877a13), | ||
1676 | X(0x6d9130d6), X(0x6d9ae4a0), X(0x6da4956f), X(0x6dae4345), | ||
1677 | X(0x6db7ee20), X(0x6dc19601), X(0x6dcb3ae7), X(0x6dd4dcd3), | ||
1678 | X(0x6dde7bc4), X(0x6de817bb), X(0x6df1b0b6), X(0x6dfb46b7), | ||
1679 | X(0x6e04d9bc), X(0x6e0e69c7), X(0x6e17f6d5), X(0x6e2180e9), | ||
1680 | X(0x6e2b0801), X(0x6e348c1d), X(0x6e3e0d3d), X(0x6e478b62), | ||
1681 | X(0x6e51068a), X(0x6e5a7eb7), X(0x6e63f3e7), X(0x6e6d661b), | ||
1682 | X(0x6e76d552), X(0x6e80418e), X(0x6e89aacc), X(0x6e93110f), | ||
1683 | X(0x6e9c7454), X(0x6ea5d49d), X(0x6eaf31e9), X(0x6eb88c37), | ||
1684 | X(0x6ec1e389), X(0x6ecb37de), X(0x6ed48936), X(0x6eddd790), | ||
1685 | X(0x6ee722ee), X(0x6ef06b4d), X(0x6ef9b0b0), X(0x6f02f315), | ||
1686 | X(0x6f0c327c), X(0x6f156ee6), X(0x6f1ea852), X(0x6f27dec1), | ||
1687 | X(0x6f311232), X(0x6f3a42a5), X(0x6f43701a), X(0x6f4c9a91), | ||
1688 | X(0x6f55c20a), X(0x6f5ee686), X(0x6f680803), X(0x6f712682), | ||
1689 | X(0x6f7a4203), X(0x6f835a86), X(0x6f8c700b), X(0x6f958291), | ||
1690 | X(0x6f9e921a), X(0x6fa79ea4), X(0x6fb0a830), X(0x6fb9aebd), | ||
1691 | X(0x6fc2b24c), X(0x6fcbb2dd), X(0x6fd4b06f), X(0x6fddab03), | ||
1692 | X(0x6fe6a299), X(0x6fef9730), X(0x6ff888c9), X(0x70017763), | ||
1693 | X(0x700a62ff), X(0x70134b9c), X(0x701c313b), X(0x702513dc), | ||
1694 | X(0x702df37e), X(0x7036d021), X(0x703fa9c6), X(0x7048806d), | ||
1695 | X(0x70515415), X(0x705a24bf), X(0x7062f26b), X(0x706bbd17), | ||
1696 | X(0x707484c6), X(0x707d4976), X(0x70860b28), X(0x708ec9dc), | ||
1697 | X(0x70978591), X(0x70a03e48), X(0x70a8f400), X(0x70b1a6bb), | ||
1698 | X(0x70ba5677), X(0x70c30335), X(0x70cbacf5), X(0x70d453b6), | ||
1699 | X(0x70dcf77a), X(0x70e59840), X(0x70ee3607), X(0x70f6d0d1), | ||
1700 | X(0x70ff689d), X(0x7107fd6b), X(0x71108f3b), X(0x71191e0d), | ||
1701 | X(0x7121a9e2), X(0x712a32b9), X(0x7132b892), X(0x713b3b6e), | ||
1702 | X(0x7143bb4c), X(0x714c382d), X(0x7154b211), X(0x715d28f7), | ||
1703 | X(0x71659ce0), X(0x716e0dcc), X(0x71767bbb), X(0x717ee6ac), | ||
1704 | X(0x71874ea1), X(0x718fb399), X(0x71981594), X(0x71a07493), | ||
1705 | X(0x71a8d094), X(0x71b1299a), X(0x71b97fa2), X(0x71c1d2af), | ||
1706 | X(0x71ca22bf), X(0x71d26fd2), X(0x71dab9ea), X(0x71e30106), | ||
1707 | X(0x71eb4526), X(0x71f3864a), X(0x71fbc472), X(0x7203ff9e), | ||
1708 | X(0x720c37cf), X(0x72146d05), X(0x721c9f3f), X(0x7224ce7e), | ||
1709 | X(0x722cfac2), X(0x7235240b), X(0x723d4a59), X(0x72456dad), | ||
1710 | X(0x724d8e05), X(0x7255ab63), X(0x725dc5c7), X(0x7265dd31), | ||
1711 | X(0x726df1a0), X(0x72760315), X(0x727e1191), X(0x72861d12), | ||
1712 | X(0x728e259a), X(0x72962b28), X(0x729e2dbd), X(0x72a62d59), | ||
1713 | X(0x72ae29fc), X(0x72b623a5), X(0x72be1a56), X(0x72c60e0e), | ||
1714 | X(0x72cdfece), X(0x72d5ec95), X(0x72ddd764), X(0x72e5bf3b), | ||
1715 | X(0x72eda41a), X(0x72f58601), X(0x72fd64f1), X(0x730540e9), | ||
1716 | X(0x730d19e9), X(0x7314eff3), X(0x731cc305), X(0x73249321), | ||
1717 | X(0x732c6046), X(0x73342a75), X(0x733bf1ad), X(0x7343b5ef), | ||
1718 | X(0x734b773b), X(0x73533591), X(0x735af0f2), X(0x7362a95d), | ||
1719 | X(0x736a5ed3), X(0x73721153), X(0x7379c0df), X(0x73816d76), | ||
1720 | X(0x73891719), X(0x7390bdc7), X(0x73986181), X(0x73a00247), | ||
1721 | X(0x73a7a01a), X(0x73af3af8), X(0x73b6d2e4), X(0x73be67dc), | ||
1722 | X(0x73c5f9e1), X(0x73cd88f3), X(0x73d51513), X(0x73dc9e40), | ||
1723 | X(0x73e4247c), X(0x73eba7c5), X(0x73f3281c), X(0x73faa582), | ||
1724 | X(0x74021ff7), X(0x7409977b), X(0x74110c0d), X(0x74187daf), | ||
1725 | X(0x741fec61), X(0x74275822), X(0x742ec0f3), X(0x743626d5), | ||
1726 | X(0x743d89c7), X(0x7444e9c9), X(0x744c46dd), X(0x7453a101), | ||
1727 | X(0x745af837), X(0x74624c7f), X(0x74699dd8), X(0x7470ec44), | ||
1728 | X(0x747837c2), X(0x747f8052), X(0x7486c5f5), X(0x748e08ac), | ||
1729 | X(0x74954875), X(0x749c8552), X(0x74a3bf43), X(0x74aaf648), | ||
1730 | X(0x74b22a62), X(0x74b95b90), X(0x74c089d2), X(0x74c7b52a), | ||
1731 | X(0x74cedd97), X(0x74d6031a), X(0x74dd25b2), X(0x74e44561), | ||
1732 | X(0x74eb6226), X(0x74f27c02), X(0x74f992f5), X(0x7500a6ff), | ||
1733 | X(0x7507b820), X(0x750ec659), X(0x7515d1aa), X(0x751cda14), | ||
1734 | X(0x7523df96), X(0x752ae231), X(0x7531e1e5), X(0x7538deb2), | ||
1735 | X(0x753fd89a), X(0x7546cf9b), X(0x754dc3b7), X(0x7554b4ed), | ||
1736 | X(0x755ba33e), X(0x75628eaa), X(0x75697732), X(0x75705cd5), | ||
1737 | X(0x75773f95), X(0x757e1f71), X(0x7584fc6a), X(0x758bd67f), | ||
1738 | X(0x7592adb2), X(0x75998203), X(0x75a05371), X(0x75a721fe), | ||
1739 | X(0x75adeda9), X(0x75b4b673), X(0x75bb7c5c), X(0x75c23f65), | ||
1740 | X(0x75c8ff8d), X(0x75cfbcd6), X(0x75d6773f), X(0x75dd2ec8), | ||
1741 | X(0x75e3e373), X(0x75ea953f), X(0x75f1442d), X(0x75f7f03d), | ||
1742 | X(0x75fe996f), X(0x76053fc5), X(0x760be33d), X(0x761283d8), | ||
1743 | X(0x76192197), X(0x761fbc7b), X(0x76265482), X(0x762ce9af), | ||
1744 | X(0x76337c01), X(0x763a0b78), X(0x76409814), X(0x764721d7), | ||
1745 | X(0x764da8c1), X(0x76542cd1), X(0x765aae08), X(0x76612c67), | ||
1746 | X(0x7667a7ee), X(0x766e209d), X(0x76749675), X(0x767b0975), | ||
1747 | X(0x7681799f), X(0x7687e6f3), X(0x768e5170), X(0x7694b918), | ||
1748 | X(0x769b1deb), X(0x76a17fe9), X(0x76a7df13), X(0x76ae3b68), | ||
1749 | X(0x76b494ea), X(0x76baeb98), X(0x76c13f74), X(0x76c7907c), | ||
1750 | X(0x76cddeb3), X(0x76d42a18), X(0x76da72ab), X(0x76e0b86d), | ||
1751 | X(0x76e6fb5e), X(0x76ed3b7f), X(0x76f378d0), X(0x76f9b352), | ||
1752 | X(0x76ffeb05), X(0x77061fe8), X(0x770c51fe), X(0x77128145), | ||
1753 | X(0x7718adbf), X(0x771ed76c), X(0x7724fe4c), X(0x772b225f), | ||
1754 | X(0x773143a7), X(0x77376223), X(0x773d7dd3), X(0x774396ba), | ||
1755 | X(0x7749acd5), X(0x774fc027), X(0x7755d0af), X(0x775bde6f), | ||
1756 | X(0x7761e965), X(0x7767f193), X(0x776df6fa), X(0x7773f998), | ||
1757 | X(0x7779f970), X(0x777ff681), X(0x7785f0cd), X(0x778be852), | ||
1758 | X(0x7791dd12), X(0x7797cf0d), X(0x779dbe43), X(0x77a3aab6), | ||
1759 | X(0x77a99465), X(0x77af7b50), X(0x77b55f79), X(0x77bb40e0), | ||
1760 | X(0x77c11f85), X(0x77c6fb68), X(0x77ccd48a), X(0x77d2aaec), | ||
1761 | X(0x77d87e8d), X(0x77de4f6f), X(0x77e41d92), X(0x77e9e8f5), | ||
1762 | X(0x77efb19b), X(0x77f57782), X(0x77fb3aad), X(0x7800fb1a), | ||
1763 | X(0x7806b8ca), X(0x780c73bf), X(0x78122bf7), X(0x7817e175), | ||
1764 | X(0x781d9438), X(0x78234440), X(0x7828f18f), X(0x782e9c25), | ||
1765 | X(0x78344401), X(0x7839e925), X(0x783f8b92), X(0x78452b46), | ||
1766 | X(0x784ac844), X(0x7850628b), X(0x7855fa1c), X(0x785b8ef8), | ||
1767 | X(0x7861211e), X(0x7866b090), X(0x786c3d4d), X(0x7871c757), | ||
1768 | X(0x78774ead), X(0x787cd351), X(0x78825543), X(0x7887d483), | ||
1769 | X(0x788d5111), X(0x7892caef), X(0x7898421c), X(0x789db69a), | ||
1770 | X(0x78a32868), X(0x78a89787), X(0x78ae03f8), X(0x78b36dbb), | ||
1771 | X(0x78b8d4d1), X(0x78be393a), X(0x78c39af6), X(0x78c8fa06), | ||
1772 | X(0x78ce566c), X(0x78d3b026), X(0x78d90736), X(0x78de5b9c), | ||
1773 | X(0x78e3ad58), X(0x78e8fc6c), X(0x78ee48d7), X(0x78f3929b), | ||
1774 | X(0x78f8d9b7), X(0x78fe1e2c), X(0x79035ffb), X(0x79089f24), | ||
1775 | X(0x790ddba8), X(0x79131587), X(0x79184cc2), X(0x791d8159), | ||
1776 | X(0x7922b34d), X(0x7927e29e), X(0x792d0f4d), X(0x7932395a), | ||
1777 | X(0x793760c6), X(0x793c8591), X(0x7941a7bd), X(0x7946c749), | ||
1778 | X(0x794be435), X(0x7950fe84), X(0x79561634), X(0x795b2b47), | ||
1779 | X(0x79603dbc), X(0x79654d96), X(0x796a5ad4), X(0x796f6576), | ||
1780 | X(0x79746d7e), X(0x797972eb), X(0x797e75bf), X(0x798375f9), | ||
1781 | X(0x7988739b), X(0x798d6ea5), X(0x79926717), X(0x79975cf2), | ||
1782 | X(0x799c5037), X(0x79a140e6), X(0x79a62f00), X(0x79ab1a85), | ||
1783 | X(0x79b00376), X(0x79b4e9d3), X(0x79b9cd9d), X(0x79beaed4), | ||
1784 | X(0x79c38d79), X(0x79c8698d), X(0x79cd4310), X(0x79d21a03), | ||
1785 | X(0x79d6ee66), X(0x79dbc03a), X(0x79e08f7f), X(0x79e55c36), | ||
1786 | X(0x79ea265f), X(0x79eeedfc), X(0x79f3b30c), X(0x79f87590), | ||
1787 | X(0x79fd3589), X(0x7a01f2f7), X(0x7a06addc), X(0x7a0b6636), | ||
1788 | X(0x7a101c08), X(0x7a14cf52), X(0x7a198013), X(0x7a1e2e4d), | ||
1789 | X(0x7a22da01), X(0x7a27832f), X(0x7a2c29d7), X(0x7a30cdfa), | ||
1790 | X(0x7a356f99), X(0x7a3a0eb4), X(0x7a3eab4c), X(0x7a434561), | ||
1791 | X(0x7a47dcf5), X(0x7a4c7207), X(0x7a510498), X(0x7a5594a9), | ||
1792 | X(0x7a5a223a), X(0x7a5ead4d), X(0x7a6335e0), X(0x7a67bbf6), | ||
1793 | X(0x7a6c3f8f), X(0x7a70c0ab), X(0x7a753f4b), X(0x7a79bb6f), | ||
1794 | X(0x7a7e3519), X(0x7a82ac48), X(0x7a8720fe), X(0x7a8b933b), | ||
1795 | X(0x7a9002ff), X(0x7a94704b), X(0x7a98db20), X(0x7a9d437e), | ||
1796 | X(0x7aa1a967), X(0x7aa60cd9), X(0x7aaa6dd7), X(0x7aaecc61), | ||
1797 | X(0x7ab32877), X(0x7ab7821b), X(0x7abbd94b), X(0x7ac02e0a), | ||
1798 | X(0x7ac48058), X(0x7ac8d035), X(0x7acd1da3), X(0x7ad168a1), | ||
1799 | X(0x7ad5b130), X(0x7ad9f751), X(0x7ade3b05), X(0x7ae27c4c), | ||
1800 | X(0x7ae6bb27), X(0x7aeaf796), X(0x7aef319a), X(0x7af36934), | ||
1801 | X(0x7af79e64), X(0x7afbd12c), X(0x7b00018a), X(0x7b042f81), | ||
1802 | X(0x7b085b10), X(0x7b0c8439), X(0x7b10aafc), X(0x7b14cf5a), | ||
1803 | X(0x7b18f153), X(0x7b1d10e8), X(0x7b212e1a), X(0x7b2548e9), | ||
1804 | X(0x7b296155), X(0x7b2d7761), X(0x7b318b0b), X(0x7b359c55), | ||
1805 | X(0x7b39ab3f), X(0x7b3db7cb), X(0x7b41c1f8), X(0x7b45c9c8), | ||
1806 | X(0x7b49cf3b), X(0x7b4dd251), X(0x7b51d30b), X(0x7b55d16b), | ||
1807 | X(0x7b59cd70), X(0x7b5dc71b), X(0x7b61be6d), X(0x7b65b366), | ||
1808 | X(0x7b69a608), X(0x7b6d9653), X(0x7b718447), X(0x7b756fe5), | ||
1809 | X(0x7b79592e), X(0x7b7d4022), X(0x7b8124c3), X(0x7b850710), | ||
1810 | X(0x7b88e70a), X(0x7b8cc4b3), X(0x7b90a00a), X(0x7b947911), | ||
1811 | X(0x7b984fc8), X(0x7b9c242f), X(0x7b9ff648), X(0x7ba3c612), | ||
1812 | X(0x7ba79390), X(0x7bab5ec1), X(0x7baf27a5), X(0x7bb2ee3f), | ||
1813 | X(0x7bb6b28e), X(0x7bba7493), X(0x7bbe344e), X(0x7bc1f1c1), | ||
1814 | X(0x7bc5acec), X(0x7bc965cf), X(0x7bcd1c6c), X(0x7bd0d0c3), | ||
1815 | X(0x7bd482d4), X(0x7bd832a1), X(0x7bdbe02a), X(0x7bdf8b70), | ||
1816 | X(0x7be33473), X(0x7be6db34), X(0x7bea7fb4), X(0x7bee21f4), | ||
1817 | X(0x7bf1c1f3), X(0x7bf55fb3), X(0x7bf8fb35), X(0x7bfc9479), | ||
1818 | X(0x7c002b7f), X(0x7c03c04a), X(0x7c0752d8), X(0x7c0ae32b), | ||
1819 | X(0x7c0e7144), X(0x7c11fd23), X(0x7c1586c9), X(0x7c190e36), | ||
1820 | X(0x7c1c936c), X(0x7c20166b), X(0x7c239733), X(0x7c2715c6), | ||
1821 | X(0x7c2a9224), X(0x7c2e0c4e), X(0x7c318444), X(0x7c34fa07), | ||
1822 | X(0x7c386d98), X(0x7c3bdef8), X(0x7c3f4e26), X(0x7c42bb25), | ||
1823 | X(0x7c4625f4), X(0x7c498e95), X(0x7c4cf507), X(0x7c50594c), | ||
1824 | X(0x7c53bb65), X(0x7c571b51), X(0x7c5a7913), X(0x7c5dd4aa), | ||
1825 | X(0x7c612e17), X(0x7c64855b), X(0x7c67da76), X(0x7c6b2d6a), | ||
1826 | X(0x7c6e7e37), X(0x7c71ccdd), X(0x7c75195e), X(0x7c7863ba), | ||
1827 | X(0x7c7babf1), X(0x7c7ef206), X(0x7c8235f7), X(0x7c8577c6), | ||
1828 | X(0x7c88b774), X(0x7c8bf502), X(0x7c8f306f), X(0x7c9269bd), | ||
1829 | X(0x7c95a0ec), X(0x7c98d5fe), X(0x7c9c08f2), X(0x7c9f39cb), | ||
1830 | X(0x7ca26887), X(0x7ca59528), X(0x7ca8bfb0), X(0x7cabe81d), | ||
1831 | X(0x7caf0e72), X(0x7cb232af), X(0x7cb554d4), X(0x7cb874e2), | ||
1832 | X(0x7cbb92db), X(0x7cbeaebe), X(0x7cc1c88d), X(0x7cc4e047), | ||
1833 | X(0x7cc7f5ef), X(0x7ccb0984), X(0x7cce1b08), X(0x7cd12a7b), | ||
1834 | X(0x7cd437dd), X(0x7cd74330), X(0x7cda4c74), X(0x7cdd53aa), | ||
1835 | X(0x7ce058d3), X(0x7ce35bef), X(0x7ce65cff), X(0x7ce95c04), | ||
1836 | X(0x7cec58ff), X(0x7cef53f0), X(0x7cf24cd7), X(0x7cf543b7), | ||
1837 | X(0x7cf8388f), X(0x7cfb2b60), X(0x7cfe1c2b), X(0x7d010af1), | ||
1838 | X(0x7d03f7b2), X(0x7d06e26f), X(0x7d09cb29), X(0x7d0cb1e0), | ||
1839 | X(0x7d0f9696), X(0x7d12794b), X(0x7d1559ff), X(0x7d1838b4), | ||
1840 | X(0x7d1b156a), X(0x7d1df022), X(0x7d20c8dd), X(0x7d239f9b), | ||
1841 | X(0x7d26745e), X(0x7d294725), X(0x7d2c17f1), X(0x7d2ee6c4), | ||
1842 | X(0x7d31b39f), X(0x7d347e81), X(0x7d37476b), X(0x7d3a0e5f), | ||
1843 | X(0x7d3cd35d), X(0x7d3f9665), X(0x7d425779), X(0x7d451699), | ||
1844 | X(0x7d47d3c6), X(0x7d4a8f01), X(0x7d4d484b), X(0x7d4fffa3), | ||
1845 | X(0x7d52b50c), X(0x7d556885), X(0x7d581a0f), X(0x7d5ac9ac), | ||
1846 | X(0x7d5d775c), X(0x7d60231f), X(0x7d62ccf6), X(0x7d6574e3), | ||
1847 | X(0x7d681ae6), X(0x7d6abeff), X(0x7d6d612f), X(0x7d700178), | ||
1848 | X(0x7d729fd9), X(0x7d753c54), X(0x7d77d6e9), X(0x7d7a6f9a), | ||
1849 | X(0x7d7d0666), X(0x7d7f9b4f), X(0x7d822e55), X(0x7d84bf79), | ||
1850 | X(0x7d874ebc), X(0x7d89dc1e), X(0x7d8c67a1), X(0x7d8ef144), | ||
1851 | X(0x7d91790a), X(0x7d93fef2), X(0x7d9682fd), X(0x7d99052d), | ||
1852 | X(0x7d9b8581), X(0x7d9e03fb), X(0x7da0809b), X(0x7da2fb62), | ||
1853 | X(0x7da57451), X(0x7da7eb68), X(0x7daa60a8), X(0x7dacd413), | ||
1854 | X(0x7daf45a9), X(0x7db1b56a), X(0x7db42357), X(0x7db68f71), | ||
1855 | X(0x7db8f9b9), X(0x7dbb6230), X(0x7dbdc8d6), X(0x7dc02dac), | ||
1856 | X(0x7dc290b3), X(0x7dc4f1eb), X(0x7dc75156), X(0x7dc9aef4), | ||
1857 | X(0x7dcc0ac5), X(0x7dce64cc), X(0x7dd0bd07), X(0x7dd31379), | ||
1858 | X(0x7dd56821), X(0x7dd7bb01), X(0x7dda0c1a), X(0x7ddc5b6b), | ||
1859 | X(0x7ddea8f7), X(0x7de0f4bd), X(0x7de33ebe), X(0x7de586fc), | ||
1860 | X(0x7de7cd76), X(0x7dea122e), X(0x7dec5525), X(0x7dee965a), | ||
1861 | X(0x7df0d5d0), X(0x7df31386), X(0x7df54f7e), X(0x7df789b8), | ||
1862 | X(0x7df9c235), X(0x7dfbf8f5), X(0x7dfe2dfa), X(0x7e006145), | ||
1863 | X(0x7e0292d5), X(0x7e04c2ac), X(0x7e06f0cb), X(0x7e091d32), | ||
1864 | X(0x7e0b47e1), X(0x7e0d70db), X(0x7e0f981f), X(0x7e11bdaf), | ||
1865 | X(0x7e13e18a), X(0x7e1603b3), X(0x7e182429), X(0x7e1a42ed), | ||
1866 | X(0x7e1c6001), X(0x7e1e7b64), X(0x7e209518), X(0x7e22ad1d), | ||
1867 | X(0x7e24c375), X(0x7e26d81f), X(0x7e28eb1d), X(0x7e2afc70), | ||
1868 | X(0x7e2d0c17), X(0x7e2f1a15), X(0x7e31266a), X(0x7e333115), | ||
1869 | X(0x7e353a1a), X(0x7e374177), X(0x7e39472e), X(0x7e3b4b3f), | ||
1870 | X(0x7e3d4dac), X(0x7e3f4e75), X(0x7e414d9a), X(0x7e434b1e), | ||
1871 | X(0x7e4546ff), X(0x7e474140), X(0x7e4939e0), X(0x7e4b30e2), | ||
1872 | X(0x7e4d2644), X(0x7e4f1a09), X(0x7e510c30), X(0x7e52fcbc), | ||
1873 | X(0x7e54ebab), X(0x7e56d900), X(0x7e58c4bb), X(0x7e5aaedd), | ||
1874 | X(0x7e5c9766), X(0x7e5e7e57), X(0x7e6063b2), X(0x7e624776), | ||
1875 | X(0x7e6429a5), X(0x7e660a3f), X(0x7e67e945), X(0x7e69c6b8), | ||
1876 | X(0x7e6ba299), X(0x7e6d7ce7), X(0x7e6f55a5), X(0x7e712cd3), | ||
1877 | X(0x7e730272), X(0x7e74d682), X(0x7e76a904), X(0x7e7879f9), | ||
1878 | X(0x7e7a4962), X(0x7e7c173f), X(0x7e7de392), X(0x7e7fae5a), | ||
1879 | X(0x7e817799), X(0x7e833f50), X(0x7e85057f), X(0x7e86ca27), | ||
1880 | X(0x7e888d49), X(0x7e8a4ee5), X(0x7e8c0efd), X(0x7e8dcd91), | ||
1881 | X(0x7e8f8aa1), X(0x7e914630), X(0x7e93003c), X(0x7e94b8c8), | ||
1882 | X(0x7e966fd4), X(0x7e982560), X(0x7e99d96e), X(0x7e9b8bfe), | ||
1883 | X(0x7e9d3d10), X(0x7e9eeca7), X(0x7ea09ac2), X(0x7ea24762), | ||
1884 | X(0x7ea3f288), X(0x7ea59c35), X(0x7ea7446a), X(0x7ea8eb27), | ||
1885 | X(0x7eaa906c), X(0x7eac343c), X(0x7eadd696), X(0x7eaf777b), | ||
1886 | X(0x7eb116ed), X(0x7eb2b4eb), X(0x7eb45177), X(0x7eb5ec91), | ||
1887 | X(0x7eb7863b), X(0x7eb91e74), X(0x7ebab53e), X(0x7ebc4a99), | ||
1888 | X(0x7ebdde87), X(0x7ebf7107), X(0x7ec1021b), X(0x7ec291c3), | ||
1889 | X(0x7ec42001), X(0x7ec5acd5), X(0x7ec7383f), X(0x7ec8c241), | ||
1890 | X(0x7eca4adb), X(0x7ecbd20d), X(0x7ecd57da), X(0x7ecedc41), | ||
1891 | X(0x7ed05f44), X(0x7ed1e0e2), X(0x7ed3611d), X(0x7ed4dff6), | ||
1892 | X(0x7ed65d6d), X(0x7ed7d983), X(0x7ed95438), X(0x7edacd8f), | ||
1893 | X(0x7edc4586), X(0x7eddbc20), X(0x7edf315c), X(0x7ee0a53c), | ||
1894 | X(0x7ee217c1), X(0x7ee388ea), X(0x7ee4f8b9), X(0x7ee6672f), | ||
1895 | X(0x7ee7d44c), X(0x7ee94012), X(0x7eeaaa80), X(0x7eec1397), | ||
1896 | X(0x7eed7b59), X(0x7eeee1c6), X(0x7ef046df), X(0x7ef1aaa5), | ||
1897 | X(0x7ef30d18), X(0x7ef46e39), X(0x7ef5ce09), X(0x7ef72c88), | ||
1898 | X(0x7ef889b8), X(0x7ef9e599), X(0x7efb402c), X(0x7efc9972), | ||
1899 | X(0x7efdf16b), X(0x7eff4818), X(0x7f009d79), X(0x7f01f191), | ||
1900 | X(0x7f03445f), X(0x7f0495e4), X(0x7f05e620), X(0x7f073516), | ||
1901 | X(0x7f0882c5), X(0x7f09cf2d), X(0x7f0b1a51), X(0x7f0c6430), | ||
1902 | X(0x7f0daccc), X(0x7f0ef425), X(0x7f103a3b), X(0x7f117f11), | ||
1903 | X(0x7f12c2a5), X(0x7f1404fa), X(0x7f15460f), X(0x7f1685e6), | ||
1904 | X(0x7f17c47f), X(0x7f1901db), X(0x7f1a3dfb), X(0x7f1b78e0), | ||
1905 | X(0x7f1cb28a), X(0x7f1deafa), X(0x7f1f2231), X(0x7f20582f), | ||
1906 | X(0x7f218cf5), X(0x7f22c085), X(0x7f23f2de), X(0x7f252401), | ||
1907 | X(0x7f2653f0), X(0x7f2782ab), X(0x7f28b032), X(0x7f29dc87), | ||
1908 | X(0x7f2b07aa), X(0x7f2c319c), X(0x7f2d5a5e), X(0x7f2e81f0), | ||
1909 | X(0x7f2fa853), X(0x7f30cd88), X(0x7f31f18f), X(0x7f33146a), | ||
1910 | X(0x7f343619), X(0x7f35569c), X(0x7f3675f6), X(0x7f379425), | ||
1911 | X(0x7f38b12c), X(0x7f39cd0a), X(0x7f3ae7c0), X(0x7f3c0150), | ||
1912 | X(0x7f3d19ba), X(0x7f3e30fe), X(0x7f3f471e), X(0x7f405c1a), | ||
1913 | X(0x7f416ff3), X(0x7f4282a9), X(0x7f43943e), X(0x7f44a4b2), | ||
1914 | X(0x7f45b405), X(0x7f46c239), X(0x7f47cf4e), X(0x7f48db45), | ||
1915 | X(0x7f49e61f), X(0x7f4aefdc), X(0x7f4bf87e), X(0x7f4d0004), | ||
1916 | X(0x7f4e0670), X(0x7f4f0bc2), X(0x7f500ffb), X(0x7f51131c), | ||
1917 | X(0x7f521525), X(0x7f531618), X(0x7f5415f4), X(0x7f5514bb), | ||
1918 | X(0x7f56126e), X(0x7f570f0c), X(0x7f580a98), X(0x7f590511), | ||
1919 | X(0x7f59fe78), X(0x7f5af6ce), X(0x7f5bee14), X(0x7f5ce44a), | ||
1920 | X(0x7f5dd972), X(0x7f5ecd8b), X(0x7f5fc097), X(0x7f60b296), | ||
1921 | X(0x7f61a389), X(0x7f629370), X(0x7f63824e), X(0x7f647021), | ||
1922 | X(0x7f655ceb), X(0x7f6648ad), X(0x7f673367), X(0x7f681d19), | ||
1923 | X(0x7f6905c6), X(0x7f69ed6d), X(0x7f6ad40f), X(0x7f6bb9ad), | ||
1924 | X(0x7f6c9e48), X(0x7f6d81e0), X(0x7f6e6475), X(0x7f6f460a), | ||
1925 | X(0x7f70269d), X(0x7f710631), X(0x7f71e4c6), X(0x7f72c25c), | ||
1926 | X(0x7f739ef4), X(0x7f747a8f), X(0x7f75552e), X(0x7f762ed1), | ||
1927 | X(0x7f770779), X(0x7f77df27), X(0x7f78b5db), X(0x7f798b97), | ||
1928 | X(0x7f7a605a), X(0x7f7b3425), X(0x7f7c06fa), X(0x7f7cd8d9), | ||
1929 | X(0x7f7da9c2), X(0x7f7e79b7), X(0x7f7f48b8), X(0x7f8016c5), | ||
1930 | X(0x7f80e3e0), X(0x7f81b009), X(0x7f827b40), X(0x7f834588), | ||
1931 | X(0x7f840edf), X(0x7f84d747), X(0x7f859ec1), X(0x7f86654d), | ||
1932 | X(0x7f872aec), X(0x7f87ef9e), X(0x7f88b365), X(0x7f897641), | ||
1933 | X(0x7f8a3832), X(0x7f8af93a), X(0x7f8bb959), X(0x7f8c7890), | ||
1934 | X(0x7f8d36df), X(0x7f8df448), X(0x7f8eb0ca), X(0x7f8f6c67), | ||
1935 | X(0x7f90271e), X(0x7f90e0f2), X(0x7f9199e2), X(0x7f9251f0), | ||
1936 | X(0x7f93091b), X(0x7f93bf65), X(0x7f9474ce), X(0x7f952958), | ||
1937 | X(0x7f95dd01), X(0x7f968fcd), X(0x7f9741ba), X(0x7f97f2ca), | ||
1938 | X(0x7f98a2fd), X(0x7f995254), X(0x7f9a00d0), X(0x7f9aae71), | ||
1939 | X(0x7f9b5b38), X(0x7f9c0726), X(0x7f9cb23b), X(0x7f9d5c78), | ||
1940 | X(0x7f9e05de), X(0x7f9eae6e), X(0x7f9f5627), X(0x7f9ffd0b), | ||
1941 | X(0x7fa0a31b), X(0x7fa14856), X(0x7fa1ecbf), X(0x7fa29054), | ||
1942 | X(0x7fa33318), X(0x7fa3d50b), X(0x7fa4762c), X(0x7fa5167e), | ||
1943 | X(0x7fa5b601), X(0x7fa654b5), X(0x7fa6f29b), X(0x7fa78fb3), | ||
1944 | X(0x7fa82bff), X(0x7fa8c77f), X(0x7fa96234), X(0x7fa9fc1e), | ||
1945 | X(0x7faa953e), X(0x7fab2d94), X(0x7fabc522), X(0x7fac5be8), | ||
1946 | X(0x7facf1e6), X(0x7fad871d), X(0x7fae1b8f), X(0x7faeaf3b), | ||
1947 | X(0x7faf4222), X(0x7fafd445), X(0x7fb065a4), X(0x7fb0f641), | ||
1948 | X(0x7fb1861b), X(0x7fb21534), X(0x7fb2a38c), X(0x7fb33124), | ||
1949 | X(0x7fb3bdfb), X(0x7fb44a14), X(0x7fb4d56f), X(0x7fb5600c), | ||
1950 | X(0x7fb5e9ec), X(0x7fb6730f), X(0x7fb6fb76), X(0x7fb78323), | ||
1951 | X(0x7fb80a15), X(0x7fb8904d), X(0x7fb915cc), X(0x7fb99a92), | ||
1952 | X(0x7fba1ea0), X(0x7fbaa1f7), X(0x7fbb2497), X(0x7fbba681), | ||
1953 | X(0x7fbc27b5), X(0x7fbca835), X(0x7fbd2801), X(0x7fbda719), | ||
1954 | X(0x7fbe257e), X(0x7fbea331), X(0x7fbf2032), X(0x7fbf9c82), | ||
1955 | X(0x7fc01821), X(0x7fc09311), X(0x7fc10d52), X(0x7fc186e4), | ||
1956 | X(0x7fc1ffc8), X(0x7fc277ff), X(0x7fc2ef89), X(0x7fc36667), | ||
1957 | X(0x7fc3dc9a), X(0x7fc45221), X(0x7fc4c6ff), X(0x7fc53b33), | ||
1958 | X(0x7fc5aebe), X(0x7fc621a0), X(0x7fc693db), X(0x7fc7056f), | ||
1959 | X(0x7fc7765c), X(0x7fc7e6a3), X(0x7fc85645), X(0x7fc8c542), | ||
1960 | X(0x7fc9339b), X(0x7fc9a150), X(0x7fca0e63), X(0x7fca7ad3), | ||
1961 | X(0x7fcae6a2), X(0x7fcb51cf), X(0x7fcbbc5c), X(0x7fcc2649), | ||
1962 | X(0x7fcc8f97), X(0x7fccf846), X(0x7fcd6058), X(0x7fcdc7cb), | ||
1963 | X(0x7fce2ea2), X(0x7fce94dd), X(0x7fcefa7b), X(0x7fcf5f7f), | ||
1964 | X(0x7fcfc3e8), X(0x7fd027b7), X(0x7fd08aed), X(0x7fd0ed8b), | ||
1965 | X(0x7fd14f90), X(0x7fd1b0fd), X(0x7fd211d4), X(0x7fd27214), | ||
1966 | X(0x7fd2d1bf), X(0x7fd330d4), X(0x7fd38f55), X(0x7fd3ed41), | ||
1967 | X(0x7fd44a9a), X(0x7fd4a761), X(0x7fd50395), X(0x7fd55f37), | ||
1968 | X(0x7fd5ba48), X(0x7fd614c9), X(0x7fd66eba), X(0x7fd6c81b), | ||
1969 | X(0x7fd720ed), X(0x7fd77932), X(0x7fd7d0e8), X(0x7fd82812), | ||
1970 | X(0x7fd87eae), X(0x7fd8d4bf), X(0x7fd92a45), X(0x7fd97f40), | ||
1971 | X(0x7fd9d3b0), X(0x7fda2797), X(0x7fda7af5), X(0x7fdacdca), | ||
1972 | X(0x7fdb2018), X(0x7fdb71dd), X(0x7fdbc31c), X(0x7fdc13d5), | ||
1973 | X(0x7fdc6408), X(0x7fdcb3b6), X(0x7fdd02df), X(0x7fdd5184), | ||
1974 | X(0x7fdd9fa5), X(0x7fdded44), X(0x7fde3a60), X(0x7fde86fb), | ||
1975 | X(0x7fded314), X(0x7fdf1eac), X(0x7fdf69c4), X(0x7fdfb45d), | ||
1976 | X(0x7fdffe76), X(0x7fe04811), X(0x7fe0912e), X(0x7fe0d9ce), | ||
1977 | X(0x7fe121f0), X(0x7fe16996), X(0x7fe1b0c1), X(0x7fe1f770), | ||
1978 | X(0x7fe23da4), X(0x7fe2835f), X(0x7fe2c89f), X(0x7fe30d67), | ||
1979 | X(0x7fe351b5), X(0x7fe3958c), X(0x7fe3d8ec), X(0x7fe41bd4), | ||
1980 | X(0x7fe45e46), X(0x7fe4a042), X(0x7fe4e1c8), X(0x7fe522da), | ||
1981 | X(0x7fe56378), X(0x7fe5a3a1), X(0x7fe5e358), X(0x7fe6229b), | ||
1982 | X(0x7fe6616d), X(0x7fe69fcc), X(0x7fe6ddbb), X(0x7fe71b39), | ||
1983 | X(0x7fe75847), X(0x7fe794e5), X(0x7fe7d114), X(0x7fe80cd5), | ||
1984 | X(0x7fe84827), X(0x7fe8830c), X(0x7fe8bd84), X(0x7fe8f78f), | ||
1985 | X(0x7fe9312f), X(0x7fe96a62), X(0x7fe9a32b), X(0x7fe9db8a), | ||
1986 | X(0x7fea137e), X(0x7fea4b09), X(0x7fea822b), X(0x7feab8e5), | ||
1987 | X(0x7feaef37), X(0x7feb2521), X(0x7feb5aa4), X(0x7feb8fc1), | ||
1988 | X(0x7febc478), X(0x7febf8ca), X(0x7fec2cb6), X(0x7fec603e), | ||
1989 | X(0x7fec9363), X(0x7fecc623), X(0x7fecf881), X(0x7fed2a7c), | ||
1990 | X(0x7fed5c16), X(0x7fed8d4e), X(0x7fedbe24), X(0x7fedee9b), | ||
1991 | X(0x7fee1eb1), X(0x7fee4e68), X(0x7fee7dc0), X(0x7feeacb9), | ||
1992 | X(0x7feedb54), X(0x7fef0991), X(0x7fef3771), X(0x7fef64f5), | ||
1993 | X(0x7fef921d), X(0x7fefbee8), X(0x7fefeb59), X(0x7ff0176f), | ||
1994 | X(0x7ff0432a), X(0x7ff06e8c), X(0x7ff09995), X(0x7ff0c444), | ||
1995 | X(0x7ff0ee9c), X(0x7ff1189b), X(0x7ff14243), X(0x7ff16b94), | ||
1996 | X(0x7ff1948e), X(0x7ff1bd32), X(0x7ff1e581), X(0x7ff20d7b), | ||
1997 | X(0x7ff2351f), X(0x7ff25c70), X(0x7ff2836d), X(0x7ff2aa17), | ||
1998 | X(0x7ff2d06d), X(0x7ff2f672), X(0x7ff31c24), X(0x7ff34185), | ||
1999 | X(0x7ff36695), X(0x7ff38b55), X(0x7ff3afc4), X(0x7ff3d3e4), | ||
2000 | X(0x7ff3f7b4), X(0x7ff41b35), X(0x7ff43e69), X(0x7ff4614e), | ||
2001 | X(0x7ff483e6), X(0x7ff4a631), X(0x7ff4c82f), X(0x7ff4e9e1), | ||
2002 | X(0x7ff50b47), X(0x7ff52c62), X(0x7ff54d33), X(0x7ff56db9), | ||
2003 | X(0x7ff58df5), X(0x7ff5ade7), X(0x7ff5cd90), X(0x7ff5ecf1), | ||
2004 | X(0x7ff60c09), X(0x7ff62ada), X(0x7ff64963), X(0x7ff667a5), | ||
2005 | X(0x7ff685a1), X(0x7ff6a357), X(0x7ff6c0c7), X(0x7ff6ddf1), | ||
2006 | X(0x7ff6fad7), X(0x7ff71778), X(0x7ff733d6), X(0x7ff74fef), | ||
2007 | X(0x7ff76bc6), X(0x7ff78759), X(0x7ff7a2ab), X(0x7ff7bdba), | ||
2008 | X(0x7ff7d888), X(0x7ff7f315), X(0x7ff80d61), X(0x7ff8276c), | ||
2009 | X(0x7ff84138), X(0x7ff85ac4), X(0x7ff87412), X(0x7ff88d20), | ||
2010 | X(0x7ff8a5f0), X(0x7ff8be82), X(0x7ff8d6d7), X(0x7ff8eeef), | ||
2011 | X(0x7ff906c9), X(0x7ff91e68), X(0x7ff935cb), X(0x7ff94cf2), | ||
2012 | X(0x7ff963dd), X(0x7ff97a8f), X(0x7ff99105), X(0x7ff9a742), | ||
2013 | X(0x7ff9bd45), X(0x7ff9d30f), X(0x7ff9e8a0), X(0x7ff9fdf9), | ||
2014 | X(0x7ffa131a), X(0x7ffa2803), X(0x7ffa3cb4), X(0x7ffa512f), | ||
2015 | X(0x7ffa6573), X(0x7ffa7981), X(0x7ffa8d59), X(0x7ffaa0fc), | ||
2016 | X(0x7ffab46a), X(0x7ffac7a3), X(0x7ffadaa8), X(0x7ffaed78), | ||
2017 | X(0x7ffb0015), X(0x7ffb127f), X(0x7ffb24b6), X(0x7ffb36bb), | ||
2018 | X(0x7ffb488d), X(0x7ffb5a2e), X(0x7ffb6b9d), X(0x7ffb7cdb), | ||
2019 | X(0x7ffb8de9), X(0x7ffb9ec6), X(0x7ffbaf73), X(0x7ffbbff1), | ||
2020 | X(0x7ffbd03f), X(0x7ffbe05e), X(0x7ffbf04f), X(0x7ffc0012), | ||
2021 | X(0x7ffc0fa6), X(0x7ffc1f0d), X(0x7ffc2e47), X(0x7ffc3d54), | ||
2022 | X(0x7ffc4c35), X(0x7ffc5ae9), X(0x7ffc6971), X(0x7ffc77ce), | ||
2023 | X(0x7ffc8600), X(0x7ffc9407), X(0x7ffca1e4), X(0x7ffcaf96), | ||
2024 | X(0x7ffcbd1f), X(0x7ffcca7e), X(0x7ffcd7b4), X(0x7ffce4c1), | ||
2025 | X(0x7ffcf1a5), X(0x7ffcfe62), X(0x7ffd0af6), X(0x7ffd1763), | ||
2026 | X(0x7ffd23a9), X(0x7ffd2fc8), X(0x7ffd3bc1), X(0x7ffd4793), | ||
2027 | X(0x7ffd533f), X(0x7ffd5ec5), X(0x7ffd6a27), X(0x7ffd7563), | ||
2028 | X(0x7ffd807a), X(0x7ffd8b6e), X(0x7ffd963d), X(0x7ffda0e8), | ||
2029 | X(0x7ffdab70), X(0x7ffdb5d5), X(0x7ffdc017), X(0x7ffdca36), | ||
2030 | X(0x7ffdd434), X(0x7ffdde0f), X(0x7ffde7c9), X(0x7ffdf161), | ||
2031 | X(0x7ffdfad8), X(0x7ffe042f), X(0x7ffe0d65), X(0x7ffe167b), | ||
2032 | X(0x7ffe1f71), X(0x7ffe2848), X(0x7ffe30ff), X(0x7ffe3997), | ||
2033 | X(0x7ffe4211), X(0x7ffe4a6c), X(0x7ffe52a9), X(0x7ffe5ac8), | ||
2034 | X(0x7ffe62c9), X(0x7ffe6aae), X(0x7ffe7275), X(0x7ffe7a1f), | ||
2035 | X(0x7ffe81ad), X(0x7ffe891f), X(0x7ffe9075), X(0x7ffe97b0), | ||
2036 | X(0x7ffe9ece), X(0x7ffea5d2), X(0x7ffeacbb), X(0x7ffeb38a), | ||
2037 | X(0x7ffeba3e), X(0x7ffec0d8), X(0x7ffec758), X(0x7ffecdbf), | ||
2038 | X(0x7ffed40d), X(0x7ffeda41), X(0x7ffee05d), X(0x7ffee660), | ||
2039 | X(0x7ffeec4b), X(0x7ffef21f), X(0x7ffef7da), X(0x7ffefd7e), | ||
2040 | X(0x7fff030b), X(0x7fff0881), X(0x7fff0de0), X(0x7fff1328), | ||
2041 | X(0x7fff185b), X(0x7fff1d77), X(0x7fff227e), X(0x7fff276f), | ||
2042 | X(0x7fff2c4b), X(0x7fff3112), X(0x7fff35c4), X(0x7fff3a62), | ||
2043 | X(0x7fff3eeb), X(0x7fff4360), X(0x7fff47c2), X(0x7fff4c0f), | ||
2044 | X(0x7fff504a), X(0x7fff5471), X(0x7fff5885), X(0x7fff5c87), | ||
2045 | X(0x7fff6076), X(0x7fff6452), X(0x7fff681d), X(0x7fff6bd6), | ||
2046 | X(0x7fff6f7d), X(0x7fff7313), X(0x7fff7698), X(0x7fff7a0c), | ||
2047 | X(0x7fff7d6f), X(0x7fff80c2), X(0x7fff8404), X(0x7fff8736), | ||
2048 | X(0x7fff8a58), X(0x7fff8d6b), X(0x7fff906e), X(0x7fff9362), | ||
2049 | X(0x7fff9646), X(0x7fff991c), X(0x7fff9be3), X(0x7fff9e9c), | ||
2050 | X(0x7fffa146), X(0x7fffa3e2), X(0x7fffa671), X(0x7fffa8f1), | ||
2051 | X(0x7fffab65), X(0x7fffadca), X(0x7fffb023), X(0x7fffb26f), | ||
2052 | X(0x7fffb4ae), X(0x7fffb6e0), X(0x7fffb906), X(0x7fffbb20), | ||
2053 | X(0x7fffbd2e), X(0x7fffbf30), X(0x7fffc126), X(0x7fffc311), | ||
2054 | X(0x7fffc4f1), X(0x7fffc6c5), X(0x7fffc88f), X(0x7fffca4d), | ||
2055 | X(0x7fffcc01), X(0x7fffcdab), X(0x7fffcf4a), X(0x7fffd0e0), | ||
2056 | X(0x7fffd26b), X(0x7fffd3ec), X(0x7fffd564), X(0x7fffd6d2), | ||
2057 | X(0x7fffd838), X(0x7fffd993), X(0x7fffdae6), X(0x7fffdc31), | ||
2058 | X(0x7fffdd72), X(0x7fffdeab), X(0x7fffdfdb), X(0x7fffe104), | ||
2059 | X(0x7fffe224), X(0x7fffe33c), X(0x7fffe44d), X(0x7fffe556), | ||
2060 | X(0x7fffe657), X(0x7fffe751), X(0x7fffe844), X(0x7fffe930), | ||
2061 | X(0x7fffea15), X(0x7fffeaf3), X(0x7fffebca), X(0x7fffec9b), | ||
2062 | X(0x7fffed66), X(0x7fffee2a), X(0x7fffeee8), X(0x7fffefa0), | ||
2063 | X(0x7ffff053), X(0x7ffff0ff), X(0x7ffff1a6), X(0x7ffff247), | ||
2064 | X(0x7ffff2e4), X(0x7ffff37a), X(0x7ffff40c), X(0x7ffff499), | ||
2065 | X(0x7ffff520), X(0x7ffff5a3), X(0x7ffff621), X(0x7ffff69b), | ||
2066 | X(0x7ffff710), X(0x7ffff781), X(0x7ffff7ee), X(0x7ffff857), | ||
2067 | X(0x7ffff8bb), X(0x7ffff91c), X(0x7ffff979), X(0x7ffff9d2), | ||
2068 | X(0x7ffffa27), X(0x7ffffa79), X(0x7ffffac8), X(0x7ffffb13), | ||
2069 | X(0x7ffffb5b), X(0x7ffffba0), X(0x7ffffbe2), X(0x7ffffc21), | ||
2070 | X(0x7ffffc5d), X(0x7ffffc96), X(0x7ffffccd), X(0x7ffffd01), | ||
2071 | X(0x7ffffd32), X(0x7ffffd61), X(0x7ffffd8e), X(0x7ffffdb8), | ||
2072 | X(0x7ffffde0), X(0x7ffffe07), X(0x7ffffe2b), X(0x7ffffe4d), | ||
2073 | X(0x7ffffe6d), X(0x7ffffe8b), X(0x7ffffea8), X(0x7ffffec3), | ||
2074 | X(0x7ffffedc), X(0x7ffffef4), X(0x7fffff0a), X(0x7fffff1f), | ||
2075 | X(0x7fffff33), X(0x7fffff45), X(0x7fffff56), X(0x7fffff66), | ||
2076 | X(0x7fffff75), X(0x7fffff82), X(0x7fffff8f), X(0x7fffff9a), | ||
2077 | X(0x7fffffa5), X(0x7fffffaf), X(0x7fffffb8), X(0x7fffffc0), | ||
2078 | X(0x7fffffc8), X(0x7fffffce), X(0x7fffffd5), X(0x7fffffda), | ||
2079 | X(0x7fffffdf), X(0x7fffffe4), X(0x7fffffe8), X(0x7fffffeb), | ||
2080 | X(0x7fffffef), X(0x7ffffff1), X(0x7ffffff4), X(0x7ffffff6), | ||
2081 | X(0x7ffffff8), X(0x7ffffff9), X(0x7ffffffb), X(0x7ffffffc), | ||
2082 | X(0x7ffffffd), X(0x7ffffffd), X(0x7ffffffe), X(0x7fffffff), | ||
2083 | X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), | ||
2084 | X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), | ||
2085 | X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), | ||
2086 | }; | ||
2087 | |||