Diffstat (limited to 'core/multimedia/opieplayer/libmpeg3/audio') (more/less context) (ignore whitespace changes)
22 files changed, 8950 insertions, 0 deletions
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/Makefile b/core/multimedia/opieplayer/libmpeg3/audio/Makefile new file mode 100644 index 0000000..eaa0e0b --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/Makefile | |||
@@ -0,0 +1,35 @@ | |||
1 | include ../global_config | ||
2 | export CFLAGS | ||
3 | export CFLAGS_lessopt | ||
4 | |||
5 | OBJS = \ | ||
6 | ac3.o \ | ||
7 | bit_allocation.o \ | ||
8 | dct.o \ | ||
9 | exponents.o \ | ||
10 | header.o \ | ||
11 | layer2.o \ | ||
12 | layer3.o \ | ||
13 | mantissa.o \ | ||
14 | mpeg3audio.o \ | ||
15 | pcm.o \ | ||
16 | synthesizers.o \ | ||
17 | tables.o | ||
18 | |||
19 | all: $(OBJS) | ||
20 | |||
21 | dct.o: dct.c | ||
22 | $(CC) -c `./c_flags dct.c` -o $@ $< | ||
23 | |||
24 | synthesizers.o: synthesizers.c | ||
25 | $(CC) -c `./c_flags synthesizers.c` -o $@ $< | ||
26 | |||
27 | |||
28 | .c.o: | ||
29 | $(CC) -c `./c_flags` -o $@ $< | ||
30 | |||
31 | .s.o: | ||
32 | $(CC) -f elf $*.s | ||
33 | |||
34 | clean: | ||
35 | rm -f *.o | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/ac3.c b/core/multimedia/opieplayer/libmpeg3/audio/ac3.c new file mode 100644 index 0000000..7a3b664 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/ac3.c | |||
@@ -0,0 +1,691 @@ | |||
1 | /* | ||
2 | * | ||
3 | *ac3.c Copyright (C) Aaron Holtzman - May 1999 | ||
4 | * | ||
5 | * | ||
6 | * This file is part of libmpeg3 | ||
7 | * | ||
8 | * libmpeg3 is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2, or (at your option) | ||
11 | * any later version. | ||
12 | * | ||
13 | * libmpeg3 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 | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with GNU Make; see the file COPYING. If not, write to | ||
20 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | * | ||
22 | */ | ||
23 | |||
24 | #include "mpeg3audio.h" | ||
25 | #include "../libmpeg3.h" | ||
26 | #include "../mpeg3protos.h" | ||
27 | |||
28 | #include <math.h> | ||
29 | #include <stdlib.h> | ||
30 | #include <stdio.h> | ||
31 | #include <string.h> | ||
32 | |||
33 | #define MPEG3AC3_MAGIC_NUMBER 0xdeadbeef | ||
34 | |||
35 | |||
36 | int mpeg3_ac3_samplerates[] = { 48000, 44100, 32000 }; | ||
37 | |||
38 | struct mpeg3_framesize_s | ||
39 | { | ||
40 | unsigned short bit_rate; | ||
41 | unsigned short frm_size[3]; | ||
42 | }; | ||
43 | |||
44 | struct mpeg3_framesize_s framesize_codes[] = | ||
45 | { | ||
46 | { 32 ,{64 ,69 ,96 } }, | ||
47 | { 32 ,{64 ,70 ,96 } }, | ||
48 | { 40 ,{80 ,87 ,120 } }, | ||
49 | { 40 ,{80 ,88 ,120 } }, | ||
50 | { 48 ,{96 ,104 ,144 } }, | ||
51 | { 48 ,{96 ,105 ,144 } }, | ||
52 | { 56 ,{112 ,121 ,168 } }, | ||
53 | { 56 ,{112 ,122 ,168 } }, | ||
54 | { 64 ,{128 ,139 ,192 } }, | ||
55 | { 64 ,{128 ,140 ,192 } }, | ||
56 | { 80 ,{160 ,174 ,240 } }, | ||
57 | { 80 ,{160 ,175 ,240 } }, | ||
58 | { 96 ,{192 ,208 ,288 } }, | ||
59 | { 96 ,{192 ,209 ,288 } }, | ||
60 | { 112 ,{224 ,243 ,336 } }, | ||
61 | { 112 ,{224 ,244 ,336 } }, | ||
62 | { 128 ,{256 ,278 ,384 } }, | ||
63 | { 128 ,{256 ,279 ,384 } }, | ||
64 | { 160 ,{320 ,348 ,480 } }, | ||
65 | { 160 ,{320 ,349 ,480 } }, | ||
66 | { 192 ,{384 ,417 ,576 } }, | ||
67 | { 192 ,{384 ,418 ,576 } }, | ||
68 | { 224 ,{448 ,487 ,672 } }, | ||
69 | { 224 ,{448 ,488 ,672 } }, | ||
70 | { 256 ,{512 ,557 ,768 } }, | ||
71 | { 256 ,{512 ,558 ,768 } }, | ||
72 | { 320 ,{640 ,696 ,960 } }, | ||
73 | { 320 ,{640 ,697 ,960 } }, | ||
74 | { 384 ,{768 ,835 ,1152 } }, | ||
75 | { 384 ,{768 ,836 ,1152 } }, | ||
76 | { 448 ,{896 ,975 ,1344 } }, | ||
77 | { 448 ,{896 ,976 ,1344 } }, | ||
78 | { 512 ,{1024 ,1114 ,1536 } }, | ||
79 | { 512 ,{1024 ,1115 ,1536 } }, | ||
80 | { 576 ,{1152 ,1253 ,1728 } }, | ||
81 | { 576 ,{1152 ,1254 ,1728 } }, | ||
82 | { 640 ,{1280 ,1393 ,1920 } }, | ||
83 | { 640 ,{1280 ,1394 ,1920 } } | ||
84 | }; | ||
85 | |||
86 | /* Audio channel modes */ | ||
87 | short mpeg3_ac3_acmodes[] = {2, 1, 2, 3, 3, 4, 4, 5}; | ||
88 | |||
89 | /* Rematrix tables */ | ||
90 | struct rematrix_band_s | ||
91 | { | ||
92 | int start; | ||
93 | int end; | ||
94 | }; | ||
95 | |||
96 | struct rematrix_band_s mpeg3_rematrix_band[] = | ||
97 | { | ||
98 | {13, 24}, | ||
99 | {25, 36}, | ||
100 | {37, 60}, | ||
101 | {61, 252} | ||
102 | }; | ||
103 | |||
104 | int mpeg3_min(int x, int y) | ||
105 | { | ||
106 | return (x < y) ? x : y; | ||
107 | } | ||
108 | |||
109 | int mpeg3_max(int x, int y) | ||
110 | { | ||
111 | return (x > y) ? x : y; | ||
112 | } | ||
113 | |||
114 | int mpeg3audio_read_ac3_header(mpeg3audio_t *audio) | ||
115 | { | ||
116 | unsigned int code, crc; | ||
117 | unsigned int i; | ||
118 | mpeg3_ac3bsi_t *bsi = &(audio->ac3_bsi); | ||
119 | |||
120 | /* Get the sync code */ | ||
121 | code = mpeg3bits_getbits(audio->astream, 16); | ||
122 | while(!mpeg3bits_eof(audio->astream) && code != MPEG3_AC3_START_CODE) | ||
123 | { | ||
124 | code <<= 8; | ||
125 | code &= 0xffff; | ||
126 | code |= mpeg3bits_getbits(audio->astream, 8); | ||
127 | } | ||
128 | |||
129 | if(mpeg3bits_eof(audio->astream)) return 1; | ||
130 | |||
131 | /* Get crc1 - we don't actually use this data though */ | ||
132 | /* The crc can be the same as the sync code or come after a sync code repeated twice */ | ||
133 | crc = mpeg3bits_getbits(audio->astream, 16); | ||
134 | |||
135 | /* Got the sync code. Read the entire frame into a buffer if possible. */ | ||
136 | if(audio->avg_framesize > 0) | ||
137 | { | ||
138 | if(mpeg3bits_read_buffer(audio->astream, audio->ac3_buffer, audio->framesize - 4)) | ||
139 | return 1; | ||
140 | mpeg3bits_use_ptr(audio->astream, audio->ac3_buffer); | ||
141 | } | ||
142 | |||
143 | /* Get the sampling rate code */ | ||
144 | audio->sampling_frequency_code = mpeg3bits_getbits(audio->astream, 2); | ||
145 | |||
146 | /* Get the frame size code */ | ||
147 | audio->ac3_framesize_code = mpeg3bits_getbits(audio->astream, 6); | ||
148 | |||
149 | audio->bitrate = framesize_codes[audio->ac3_framesize_code].bit_rate; | ||
150 | audio->avg_framesize = audio->framesize = 2 * framesize_codes[audio->ac3_framesize_code].frm_size[audio->sampling_frequency_code]; | ||
151 | |||
152 | /* Check the AC-3 version number */ | ||
153 | bsi->bsid = mpeg3bits_getbits(audio->astream, 5); | ||
154 | |||
155 | /* Get the audio service provided by the steram */ | ||
156 | bsi->bsmod = mpeg3bits_getbits(audio->astream, 3); | ||
157 | |||
158 | /* Get the audio coding mode (ie how many channels)*/ | ||
159 | bsi->acmod = mpeg3bits_getbits(audio->astream, 3); | ||
160 | |||
161 | /* Predecode the number of full bandwidth channels as we use this | ||
162 | * number a lot */ | ||
163 | bsi->nfchans = mpeg3_ac3_acmodes[bsi->acmod]; | ||
164 | audio->channels = bsi->nfchans; | ||
165 | |||
166 | /* If it is in use, get the centre channel mix level */ | ||
167 | if((bsi->acmod & 0x1) && (bsi->acmod != 0x1)) | ||
168 | bsi->cmixlev = mpeg3bits_getbits(audio->astream, 2); | ||
169 | |||
170 | /* If it is in use, get the surround channel mix level */ | ||
171 | if(bsi->acmod & 0x4) | ||
172 | bsi->surmixlev = mpeg3bits_getbits(audio->astream, 2); | ||
173 | |||
174 | /* Get the dolby surround mode if in 2/0 mode */ | ||
175 | if(bsi->acmod == 0x2) | ||
176 | bsi->dsurmod= mpeg3bits_getbits(audio->astream, 2); | ||
177 | |||
178 | /* Is the low frequency effects channel on? */ | ||
179 | bsi->lfeon = mpeg3bits_getbits(audio->astream, 1); | ||
180 | |||
181 | /* Get the dialogue normalization level */ | ||
182 | bsi->dialnorm = mpeg3bits_getbits(audio->astream, 5); | ||
183 | |||
184 | /* Does compression gain exist? */ | ||
185 | bsi->compre = mpeg3bits_getbits(audio->astream, 1); | ||
186 | if (bsi->compre) | ||
187 | { | ||
188 | /* Get compression gain */ | ||
189 | bsi->compr = mpeg3bits_getbits(audio->astream, 8); | ||
190 | } | ||
191 | |||
192 | /* Does language code exist? */ | ||
193 | bsi->langcode = mpeg3bits_getbits(audio->astream, 1); | ||
194 | if (bsi->langcode) | ||
195 | { | ||
196 | /* Get langauge code */ | ||
197 | bsi->langcod = mpeg3bits_getbits(audio->astream, 8); | ||
198 | } | ||
199 | |||
200 | /* Does audio production info exist? */ | ||
201 | bsi->audprodie = mpeg3bits_getbits(audio->astream, 1); | ||
202 | if (bsi->audprodie) | ||
203 | { | ||
204 | /* Get mix level */ | ||
205 | bsi->mixlevel = mpeg3bits_getbits(audio->astream, 5); | ||
206 | |||
207 | /* Get room type */ | ||
208 | bsi->roomtyp = mpeg3bits_getbits(audio->astream, 2); | ||
209 | } | ||
210 | |||
211 | /* If we're in dual mono mode then get some extra info */ | ||
212 | if (bsi->acmod == 0) | ||
213 | { | ||
214 | /* Get the dialogue normalization level two */ | ||
215 | bsi->dialnorm2 = mpeg3bits_getbits(audio->astream, 5); | ||
216 | |||
217 | /* Does compression gain two exist? */ | ||
218 | bsi->compr2e = mpeg3bits_getbits(audio->astream, 1); | ||
219 | if (bsi->compr2e) | ||
220 | { | ||
221 | /* Get compression gain two */ | ||
222 | bsi->compr2 = mpeg3bits_getbits(audio->astream, 8); | ||
223 | } | ||
224 | |||
225 | /* Does language code two exist? */ | ||
226 | bsi->langcod2e = mpeg3bits_getbits(audio->astream, 1); | ||
227 | if (bsi->langcod2e) | ||
228 | { | ||
229 | /* Get langauge code two */ | ||
230 | bsi->langcod2 = mpeg3bits_getbits(audio->astream, 8); | ||
231 | } | ||
232 | |||
233 | /* Does audio production info two exist? */ | ||
234 | bsi->audprodi2e = mpeg3bits_getbits(audio->astream, 1); | ||
235 | if (bsi->audprodi2e) | ||
236 | { | ||
237 | /* Get mix level two */ | ||
238 | bsi->mixlevel2 = mpeg3bits_getbits(audio->astream, 5); | ||
239 | |||
240 | /* Get room type two */ | ||
241 | bsi->roomtyp2 = mpeg3bits_getbits(audio->astream, 2); | ||
242 | } | ||
243 | } | ||
244 | |||
245 | /* Get the copyright bit */ | ||
246 | bsi->copyrightb = mpeg3bits_getbits(audio->astream, 1); | ||
247 | |||
248 | /* Get the original bit */ | ||
249 | bsi->origbs = mpeg3bits_getbits(audio->astream, 1); | ||
250 | |||
251 | /* Does timecode one exist? */ | ||
252 | bsi->timecod1e = mpeg3bits_getbits(audio->astream, 1); | ||
253 | |||
254 | if(bsi->timecod1e) | ||
255 | bsi->timecod1 = mpeg3bits_getbits(audio->astream, 14); | ||
256 | |||
257 | /* Does timecode two exist? */ | ||
258 | bsi->timecod2e = mpeg3bits_getbits(audio->astream, 1); | ||
259 | |||
260 | if(bsi->timecod2e) | ||
261 | bsi->timecod2 = mpeg3bits_getbits(audio->astream, 14); | ||
262 | |||
263 | /* Does addition info exist? */ | ||
264 | bsi->addbsie = mpeg3bits_getbits(audio->astream, 1); | ||
265 | |||
266 | if(bsi->addbsie) | ||
267 | { | ||
268 | /* Get how much info is there */ | ||
269 | bsi->addbsil = mpeg3bits_getbits(audio->astream, 6); | ||
270 | |||
271 | /* Get the additional info */ | ||
272 | for(i = 0; i < (bsi->addbsil + 1); i++) | ||
273 | bsi->addbsi[i] = mpeg3bits_getbits(audio->astream, 8); | ||
274 | } | ||
275 | |||
276 | if(mpeg3bits_eof(audio->astream)) | ||
277 | { | ||
278 | mpeg3bits_use_demuxer(audio->astream); | ||
279 | return 1; | ||
280 | } | ||
281 | //return mpeg3bits_error(audio->astream); | ||
282 | } | ||
283 | |||
284 | int mpeg3audio_read_ac3_audblk(mpeg3audio_t *audio) | ||
285 | { | ||
286 | int i, j; | ||
287 | mpeg3_ac3bsi_t *bsi = &(audio->ac3_bsi); | ||
288 | mpeg3_ac3audblk_t *audblk = &(audio->ac3_audblk); | ||
289 | |||
290 | for(i = 0; i < bsi->nfchans; i++) | ||
291 | { | ||
292 | /* Is this channel an interleaved 256 + 256 block ? */ | ||
293 | audblk->blksw[i] = mpeg3bits_getbits(audio->astream, 1); | ||
294 | } | ||
295 | |||
296 | for(i = 0; i < bsi->nfchans; i++) | ||
297 | { | ||
298 | /* Should we dither this channel? */ | ||
299 | audblk->dithflag[i] = mpeg3bits_getbits(audio->astream, 1); | ||
300 | } | ||
301 | |||
302 | /* Does dynamic range control exist? */ | ||
303 | audblk->dynrnge = mpeg3bits_getbits(audio->astream, 1); | ||
304 | if(audblk->dynrnge) | ||
305 | { | ||
306 | /* Get dynamic range info */ | ||
307 | audblk->dynrng = mpeg3bits_getbits(audio->astream, 8); | ||
308 | } | ||
309 | |||
310 | /* If we're in dual mono mode then get the second channel DR info */ | ||
311 | if(bsi->acmod == 0) | ||
312 | { | ||
313 | /* Does dynamic range control two exist? */ | ||
314 | audblk->dynrng2e = mpeg3bits_getbits(audio->astream, 1); | ||
315 | if (audblk->dynrng2e) | ||
316 | { | ||
317 | /* Get dynamic range info */ | ||
318 | audblk->dynrng2 = mpeg3bits_getbits(audio->astream, 8); | ||
319 | } | ||
320 | } | ||
321 | |||
322 | /* Does coupling strategy exist? */ | ||
323 | audblk->cplstre = mpeg3bits_getbits(audio->astream, 1); | ||
324 | if(audblk->cplstre) | ||
325 | { | ||
326 | /* Is coupling turned on? */ | ||
327 | audblk->cplinu = mpeg3bits_getbits(audio->astream, 1); | ||
328 | if(audblk->cplinu) | ||
329 | { | ||
330 | for(i = 0; i < bsi->nfchans; i++) | ||
331 | audblk->chincpl[i] = mpeg3bits_getbits(audio->astream, 1); | ||
332 | |||
333 | if(bsi->acmod == 0x2) | ||
334 | audblk->phsflginu = mpeg3bits_getbits(audio->astream, 1); | ||
335 | |||
336 | audblk->cplbegf = mpeg3bits_getbits(audio->astream, 4); | ||
337 | audblk->cplendf = mpeg3bits_getbits(audio->astream, 4); | ||
338 | audblk->ncplsubnd = (audblk->cplendf + 2) - audblk->cplbegf + 1; | ||
339 | |||
340 | /* Calculate the start and end bins of the coupling channel */ | ||
341 | audblk->cplstrtmant = (audblk->cplbegf * 12) + 37 ; | ||
342 | audblk->cplendmant = ((audblk->cplendf + 3) * 12) + 37; | ||
343 | |||
344 | /* The number of combined subbands is ncplsubnd minus each combined band */ | ||
345 | audblk->ncplbnd = audblk->ncplsubnd; | ||
346 | |||
347 | for(i = 1; i < audblk->ncplsubnd; i++) | ||
348 | { | ||
349 | audblk->cplbndstrc[i] = mpeg3bits_getbits(audio->astream, 1); | ||
350 | audblk->ncplbnd -= audblk->cplbndstrc[i]; | ||
351 | } | ||
352 | } | ||
353 | } | ||
354 | |||
355 | if(audblk->cplinu) | ||
356 | { | ||
357 | /* Loop through all the channels and get their coupling co-ords */ | ||
358 | for(i = 0; i < bsi->nfchans; i++) | ||
359 | { | ||
360 | if(!audblk->chincpl[i]) | ||
361 | continue; | ||
362 | |||
363 | /* Is there new coupling co-ordinate info? */ | ||
364 | audblk->cplcoe[i] = mpeg3bits_getbits(audio->astream, 1); | ||
365 | |||
366 | if(audblk->cplcoe[i]) | ||
367 | { | ||
368 | audblk->mstrcplco[i] = mpeg3bits_getbits(audio->astream, 2); | ||
369 | for(j = 0; j < audblk->ncplbnd; j++) | ||
370 | { | ||
371 | audblk->cplcoexp[i][j] = mpeg3bits_getbits(audio->astream, 4); | ||
372 | audblk->cplcomant[i][j] = mpeg3bits_getbits(audio->astream, 4); | ||
373 | } | ||
374 | } | ||
375 | } | ||
376 | |||
377 | /* If we're in dual mono mode, there's going to be some phase info */ | ||
378 | if((bsi->acmod == 0x2) && audblk->phsflginu && | ||
379 | (audblk->cplcoe[0] || audblk->cplcoe[1])) | ||
380 | { | ||
381 | for(j = 0; j < audblk->ncplbnd; j++) | ||
382 | { | ||
383 | audblk->phsflg[j] = mpeg3bits_getbits(audio->astream, 1); | ||
384 | } | ||
385 | } | ||
386 | } | ||
387 | |||
388 | /* If we're in dual mono mode, there may be a rematrix strategy */ | ||
389 | if(bsi->acmod == 0x2) | ||
390 | { | ||
391 | audblk->rematstr = mpeg3bits_getbits(audio->astream, 1); | ||
392 | if(audblk->rematstr) | ||
393 | { | ||
394 | if (audblk->cplinu == 0) | ||
395 | { | ||
396 | for(i = 0; i < 4; i++) | ||
397 | audblk->rematflg[i] = mpeg3bits_getbits(audio->astream, 1); | ||
398 | } | ||
399 | if((audblk->cplbegf > 2) && audblk->cplinu) | ||
400 | { | ||
401 | for(i = 0; i < 4; i++) | ||
402 | audblk->rematflg[i] = mpeg3bits_getbits(audio->astream, 1); | ||
403 | } | ||
404 | if((audblk->cplbegf <= 2) && audblk->cplinu) | ||
405 | { | ||
406 | for(i = 0; i < 3; i++) | ||
407 | audblk->rematflg[i] = mpeg3bits_getbits(audio->astream, 1); | ||
408 | } | ||
409 | if((audblk->cplbegf == 0) && audblk->cplinu) | ||
410 | for(i = 0; i < 2; i++) | ||
411 | audblk->rematflg[i] = mpeg3bits_getbits(audio->astream, 1); | ||
412 | |||
413 | } | ||
414 | } | ||
415 | |||
416 | if (audblk->cplinu) | ||
417 | { | ||
418 | /* Get the coupling channel exponent strategy */ | ||
419 | audblk->cplexpstr = mpeg3bits_getbits(audio->astream, 2); | ||
420 | |||
421 | if(audblk->cplexpstr == 0) | ||
422 | audblk->ncplgrps = 0; | ||
423 | else | ||
424 | audblk->ncplgrps = (audblk->cplendmant - audblk->cplstrtmant) / | ||
425 | (3 << (audblk->cplexpstr - 1)); | ||
426 | |||
427 | } | ||
428 | |||
429 | for(i = 0; i < bsi->nfchans; i++) | ||
430 | { | ||
431 | audblk->chexpstr[i] = mpeg3bits_getbits(audio->astream, 2); | ||
432 | } | ||
433 | |||
434 | /* Get the exponent strategy for lfe channel */ | ||
435 | if(bsi->lfeon) | ||
436 | audblk->lfeexpstr = mpeg3bits_getbits(audio->astream, 1); | ||
437 | |||
438 | /* Determine the bandwidths of all the fbw channels */ | ||
439 | for(i = 0; i < bsi->nfchans; i++) | ||
440 | { | ||
441 | unsigned short grp_size; | ||
442 | |||
443 | if(audblk->chexpstr[i] != MPEG3_EXP_REUSE) | ||
444 | { | ||
445 | if (audblk->cplinu && audblk->chincpl[i]) | ||
446 | { | ||
447 | audblk->endmant[i] = audblk->cplstrtmant; | ||
448 | } | ||
449 | else | ||
450 | { | ||
451 | audblk->chbwcod[i] = mpeg3bits_getbits(audio->astream, 6); | ||
452 | audblk->endmant[i] = ((audblk->chbwcod[i] + 12) * 3) + 37; | ||
453 | } | ||
454 | |||
455 | /* Calculate the number of exponent groups to fetch */ | ||
456 | grp_size = 3 * (1 << (audblk->chexpstr[i] - 1)); | ||
457 | audblk->nchgrps[i] = (audblk->endmant[i] - 1 + (grp_size - 3)) / grp_size; | ||
458 | } | ||
459 | } | ||
460 | |||
461 | /* Get the coupling exponents if they exist */ | ||
462 | if(audblk->cplinu && (audblk->cplexpstr != MPEG3_EXP_REUSE)) | ||
463 | { | ||
464 | audblk->cplabsexp = mpeg3bits_getbits(audio->astream, 4); | ||
465 | for(i = 0; i< audblk->ncplgrps; i++) | ||
466 | audblk->cplexps[i] = mpeg3bits_getbits(audio->astream, 7); | ||
467 | } | ||
468 | |||
469 | /* Get the fwb channel exponents */ | ||
470 | for(i = 0; i < bsi->nfchans; i++) | ||
471 | { | ||
472 | if(audblk->chexpstr[i] != MPEG3_EXP_REUSE) | ||
473 | { | ||
474 | audblk->exps[i][0] = mpeg3bits_getbits(audio->astream, 4); | ||
475 | for(j = 1; j <= audblk->nchgrps[i]; j++) | ||
476 | audblk->exps[i][j] = mpeg3bits_getbits(audio->astream, 7); | ||
477 | audblk->gainrng[i] = mpeg3bits_getbits(audio->astream, 2); | ||
478 | } | ||
479 | } | ||
480 | |||
481 | /* Get the lfe channel exponents */ | ||
482 | if(bsi->lfeon && (audblk->lfeexpstr != MPEG3_EXP_REUSE)) | ||
483 | { | ||
484 | audblk->lfeexps[0] = mpeg3bits_getbits(audio->astream, 4); | ||
485 | audblk->lfeexps[1] = mpeg3bits_getbits(audio->astream, 7); | ||
486 | audblk->lfeexps[2] = mpeg3bits_getbits(audio->astream, 7); | ||
487 | } | ||
488 | |||
489 | /* Get the parametric bit allocation parameters */ | ||
490 | audblk->baie = mpeg3bits_getbits(audio->astream, 1); | ||
491 | |||
492 | if(audblk->baie) | ||
493 | { | ||
494 | audblk->sdcycod = mpeg3bits_getbits(audio->astream, 2); | ||
495 | audblk->fdcycod = mpeg3bits_getbits(audio->astream, 2); | ||
496 | audblk->sgaincod = mpeg3bits_getbits(audio->astream, 2); | ||
497 | audblk->dbpbcod = mpeg3bits_getbits(audio->astream, 2); | ||
498 | audblk->floorcod = mpeg3bits_getbits(audio->astream, 3); | ||
499 | } | ||
500 | |||
501 | |||
502 | /* Get the SNR off set info if it exists */ | ||
503 | audblk->snroffste = mpeg3bits_getbits(audio->astream, 1); | ||
504 | |||
505 | if(audblk->snroffste) | ||
506 | { | ||
507 | audblk->csnroffst = mpeg3bits_getbits(audio->astream, 6); | ||
508 | |||
509 | if(audblk->cplinu) | ||
510 | { | ||
511 | audblk->cplfsnroffst = mpeg3bits_getbits(audio->astream, 4); | ||
512 | audblk->cplfgaincod = mpeg3bits_getbits(audio->astream, 3); | ||
513 | } | ||
514 | |||
515 | for(i = 0; i < bsi->nfchans; i++) | ||
516 | { | ||
517 | audblk->fsnroffst[i] = mpeg3bits_getbits(audio->astream, 4); | ||
518 | audblk->fgaincod[i] = mpeg3bits_getbits(audio->astream, 3); | ||
519 | } | ||
520 | if(bsi->lfeon) | ||
521 | { | ||
522 | |||
523 | audblk->lfefsnroffst = mpeg3bits_getbits(audio->astream, 4); | ||
524 | audblk->lfefgaincod = mpeg3bits_getbits(audio->astream, 3); | ||
525 | } | ||
526 | } | ||
527 | |||
528 | /* Get coupling leakage info if it exists */ | ||
529 | if(audblk->cplinu) | ||
530 | { | ||
531 | audblk->cplleake = mpeg3bits_getbits(audio->astream, 1); | ||
532 | |||
533 | if(audblk->cplleake) | ||
534 | { | ||
535 | audblk->cplfleak = mpeg3bits_getbits(audio->astream, 3); | ||
536 | audblk->cplsleak = mpeg3bits_getbits(audio->astream, 3); | ||
537 | } | ||
538 | } | ||
539 | |||
540 | /* Get the delta bit alloaction info */ | ||
541 | audblk->deltbaie = mpeg3bits_getbits(audio->astream, 1); | ||
542 | |||
543 | if(audblk->deltbaie) | ||
544 | { | ||
545 | if(audblk->cplinu) | ||
546 | audblk->cpldeltbae = mpeg3bits_getbits(audio->astream, 2); | ||
547 | |||
548 | for(i = 0; i < bsi->nfchans; i++) | ||
549 | audblk->deltbae[i] = mpeg3bits_getbits(audio->astream, 2); | ||
550 | |||
551 | if (audblk->cplinu && (audblk->cpldeltbae == DELTA_BIT_NEW)) | ||
552 | { | ||
553 | audblk->cpldeltnseg = mpeg3bits_getbits(audio->astream, 3); | ||
554 | for(i = 0; i < audblk->cpldeltnseg + 1; i++) | ||
555 | { | ||
556 | audblk->cpldeltoffst[i] = mpeg3bits_getbits(audio->astream, 5); | ||
557 | audblk->cpldeltlen[i] = mpeg3bits_getbits(audio->astream, 4); | ||
558 | audblk->cpldeltba[i] = mpeg3bits_getbits(audio->astream, 3); | ||
559 | } | ||
560 | } | ||
561 | |||
562 | for(i = 0; i < bsi->nfchans; i++) | ||
563 | { | ||
564 | if (audblk->deltbae[i] == DELTA_BIT_NEW) | ||
565 | { | ||
566 | audblk->deltnseg[i] = mpeg3bits_getbits(audio->astream, 3); | ||
567 | for(j = 0; j < audblk->deltnseg[i] + 1; j++) | ||
568 | { | ||
569 | audblk->deltoffst[i][j] = mpeg3bits_getbits(audio->astream, 5); | ||
570 | audblk->deltlen[i][j] = mpeg3bits_getbits(audio->astream, 4); | ||
571 | audblk->deltba[i][j] = mpeg3bits_getbits(audio->astream, 3); | ||
572 | } | ||
573 | } | ||
574 | } | ||
575 | } | ||
576 | |||
577 | /* Check to see if there's any dummy info to get */ | ||
578 | if((audblk->skiple = mpeg3bits_getbits(audio->astream, 1))) | ||
579 | { | ||
580 | unsigned int skip_data; | ||
581 | audblk->skipl = mpeg3bits_getbits(audio->astream, 9); | ||
582 | for(i = 0; i < audblk->skipl ; i++) | ||
583 | { | ||
584 | skip_data = mpeg3bits_getbits(audio->astream, 8); | ||
585 | } | ||
586 | } | ||
587 | |||
588 | return mpeg3bits_error(audio->astream); | ||
589 | } | ||
590 | |||
591 | |||
592 | /* This routine simply does stereo rematrixing for the 2 channel | ||
593 | * stereo mode */ | ||
594 | int mpeg3audio_ac3_rematrix(mpeg3_ac3audblk_t *audblk, | ||
595 | mpeg3ac3_stream_samples_t samples) | ||
596 | { | ||
597 | int num_bands; | ||
598 | int start; | ||
599 | int end; | ||
600 | int i, j; | ||
601 | mpeg3_real_t left, right; | ||
602 | |||
603 | if(audblk->cplinu || audblk->cplbegf > 2) | ||
604 | num_bands = 4; | ||
605 | else if (audblk->cplbegf > 0) | ||
606 | num_bands = 3; | ||
607 | else | ||
608 | num_bands = 2; | ||
609 | |||
610 | for(i = 0; i < num_bands; i++) | ||
611 | { | ||
612 | if(!audblk->rematflg[i]) | ||
613 | continue; | ||
614 | |||
615 | start = mpeg3_rematrix_band[i].start; | ||
616 | end = mpeg3_min(mpeg3_rematrix_band[i].end, 12 * audblk->cplbegf + 36); | ||
617 | |||
618 | for(j = start; j < end; j++) | ||
619 | { | ||
620 | left = samples[0][j] + samples[1][j]; | ||
621 | right = samples[0][j] - samples[1][j]; | ||
622 | samples[0][j] = left; | ||
623 | samples[1][j] = right; | ||
624 | } | ||
625 | } | ||
626 | return 0; | ||
627 | } | ||
628 | |||
629 | |||
630 | int mpeg3audio_ac3_reset_frame(mpeg3audio_t *audio) | ||
631 | { | ||
632 | memset(&audio->ac3_bit_allocation, 0, sizeof(mpeg3_ac3_bitallocation_t)); | ||
633 | memset(&audio->ac3_mantissa, 0, sizeof(mpeg3_ac3_mantissa_t)); | ||
634 | memset(&audio->ac3_audblk, 0, sizeof(mpeg3_ac3audblk_t)); | ||
635 | |||
636 | return 0; | ||
637 | } | ||
638 | |||
639 | int mpeg3audio_do_ac3(mpeg3audio_t *audio) | ||
640 | { | ||
641 | int result = 0, i; | ||
642 | |||
643 | /* Reset the coefficients and exponents */ | ||
644 | mpeg3audio_ac3_reset_frame(audio); | ||
645 | |||
646 | for(i = 0; i < 6 && !result; i++) | ||
647 | { | ||
648 | memset(audio->ac3_samples, 0, sizeof(mpeg3_real_t) * 256 * (audio->ac3_bsi.nfchans + audio->ac3_bsi.lfeon)); | ||
649 | /* Extract most of the audblk info from the bitstream | ||
650 | * (minus the mantissas */ | ||
651 | result |= mpeg3audio_read_ac3_audblk(audio); | ||
652 | |||
653 | /* Take the differential exponent data and turn it into | ||
654 | * absolute exponents */ | ||
655 | if(!result) result |= mpeg3audio_ac3_exponent_unpack(audio, | ||
656 | &(audio->ac3_bsi), | ||
657 | &(audio->ac3_audblk)); | ||
658 | |||
659 | /* Figure out how many bits per mantissa */ | ||
660 | if(!result) result |= mpeg3audio_ac3_bit_allocate(audio, | ||
661 | audio->sampling_frequency_code, | ||
662 | &(audio->ac3_bsi), | ||
663 | &(audio->ac3_audblk)); | ||
664 | |||
665 | /* Extract the mantissas from the data stream */ | ||
666 | if(!result) result |= mpeg3audio_ac3_coeff_unpack(audio, | ||
667 | &(audio->ac3_bsi), | ||
668 | &(audio->ac3_audblk), | ||
669 | audio->ac3_samples); | ||
670 | |||
671 | if(audio->ac3_bsi.acmod == 0x2) | ||
672 | if(!result) result |= mpeg3audio_ac3_rematrix(&(audio->ac3_audblk), | ||
673 | audio->ac3_samples); | ||
674 | |||
675 | /* Convert the frequency data into time samples */ | ||
676 | if(!result) result |= mpeg3audio_ac3_imdct(audio, | ||
677 | &(audio->ac3_bsi), | ||
678 | &(audio->ac3_audblk), | ||
679 | audio->ac3_samples); | ||
680 | |||
681 | if(audio->pcm_point / audio->channels >= audio->pcm_allocated - MPEG3AUDIO_PADDING * audio->channels) | ||
682 | { | ||
683 | /* Need more room */ | ||
684 | mpeg3audio_replace_buffer(audio, audio->pcm_allocated + MPEG3AUDIO_PADDING * audio->channels); | ||
685 | } | ||
686 | } | ||
687 | |||
688 | mpeg3bits_use_demuxer(audio->astream); | ||
689 | |||
690 | return result; | ||
691 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/ac3.h b/core/multimedia/opieplayer/libmpeg3/audio/ac3.h new file mode 100644 index 0000000..9161c36 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/ac3.h | |||
@@ -0,0 +1,308 @@ | |||
1 | /********************************************************************** | ||
2 | ** Copyright (C) 2000 Trolltech AS. All rights reserved. | ||
3 | ** | ||
4 | ** This file is part of Qtopia Environment. | ||
5 | ** | ||
6 | ** This file may be distributed and/or modified under the terms of the | ||
7 | ** GNU General Public License version 2 as published by the Free Software | ||
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | ||
9 | ** packaging of this file. | ||
10 | ** | ||
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | ||
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | ||
13 | ** | ||
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | ||
15 | ** | ||
16 | ** Contact info@trolltech.com if any conditions of this licensing are | ||
17 | ** not clear to you. | ||
18 | ** | ||
19 | **********************************************************************/ | ||
20 | #ifndef AC3_H | ||
21 | #define AC3_H | ||
22 | |||
23 | #include "mpeg3real.h" | ||
24 | |||
25 | #define MAX_AC3_FRAMESIZE 1920 * 2 + 512 | ||
26 | |||
27 | extern int mpeg3_ac3_samplerates[3]; | ||
28 | |||
29 | /* Exponent strategy constants */ | ||
30 | #define MPEG3_EXP_REUSE (0) | ||
31 | #define MPEG3_EXP_D15 (1) | ||
32 | #define MPEG3_EXP_D25 (2) | ||
33 | #define MPEG3_EXP_D45 (3) | ||
34 | |||
35 | /* Delta bit allocation constants */ | ||
36 | #define DELTA_BIT_REUSE (0) | ||
37 | #define DELTA_BIT_NEW (1) | ||
38 | #define DELTA_BIT_NONE (2) | ||
39 | #define DELTA_BIT_RESERVED (3) | ||
40 | |||
41 | |||
42 | typedef mpeg3_real_t mpeg3ac3_stream_samples_t[6][256]; | ||
43 | |||
44 | typedef struct | ||
45 | { | ||
46 | /* Bit stream identification == 0x8 */ | ||
47 | int bsid; | ||
48 | /* Bit stream mode */ | ||
49 | int bsmod; | ||
50 | /* Audio coding mode */ | ||
51 | int acmod; | ||
52 | /* If we're using the centre channel then */ | ||
53 | /* centre mix level */ | ||
54 | int cmixlev; | ||
55 | /* If we're using the surround channel then */ | ||
56 | /* surround mix level */ | ||
57 | int surmixlev; | ||
58 | /* If we're in 2/0 mode then */ | ||
59 | /* Dolby surround mix level - NOT USED - */ | ||
60 | int dsurmod; | ||
61 | /* Low frequency effects on */ | ||
62 | int lfeon; | ||
63 | /* Dialogue Normalization level */ | ||
64 | int dialnorm; | ||
65 | /* Compression exists */ | ||
66 | int compre; | ||
67 | /* Compression level */ | ||
68 | int compr; | ||
69 | /* Language code exists */ | ||
70 | int langcode; | ||
71 | /* Language code */ | ||
72 | int langcod; | ||
73 | /* Audio production info exists*/ | ||
74 | unsigned int audprodie; | ||
75 | int mixlevel; | ||
76 | int roomtyp; | ||
77 | /* If we're in dual mono mode (acmod == 0) then extra stuff */ | ||
78 | int dialnorm2; | ||
79 | int compr2e; | ||
80 | int compr2; | ||
81 | int langcod2e; | ||
82 | int langcod2; | ||
83 | int audprodi2e; | ||
84 | int mixlevel2; | ||
85 | int roomtyp2; | ||
86 | /* Copyright bit */ | ||
87 | int copyrightb; | ||
88 | /* Original bit */ | ||
89 | int origbs; | ||
90 | /* Timecode 1 exists */ | ||
91 | int timecod1e; | ||
92 | /* Timecode 1 */ | ||
93 | unsigned int timecod1; | ||
94 | /* Timecode 2 exists */ | ||
95 | int timecod2e; | ||
96 | /* Timecode 2 */ | ||
97 | unsigned int timecod2; | ||
98 | /* Additional bit stream info exists */ | ||
99 | int addbsie; | ||
100 | /* Additional bit stream length - 1 (in bytes) */ | ||
101 | int addbsil; | ||
102 | /* Additional bit stream information (max 64 bytes) */ | ||
103 | unsigned char addbsi[64]; | ||
104 | |||
105 | /* Information not in the AC-3 bitstream, but derived */ | ||
106 | /* Number of channels (excluding LFE) | ||
107 | * Derived from acmod */ | ||
108 | int nfchans; | ||
109 | } mpeg3_ac3bsi_t; | ||
110 | |||
111 | typedef struct | ||
112 | { | ||
113 | /* block switch bit indexed by channel num */ | ||
114 | unsigned short blksw[5]; | ||
115 | /* dither enable bit indexed by channel num */ | ||
116 | unsigned short dithflag[5]; | ||
117 | /* dynamic range gain exists */ | ||
118 | int dynrnge; | ||
119 | /* dynamic range gain */ | ||
120 | int dynrng; | ||
121 | /* if acmod==0 then */ | ||
122 | /* dynamic range 2 gain exists */ | ||
123 | int dynrng2e; | ||
124 | /* dynamic range 2 gain */ | ||
125 | int dynrng2; | ||
126 | /* coupling strategy exists */ | ||
127 | int cplstre; | ||
128 | /* coupling in use */ | ||
129 | int cplinu; | ||
130 | /* channel coupled */ | ||
131 | unsigned short chincpl[5]; | ||
132 | /* if acmod==2 then */ | ||
133 | /* Phase flags in use */ | ||
134 | int phsflginu; | ||
135 | /* coupling begin frequency code */ | ||
136 | int cplbegf; | ||
137 | /* coupling end frequency code */ | ||
138 | int cplendf; | ||
139 | /* coupling band structure bits */ | ||
140 | unsigned short cplbndstrc[18]; | ||
141 | /* Do coupling co-ords exist for this channel? */ | ||
142 | unsigned short cplcoe[5]; | ||
143 | /* Master coupling co-ordinate */ | ||
144 | unsigned short mstrcplco[5]; | ||
145 | /* Per coupling band coupling co-ordinates */ | ||
146 | unsigned short cplcoexp[5][18]; | ||
147 | unsigned short cplcomant[5][18]; | ||
148 | /* Phase flags for dual mono */ | ||
149 | unsigned short phsflg[18]; | ||
150 | /* Is there a rematrixing strategy */ | ||
151 | unsigned int rematstr; | ||
152 | /* Rematrixing bits */ | ||
153 | unsigned short rematflg[4]; | ||
154 | /* Coupling exponent strategy */ | ||
155 | int cplexpstr; | ||
156 | /* Exponent strategy for full bandwidth channels */ | ||
157 | unsigned short chexpstr[5]; | ||
158 | /* Exponent strategy for lfe channel */ | ||
159 | int lfeexpstr; | ||
160 | /* Channel bandwidth for independent channels */ | ||
161 | unsigned short chbwcod[5]; | ||
162 | /* The absolute coupling exponent */ | ||
163 | int cplabsexp; | ||
164 | /* Coupling channel exponents (D15 mode gives 18 * 12 /3 encoded exponents */ | ||
165 | unsigned short cplexps[18 * 12 / 3]; | ||
166 | /* fbw channel exponents */ | ||
167 | unsigned short exps[5][252 / 3]; | ||
168 | /* channel gain range */ | ||
169 | unsigned short gainrng[5]; | ||
170 | /* low frequency exponents */ | ||
171 | unsigned short lfeexps[3]; | ||
172 | |||
173 | /* Bit allocation info */ | ||
174 | int baie; | ||
175 | /* Slow decay code */ | ||
176 | int sdcycod; | ||
177 | /* Fast decay code */ | ||
178 | int fdcycod; | ||
179 | /* Slow gain code */ | ||
180 | int sgaincod; | ||
181 | /* dB per bit code */ | ||
182 | int dbpbcod; | ||
183 | /* masking floor code */ | ||
184 | int floorcod; | ||
185 | |||
186 | /* SNR offset info */ | ||
187 | int snroffste; | ||
188 | /* coarse SNR offset */ | ||
189 | int csnroffst; | ||
190 | /* coupling fine SNR offset */ | ||
191 | int cplfsnroffst; | ||
192 | /* coupling fast gain code */ | ||
193 | int cplfgaincod; | ||
194 | /* fbw fine SNR offset */ | ||
195 | unsigned short fsnroffst[5]; | ||
196 | /* fbw fast gain code */ | ||
197 | unsigned short fgaincod[5]; | ||
198 | /* lfe fine SNR offset */ | ||
199 | int lfefsnroffst; | ||
200 | /* lfe fast gain code */ | ||
201 | int lfefgaincod; | ||
202 | |||
203 | /* Coupling leak info */ | ||
204 | int cplleake; | ||
205 | /* coupling fast leak initialization */ | ||
206 | int cplfleak; | ||
207 | /* coupling slow leak initialization */ | ||
208 | int cplsleak; | ||
209 | |||
210 | /* delta bit allocation info */ | ||
211 | int deltbaie; | ||
212 | /* coupling delta bit allocation exists */ | ||
213 | int cpldeltbae; | ||
214 | /* fbw delta bit allocation exists */ | ||
215 | unsigned short deltbae[5]; | ||
216 | /* number of cpl delta bit segments */ | ||
217 | int cpldeltnseg; | ||
218 | /* coupling delta bit allocation offset */ | ||
219 | short cpldeltoffst[8]; | ||
220 | /* coupling delta bit allocation length */ | ||
221 | short cpldeltlen[8]; | ||
222 | /* coupling delta bit allocation length */ | ||
223 | short cpldeltba[8]; | ||
224 | /* number of delta bit segments */ | ||
225 | unsigned short deltnseg[5]; | ||
226 | /* fbw delta bit allocation offset */ | ||
227 | short deltoffst[5][8]; | ||
228 | /* fbw delta bit allocation length */ | ||
229 | short deltlen[5][8]; | ||
230 | /* fbw delta bit allocation length */ | ||
231 | short deltba[5][8]; | ||
232 | |||
233 | /* skip length exists */ | ||
234 | int skiple; | ||
235 | /* skip length */ | ||
236 | int skipl; | ||
237 | |||
238 | /* channel mantissas */ | ||
239 | short chmant[5][256]; | ||
240 | |||
241 | /* coupling mantissas */ | ||
242 | unsigned short cplmant[256]; | ||
243 | |||
244 | /* coupling mantissas */ | ||
245 | unsigned short lfemant[7]; | ||
246 | |||
247 | /* -- Information not in the bitstream, but derived thereof -- */ | ||
248 | |||
249 | /* Number of coupling sub-bands */ | ||
250 | int ncplsubnd; | ||
251 | |||
252 | /* Number of combined coupling sub-bands | ||
253 | * Derived from ncplsubnd and cplbndstrc */ | ||
254 | int ncplbnd; | ||
255 | |||
256 | /* Number of exponent groups by channel | ||
257 | * Derived from strmant, endmant */ | ||
258 | int nchgrps[5]; | ||
259 | |||
260 | /* Number of coupling exponent groups | ||
261 | * Derived from cplbegf, cplendf, cplexpstr */ | ||
262 | int ncplgrps; | ||
263 | |||
264 | /* End mantissa numbers of fbw channels */ | ||
265 | unsigned short endmant[5]; | ||
266 | |||
267 | /* Start and end mantissa numbers for the coupling channel */ | ||
268 | int cplstrtmant; | ||
269 | int cplendmant; | ||
270 | |||
271 | /* Decoded exponent info */ | ||
272 | unsigned short fbw_exp[5][256]; | ||
273 | unsigned short cpl_exp[256]; | ||
274 | unsigned short lfe_exp[7]; | ||
275 | |||
276 | /* Bit allocation pointer results */ | ||
277 | short fbw_bap[5][256]; | ||
278 | /*FIXME figure out exactly how many entries there should be (253-37?) */ | ||
279 | short cpl_bap[256]; | ||
280 | short lfe_bap[7]; | ||
281 | } mpeg3_ac3audblk_t; | ||
282 | |||
283 | /* Bit allocation data */ | ||
284 | typedef struct | ||
285 | { | ||
286 | int sdecay; | ||
287 | int fdecay; | ||
288 | int sgain; | ||
289 | int dbknee; | ||
290 | int floor; | ||
291 | short psd[256]; | ||
292 | short bndpsd[256]; | ||
293 | short excite[256]; | ||
294 | short mask[256]; | ||
295 | } mpeg3_ac3_bitallocation_t; | ||
296 | |||
297 | /* Mantissa data */ | ||
298 | typedef struct | ||
299 | { | ||
300 | unsigned short m_1[3]; | ||
301 | unsigned short m_2[3]; | ||
302 | unsigned short m_4[2]; | ||
303 | unsigned short m_1_pointer; | ||
304 | unsigned short m_2_pointer; | ||
305 | unsigned short m_4_pointer; | ||
306 | } mpeg3_ac3_mantissa_t; | ||
307 | |||
308 | #endif | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/bit_allocation.c b/core/multimedia/opieplayer/libmpeg3/audio/bit_allocation.c new file mode 100644 index 0000000..29df7d7 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/bit_allocation.c | |||
@@ -0,0 +1,586 @@ | |||
1 | /* | ||
2 | * | ||
3 | *Copyright (C) Aaron Holtzman - May 1999 | ||
4 | * | ||
5 | * | ||
6 | * This file is part of libmpeg3 | ||
7 | * | ||
8 | * libmpeg3 is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2, or (at your option) | ||
11 | * any later version. | ||
12 | * | ||
13 | * libmpeg3 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 | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with GNU Make; see the file COPYING. If not, write to | ||
20 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | * | ||
22 | */ | ||
23 | |||
24 | #include "mpeg3audio.h" | ||
25 | #include "../libmpeg3.h" | ||
26 | #include "../mpeg3protos.h" | ||
27 | #include <string.h> | ||
28 | #include <stdlib.h> | ||
29 | |||
30 | /* Bit allocation tables */ | ||
31 | |||
32 | static short mpeg3_slowdec[] = { 0x0f, 0x11, 0x13, 0x15 }; | ||
33 | static short mpeg3_fastdec[] = { 0x3f, 0x53, 0x67, 0x7b }; | ||
34 | static short mpeg3_slowgain[] = { 0x540, 0x4d8, 0x478, 0x410 }; | ||
35 | static short mpeg3_dbpbtab[] = { 0x000, 0x700, 0x900, 0xb00 }; | ||
36 | |||
37 | static unsigned short mpeg3_floortab[] = { 0x2f0, 0x2b0, 0x270, 0x230, 0x1f0, 0x170, 0x0f0, 0xf800 }; | ||
38 | static short mpeg3_fastgain[] = { 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 }; | ||
39 | |||
40 | |||
41 | static short mpeg3_bndtab[] = | ||
42 | { | ||
43 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, | ||
44 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | ||
45 | 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, | ||
46 | 34, 37, 40, 43, 46, 49, 55, 61, 67, 73, | ||
47 | 79, 85, 97, 109, 121, 133, 157, 181, 205, 229 | ||
48 | }; | ||
49 | |||
50 | static short mpeg3_bndsz[] = | ||
51 | { | ||
52 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
53 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
54 | 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, | ||
55 | 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, | ||
56 | 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 | ||
57 | }; | ||
58 | |||
59 | static short mpeg3_masktab[] = | ||
60 | { | ||
61 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, | ||
62 | 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, 28, 29, | ||
63 | 29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, | ||
64 | 34, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37, | ||
65 | 37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 40, | ||
66 | 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, | ||
67 | 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43, | ||
68 | 43, 43, 43, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44, | ||
69 | 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, | ||
70 | 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, | ||
71 | 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, | ||
72 | 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, | ||
73 | 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, | ||
74 | 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, | ||
75 | 48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, | ||
76 | 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 0, 0, 0 | ||
77 | }; | ||
78 | |||
79 | |||
80 | static short mpeg3_latab[] = | ||
81 | { | ||
82 | 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039, | ||
83 | 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032, | ||
84 | 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c, | ||
85 | 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026, | ||
86 | 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021, | ||
87 | 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c, | ||
88 | 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018, | ||
89 | 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015, | ||
90 | 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012, | ||
91 | 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f, | ||
92 | 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d, | ||
93 | 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b, | ||
94 | 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009, | ||
95 | 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, | ||
96 | 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006, | ||
97 | 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005, | ||
98 | 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004, | ||
99 | 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, | ||
100 | 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, | ||
101 | 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002, | ||
102 | 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, | ||
103 | 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, | ||
104 | 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | ||
105 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | ||
106 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | ||
107 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | ||
108 | 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | ||
109 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | ||
110 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | ||
111 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | ||
112 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | ||
113 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | ||
114 | 0x0000, 0x0000, 0x0000, 0x0000 | ||
115 | }; | ||
116 | |||
117 | static short mpeg3_hth[][50] = | ||
118 | { | ||
119 | { | ||
120 | 0x04d0, 0x04d0, 0x0440, 0x0400, 0x03e0, 0x03c0, 0x03b0, 0x03b0, | ||
121 | 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, | ||
122 | 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350, | ||
123 | 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, | ||
124 | 0x02f0, 0x02f0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03e0, 0x0420, | ||
125 | 0x0460, 0x0490, 0x04a0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800, | ||
126 | 0x0840, 0x0840 | ||
127 | }, | ||
128 | |||
129 | { | ||
130 | 0x04f0, 0x04f0, 0x0460, 0x0410, 0x03e0, 0x03d0, 0x03c0, 0x03b0, | ||
131 | 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, | ||
132 | 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360, | ||
133 | 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, 0x0300, 0x02f0, | ||
134 | 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03e0, | ||
135 | 0x0420, 0x0450, 0x04a0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630, | ||
136 | 0x0840, 0x0840 | ||
137 | }, | ||
138 | |||
139 | { | ||
140 | 0x0580, 0x0580, 0x04b0, 0x0450, 0x0420, 0x03f0, 0x03e0, 0x03d0, | ||
141 | 0x03c0, 0x03b0, 0x03b0, 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, | ||
142 | 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, 0x0390, | ||
143 | 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, 0x0340, 0x0330, | ||
144 | 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0310, | ||
145 | 0x0330, 0x0350, 0x03c0, 0x0410, 0x0470, 0x04a0, 0x0460, 0x0440, | ||
146 | 0x0450, 0x04e0 | ||
147 | } | ||
148 | }; | ||
149 | |||
150 | |||
151 | static short mpeg3_baptab[] = | ||
152 | { | ||
153 | 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, | ||
154 | 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, | ||
155 | 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, | ||
156 | 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 | ||
157 | }; | ||
158 | |||
159 | |||
160 | inline int logadd(int a, int b) | ||
161 | { | ||
162 | int c; | ||
163 | int address; | ||
164 | |||
165 | c = a - b; | ||
166 | address = mpeg3_min((abs(c) >> 1), 255); | ||
167 | |||
168 | if(c >= 0) | ||
169 | return(a + mpeg3_latab[address]); | ||
170 | else | ||
171 | return(b + mpeg3_latab[address]); | ||
172 | } | ||
173 | |||
174 | |||
175 | int mpeg3audio_ac3_calc_lowcomp(int a, int b0, int b1, int bin) | ||
176 | { | ||
177 | if(bin < 7) | ||
178 | { | ||
179 | if((b0 + 256) == b1) | ||
180 | a = 384; | ||
181 | else | ||
182 | if(b0 > b1) | ||
183 | a = mpeg3_max(0, a - 64); | ||
184 | } | ||
185 | else if(bin < 20) | ||
186 | { | ||
187 | if((b0 + 256) == b1) | ||
188 | a = 320; | ||
189 | else if(b0 > b1) | ||
190 | a = mpeg3_max(0, a - 64) ; | ||
191 | } | ||
192 | else | ||
193 | a = mpeg3_max(0, a - 128); | ||
194 | |||
195 | return(a); | ||
196 | } | ||
197 | |||
198 | void mpeg3audio_ac3_ba_compute_psd(int start, | ||
199 | int end, | ||
200 | unsigned short exps[], | ||
201 | short psd[], | ||
202 | short bndpsd[]) | ||
203 | { | ||
204 | int bin,i,j,k; | ||
205 | int lastbin = 0; | ||
206 | |||
207 | /* Map the exponents into dBs */ | ||
208 | for (bin = start; bin < end; bin++) | ||
209 | { | ||
210 | psd[bin] = (3072 - (exps[bin] << 7)); | ||
211 | } | ||
212 | |||
213 | /* Integrate the psd function over each bit allocation band */ | ||
214 | j = start; | ||
215 | k = mpeg3_masktab[start]; | ||
216 | |||
217 | do | ||
218 | { | ||
219 | lastbin = mpeg3_min(mpeg3_bndtab[k] + mpeg3_bndsz[k], end); | ||
220 | bndpsd[k] = psd[j]; | ||
221 | j++; | ||
222 | |||
223 | for(i = j; i < lastbin; i++) | ||
224 | { | ||
225 | bndpsd[k] = logadd(bndpsd[k], psd[j]); | ||
226 | j++; | ||
227 | } | ||
228 | |||
229 | k++; | ||
230 | }while(end > lastbin); | ||
231 | } | ||
232 | |||
233 | void mpeg3audio_ac3_ba_compute_excitation(mpeg3audio_t *audio, | ||
234 | int start, | ||
235 | int end, | ||
236 | int fgain, | ||
237 | int fastleak, | ||
238 | int slowleak, | ||
239 | int is_lfe, | ||
240 | short bndpsd[], | ||
241 | short excite[]) | ||
242 | { | ||
243 | int bin; | ||
244 | int bndstrt; | ||
245 | int bndend; | ||
246 | int lowcomp = 0; | ||
247 | int begin = 0; | ||
248 | |||
249 | /* Compute excitation function */ | ||
250 | bndstrt = mpeg3_masktab[start]; | ||
251 | bndend = mpeg3_masktab[end - 1] + 1; | ||
252 | |||
253 | if(bndstrt == 0) /* For fbw and lfe channels */ | ||
254 | { | ||
255 | lowcomp = mpeg3audio_ac3_calc_lowcomp(lowcomp, bndpsd[0], bndpsd[1], 0); | ||
256 | excite[0] = bndpsd[0] - fgain - lowcomp; | ||
257 | lowcomp = mpeg3audio_ac3_calc_lowcomp(lowcomp, bndpsd[1], bndpsd[2], 1); | ||
258 | excite[1] = bndpsd[1] - fgain - lowcomp; | ||
259 | begin = 7 ; | ||
260 | |||
261 | /* Note: Do not call mpeg3audio_ac3_calc_lowcomp() for the last band of the lfe channel, (bin = 6) */ | ||
262 | for (bin = 2; bin < 7; bin++) | ||
263 | { | ||
264 | if(!(is_lfe && (bin == 6))) | ||
265 | lowcomp = mpeg3audio_ac3_calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin); | ||
266 | fastleak = bndpsd[bin] - fgain; | ||
267 | slowleak = bndpsd[bin] - audio->ac3_bit_allocation.sgain; | ||
268 | excite[bin] = fastleak - lowcomp; | ||
269 | |||
270 | if(!(is_lfe && (bin == 6))) | ||
271 | { | ||
272 | if(bndpsd[bin] <= bndpsd[bin+1]) | ||
273 | { | ||
274 | begin = bin + 1 ; | ||
275 | break; | ||
276 | } | ||
277 | } | ||
278 | } | ||
279 | |||
280 | for (bin = begin; bin < mpeg3_min(bndend, 22); bin++) | ||
281 | { | ||
282 | if (!(is_lfe && (bin == 6))) | ||
283 | lowcomp = mpeg3audio_ac3_calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin); | ||
284 | fastleak -= audio->ac3_bit_allocation.fdecay; | ||
285 | fastleak = mpeg3_max(fastleak, bndpsd[bin] - fgain); | ||
286 | slowleak -= audio->ac3_bit_allocation.sdecay; | ||
287 | slowleak = mpeg3_max(slowleak, bndpsd[bin] - audio->ac3_bit_allocation.sgain); | ||
288 | excite[bin] = mpeg3_max(fastleak - lowcomp, slowleak); | ||
289 | } | ||
290 | begin = 22; | ||
291 | } | ||
292 | else /* For coupling channel */ | ||
293 | { | ||
294 | begin = bndstrt; | ||
295 | } | ||
296 | |||
297 | for (bin = begin; bin < bndend; bin++) | ||
298 | { | ||
299 | fastleak -= audio->ac3_bit_allocation.fdecay; | ||
300 | fastleak = mpeg3_max(fastleak, bndpsd[bin] - fgain); | ||
301 | slowleak -= audio->ac3_bit_allocation.sdecay; | ||
302 | slowleak = mpeg3_max(slowleak, bndpsd[bin] - audio->ac3_bit_allocation.sgain); | ||
303 | excite[bin] = mpeg3_max(fastleak, slowleak) ; | ||
304 | } | ||
305 | } | ||
306 | |||
307 | void mpeg3audio_ac3_ba_compute_mask(mpeg3audio_t *audio, | ||
308 | int start, | ||
309 | int end, | ||
310 | int fscod, | ||
311 | int deltbae, | ||
312 | int deltnseg, | ||
313 | short deltoffst[], | ||
314 | short deltba[], | ||
315 | short deltlen[], | ||
316 | short excite[], | ||
317 | short mask[]) | ||
318 | { | ||
319 | int bin, k; | ||
320 | int bndstrt; | ||
321 | int bndend; | ||
322 | int delta; | ||
323 | |||
324 | bndstrt = mpeg3_masktab[start]; | ||
325 | bndend = mpeg3_masktab[end - 1] + 1; | ||
326 | |||
327 | /* Compute the masking curve */ | ||
328 | |||
329 | for (bin = bndstrt; bin < bndend; bin++) | ||
330 | { | ||
331 | if (audio->ac3_bit_allocation.bndpsd[bin] < audio->ac3_bit_allocation.dbknee) | ||
332 | { | ||
333 | excite[bin] += ((audio->ac3_bit_allocation.dbknee - audio->ac3_bit_allocation.bndpsd[bin]) >> 2); | ||
334 | } | ||
335 | mask[bin] = mpeg3_max(excite[bin], mpeg3_hth[fscod][bin]); | ||
336 | } | ||
337 | |||
338 | /* Perform delta bit modulation if necessary */ | ||
339 | if ((deltbae == DELTA_BIT_REUSE) || (deltbae == DELTA_BIT_NEW)) | ||
340 | { | ||
341 | int band = 0; | ||
342 | int seg = 0; | ||
343 | |||
344 | for (seg = 0; seg < deltnseg + 1; seg++) | ||
345 | { | ||
346 | band += deltoffst[seg]; | ||
347 | if (deltba[seg] >= 4) | ||
348 | { | ||
349 | delta = (deltba[seg] - 3) << 7; | ||
350 | } | ||
351 | else | ||
352 | { | ||
353 | delta = (deltba[seg] - 4) << 7; | ||
354 | } | ||
355 | |||
356 | for (k = 0; k < deltlen[seg]; k++) | ||
357 | { | ||
358 | mask[band] += delta; | ||
359 | band++; | ||
360 | } | ||
361 | } | ||
362 | } | ||
363 | } | ||
364 | |||
365 | void mpeg3audio_ac3_ba_compute_bap(mpeg3audio_t *audio, | ||
366 | int start, | ||
367 | int end, | ||
368 | int snroffset, | ||
369 | short psd[], | ||
370 | short mask[], | ||
371 | short bap[]) | ||
372 | { | ||
373 | int i, j, k; | ||
374 | short lastbin = 0; | ||
375 | short address = 0; | ||
376 | |||
377 | /* Compute the bit allocation pointer for each bin */ | ||
378 | i = start; | ||
379 | j = mpeg3_masktab[start]; | ||
380 | |||
381 | do | ||
382 | { | ||
383 | lastbin = mpeg3_min(mpeg3_bndtab[j] + mpeg3_bndsz[j], end); | ||
384 | mask[j] -= snroffset; | ||
385 | mask[j] -= audio->ac3_bit_allocation.floor; | ||
386 | |||
387 | if(mask[j] < 0) | ||
388 | mask[j] = 0; | ||
389 | |||
390 | mask[j] &= 0x1fe0; | ||
391 | mask[j] += audio->ac3_bit_allocation.floor; | ||
392 | for(k = i; k < lastbin; k++) | ||
393 | { | ||
394 | address = (psd[i] - mask[j]) >> 5; | ||
395 | address = mpeg3_min(63, mpeg3_max(0, address)); | ||
396 | bap[i] = mpeg3_baptab[address]; | ||
397 | i++; | ||
398 | } | ||
399 | j++; | ||
400 | }while (end > lastbin); | ||
401 | } | ||
402 | |||
403 | int mpeg3audio_ac3_bit_allocate(mpeg3audio_t *audio, | ||
404 | unsigned int fscod, | ||
405 | mpeg3_ac3bsi_t *bsi, | ||
406 | mpeg3_ac3audblk_t *audblk) | ||
407 | { | ||
408 | int result = 0; | ||
409 | int i; | ||
410 | int fgain; | ||
411 | int snroffset; | ||
412 | int start; | ||
413 | int end; | ||
414 | int fastleak; | ||
415 | int slowleak; | ||
416 | |||
417 | /*printf("mpeg3audio_ac3_bit_allocate %d %d %d %d %d\n", audblk->sdcycod, audblk->fdcycod, audblk->sgaincod, audblk->dbpbcod, audblk->floorcod); */ | ||
418 | /* Only perform bit_allocation if the exponents have changed or we | ||
419 | * have new sideband information */ | ||
420 | if(audblk->chexpstr[0] == 0 && audblk->chexpstr[1] == 0 && | ||
421 | audblk->chexpstr[2] == 0 && audblk->chexpstr[3] == 0 && | ||
422 | audblk->chexpstr[4] == 0 && audblk->cplexpstr == 0 && | ||
423 | audblk->lfeexpstr == 0 && audblk->baie == 0 && | ||
424 | audblk->snroffste == 0 && audblk->deltbaie == 0) | ||
425 | return 0; | ||
426 | |||
427 | /* Do some setup before we do the bit alloc */ | ||
428 | audio->ac3_bit_allocation.sdecay = mpeg3_slowdec[audblk->sdcycod]; | ||
429 | audio->ac3_bit_allocation.fdecay = mpeg3_fastdec[audblk->fdcycod]; | ||
430 | audio->ac3_bit_allocation.sgain = mpeg3_slowgain[audblk->sgaincod]; | ||
431 | audio->ac3_bit_allocation.dbknee = mpeg3_dbpbtab[audblk->dbpbcod]; | ||
432 | audio->ac3_bit_allocation.floor = mpeg3_floortab[audblk->floorcod]; | ||
433 | |||
434 | /* if all the SNR offset constants are zero then the whole block is zero */ | ||
435 | if(!audblk->csnroffst && !audblk->fsnroffst[0] && | ||
436 | !audblk->fsnroffst[1] && !audblk->fsnroffst[2] && | ||
437 | !audblk->fsnroffst[3] && !audblk->fsnroffst[4] && | ||
438 | !audblk->cplfsnroffst && !audblk->lfefsnroffst) | ||
439 | { | ||
440 | memset(audblk->fbw_bap, 0, sizeof(short) * 256 * 5); | ||
441 | memset(audblk->cpl_bap, 0, sizeof(short) * 256); | ||
442 | memset(audblk->lfe_bap, 0, sizeof(short) * 7); | ||
443 | return 0; | ||
444 | } | ||
445 | |||
446 | for(i = 0; i < bsi->nfchans; i++) | ||
447 | { | ||
448 | start = 0; | ||
449 | end = audblk->endmant[i]; | ||
450 | fgain = mpeg3_fastgain[audblk->fgaincod[i]]; | ||
451 | snroffset = (((audblk->csnroffst - 15) << 4) + audblk->fsnroffst[i]) << 2 ; | ||
452 | fastleak = 0; | ||
453 | slowleak = 0; | ||
454 | |||
455 | mpeg3audio_ac3_ba_compute_psd(start, | ||
456 | end, | ||
457 | audblk->fbw_exp[i], | ||
458 | audio->ac3_bit_allocation.psd, | ||
459 | audio->ac3_bit_allocation.bndpsd); | ||
460 | |||
461 | mpeg3audio_ac3_ba_compute_excitation(audio, | ||
462 | start, | ||
463 | end , | ||
464 | fgain, | ||
465 | fastleak, | ||
466 | slowleak, | ||
467 | 0, | ||
468 | audio->ac3_bit_allocation.bndpsd, | ||
469 | audio->ac3_bit_allocation.excite); | ||
470 | |||
471 | mpeg3audio_ac3_ba_compute_mask(audio, | ||
472 | start, | ||
473 | end, | ||
474 | fscod, | ||
475 | audblk->deltbae[i], | ||
476 | audblk->deltnseg[i], | ||
477 | audblk->deltoffst[i], | ||
478 | audblk->deltba[i], | ||
479 | audblk->deltlen[i], | ||
480 | audio->ac3_bit_allocation.excite, | ||
481 | audio->ac3_bit_allocation.mask); | ||
482 | |||
483 | mpeg3audio_ac3_ba_compute_bap(audio, | ||
484 | start, | ||
485 | end, | ||
486 | snroffset, | ||
487 | audio->ac3_bit_allocation.psd, | ||
488 | audio->ac3_bit_allocation.mask, | ||
489 | audblk->fbw_bap[i]); | ||
490 | } | ||
491 | |||
492 | if(audblk->cplinu) | ||
493 | { | ||
494 | start = audblk->cplstrtmant; | ||
495 | end = audblk->cplendmant; | ||
496 | fgain = mpeg3_fastgain[audblk->cplfgaincod]; | ||
497 | snroffset = (((audblk->csnroffst - 15) << 4) + audblk->cplfsnroffst) << 2 ; | ||
498 | fastleak = (audblk->cplfleak << 8) + 768; | ||
499 | slowleak = (audblk->cplsleak << 8) + 768; | ||
500 | |||
501 | mpeg3audio_ac3_ba_compute_psd(start, | ||
502 | end, | ||
503 | audblk->cpl_exp, | ||
504 | audio->ac3_bit_allocation.psd, | ||
505 | audio->ac3_bit_allocation.bndpsd); | ||
506 | |||
507 | mpeg3audio_ac3_ba_compute_excitation(audio, | ||
508 | start, | ||
509 | end , | ||
510 | fgain, | ||
511 | fastleak, | ||
512 | slowleak, | ||
513 | 0, | ||
514 | audio->ac3_bit_allocation.bndpsd, | ||
515 | audio->ac3_bit_allocation.excite); | ||
516 | |||
517 | mpeg3audio_ac3_ba_compute_mask(audio, | ||
518 | start, | ||
519 | end, | ||
520 | fscod, | ||
521 | audblk->cpldeltbae, | ||
522 | audblk->cpldeltnseg, | ||
523 | audblk->cpldeltoffst, | ||
524 | audblk->cpldeltba, | ||
525 | audblk->cpldeltlen, | ||
526 | audio->ac3_bit_allocation.excite, | ||
527 | audio->ac3_bit_allocation.mask); | ||
528 | |||
529 | mpeg3audio_ac3_ba_compute_bap(audio, | ||
530 | start, | ||
531 | end, | ||
532 | snroffset, | ||
533 | audio->ac3_bit_allocation.psd, | ||
534 | audio->ac3_bit_allocation.mask, | ||
535 | audblk->cpl_bap); | ||
536 | } | ||
537 | |||
538 | if(bsi->lfeon) | ||
539 | { | ||
540 | start = 0; | ||
541 | end = 7; | ||
542 | fgain = mpeg3_fastgain[audblk->lfefgaincod]; | ||
543 | snroffset = (((audblk->csnroffst - 15) << 4) + audblk->lfefsnroffst) << 2 ; | ||
544 | fastleak = 0; | ||
545 | slowleak = 0; | ||
546 | |||
547 | mpeg3audio_ac3_ba_compute_psd(start, | ||
548 | end, | ||
549 | audblk->lfe_exp, | ||
550 | audio->ac3_bit_allocation.psd, | ||
551 | audio->ac3_bit_allocation.bndpsd); | ||
552 | |||
553 | mpeg3audio_ac3_ba_compute_excitation(audio, | ||
554 | start, | ||
555 | end , | ||
556 | fgain, | ||
557 | fastleak, | ||
558 | slowleak, | ||
559 | 1, | ||
560 | audio->ac3_bit_allocation.bndpsd, | ||
561 | audio->ac3_bit_allocation.excite); | ||
562 | |||
563 | /* Perform no delta bit allocation for lfe */ | ||
564 | mpeg3audio_ac3_ba_compute_mask(audio, | ||
565 | start, | ||
566 | end, | ||
567 | fscod, | ||
568 | 2, | ||
569 | 0, | ||
570 | 0, | ||
571 | 0, | ||
572 | 0, | ||
573 | audio->ac3_bit_allocation.excite, | ||
574 | audio->ac3_bit_allocation.mask); | ||
575 | |||
576 | mpeg3audio_ac3_ba_compute_bap(audio, | ||
577 | start, | ||
578 | end, | ||
579 | snroffset, | ||
580 | audio->ac3_bit_allocation.psd, | ||
581 | audio->ac3_bit_allocation.mask, | ||
582 | audblk->lfe_bap); | ||
583 | } | ||
584 | |||
585 | return result; | ||
586 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/c_flags b/core/multimedia/opieplayer/libmpeg3/audio/c_flags new file mode 100755 index 0000000..d7943d0 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/c_flags | |||
@@ -0,0 +1 @@ | |||
echo $CFLAGS | |||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/dct.c b/core/multimedia/opieplayer/libmpeg3/audio/dct.c new file mode 100644 index 0000000..1fd52ce --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/dct.c | |||
@@ -0,0 +1,1135 @@ | |||
1 | /* | ||
2 | * | ||
3 | * This file is part of libmpeg3 | ||
4 | * | ||
5 | * libmpeg3 is free software; you can redistribute it and/or modify | ||
6 | * it under the terms of the GNU General Public License as published by | ||
7 | * the Free Software Foundation; either version 2, or (at your option) | ||
8 | * any later version. | ||
9 | * | ||
10 | * libmpeg3 is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with GNU Make; see the file COPYING. If not, write to | ||
17 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | ||
18 | * | ||
19 | */ | ||
20 | |||
21 | /* | ||
22 | * Discrete Cosine Tansform (DCT) for subband synthesis | ||
23 | * optimized for machines with no auto-increment. | ||
24 | * The performance is highly compiler dependend. Maybe | ||
25 | * the dct64.c version for 'normal' processor may be faster | ||
26 | * even for Intel processors. | ||
27 | */ | ||
28 | |||
29 | #include "mpeg3audio.h" | ||
30 | #include "../libmpeg3.h" | ||
31 | #include "../mpeg3protos.h" | ||
32 | #include "tables.h" | ||
33 | |||
34 | #include <math.h> | ||
35 | |||
36 | int mpeg3audio_dct64_1(mpeg3_real_t *out0, mpeg3_real_t *out1, mpeg3_real_t *b1, mpeg3_real_t *b2, mpeg3_real_t *samples) | ||
37 | { | ||
38 | register mpeg3_real_t *costab = mpeg3_pnts[0]; | ||
39 | |||
40 | b1[0x00] = samples[0x00] + samples[0x1F]; | ||
41 | b1[0x01] = samples[0x01] + samples[0x1E]; | ||
42 | b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0]; | ||
43 | b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1]; | ||
44 | |||
45 | b1[0x02] = samples[0x02] + samples[0x1D]; | ||
46 | b1[0x03] = samples[0x03] + samples[0x1C]; | ||
47 | b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2]; | ||
48 | b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3]; | ||
49 | |||
50 | b1[0x04] = samples[0x04] + samples[0x1B]; | ||
51 | b1[0x05] = samples[0x05] + samples[0x1A]; | ||
52 | b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4]; | ||
53 | b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5]; | ||
54 | |||
55 | b1[0x06] = samples[0x06] + samples[0x19]; | ||
56 | b1[0x07] = samples[0x07] + samples[0x18]; | ||
57 | b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6]; | ||
58 | b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7]; | ||
59 | |||
60 | b1[0x08] = samples[0x08] + samples[0x17]; | ||
61 | b1[0x09] = samples[0x09] + samples[0x16]; | ||
62 | b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8]; | ||
63 | b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9]; | ||
64 | |||
65 | b1[0x0A] = samples[0x0A] + samples[0x15]; | ||
66 | b1[0x0B] = samples[0x0B] + samples[0x14]; | ||
67 | b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA]; | ||
68 | b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB]; | ||
69 | |||
70 | b1[0x0C] = samples[0x0C] + samples[0x13]; | ||
71 | b1[0x0D] = samples[0x0D] + samples[0x12]; | ||
72 | b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC]; | ||
73 | b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD]; | ||
74 | |||
75 | b1[0x0E] = samples[0x0E] + samples[0x11]; | ||
76 | b1[0x0F] = samples[0x0F] + samples[0x10]; | ||
77 | b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE]; | ||
78 | b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF]; | ||
79 | |||
80 | costab = mpeg3_pnts[1]; | ||
81 | |||
82 | b2[0x00] = b1[0x00] + b1[0x0F]; | ||
83 | b2[0x01] = b1[0x01] + b1[0x0E]; | ||
84 | b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0]; | ||
85 | b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1]; | ||
86 | |||
87 | b2[0x02] = b1[0x02] + b1[0x0D]; | ||
88 | b2[0x03] = b1[0x03] + b1[0x0C]; | ||
89 | b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2]; | ||
90 | b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3]; | ||
91 | |||
92 | b2[0x04] = b1[0x04] + b1[0x0B]; | ||
93 | b2[0x05] = b1[0x05] + b1[0x0A]; | ||
94 | b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4]; | ||
95 | b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5]; | ||
96 | |||
97 | b2[0x06] = b1[0x06] + b1[0x09]; | ||
98 | b2[0x07] = b1[0x07] + b1[0x08]; | ||
99 | b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6]; | ||
100 | b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7]; | ||
101 | |||
102 | /* */ | ||
103 | |||
104 | b2[0x10] = b1[0x10] + b1[0x1F]; | ||
105 | b2[0x11] = b1[0x11] + b1[0x1E]; | ||
106 | b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0]; | ||
107 | b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1]; | ||
108 | |||
109 | b2[0x12] = b1[0x12] + b1[0x1D]; | ||
110 | b2[0x13] = b1[0x13] + b1[0x1C]; | ||
111 | b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2]; | ||
112 | b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3]; | ||
113 | |||
114 | b2[0x14] = b1[0x14] + b1[0x1B]; | ||
115 | b2[0x15] = b1[0x15] + b1[0x1A]; | ||
116 | b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4]; | ||
117 | b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5]; | ||
118 | |||
119 | b2[0x16] = b1[0x16] + b1[0x19]; | ||
120 | b2[0x17] = b1[0x17] + b1[0x18]; | ||
121 | b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6]; | ||
122 | b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7]; | ||
123 | |||
124 | costab = mpeg3_pnts[2]; | ||
125 | |||
126 | b1[0x00] = b2[0x00] + b2[0x07]; | ||
127 | b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0]; | ||
128 | b1[0x01] = b2[0x01] + b2[0x06]; | ||
129 | b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1]; | ||
130 | b1[0x02] = b2[0x02] + b2[0x05]; | ||
131 | b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2]; | ||
132 | b1[0x03] = b2[0x03] + b2[0x04]; | ||
133 | b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3]; | ||
134 | |||
135 | b1[0x08] = b2[0x08] + b2[0x0F]; | ||
136 | b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0]; | ||
137 | b1[0x09] = b2[0x09] + b2[0x0E]; | ||
138 | b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1]; | ||
139 | b1[0x0A] = b2[0x0A] + b2[0x0D]; | ||
140 | b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2]; | ||
141 | b1[0x0B] = b2[0x0B] + b2[0x0C]; | ||
142 | b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3]; | ||
143 | |||
144 | b1[0x10] = b2[0x10] + b2[0x17]; | ||
145 | b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0]; | ||
146 | b1[0x11] = b2[0x11] + b2[0x16]; | ||
147 | b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1]; | ||
148 | b1[0x12] = b2[0x12] + b2[0x15]; | ||
149 | b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2]; | ||
150 | b1[0x13] = b2[0x13] + b2[0x14]; | ||
151 | b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3]; | ||
152 | |||
153 | b1[0x18] = b2[0x18] + b2[0x1F]; | ||
154 | b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0]; | ||
155 | b1[0x19] = b2[0x19] + b2[0x1E]; | ||
156 | b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1]; | ||
157 | b1[0x1A] = b2[0x1A] + b2[0x1D]; | ||
158 | b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2]; | ||
159 | b1[0x1B] = b2[0x1B] + b2[0x1C]; | ||
160 | b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3]; | ||
161 | |||
162 | { | ||
163 | register mpeg3_real_t const cos0 = mpeg3_pnts[3][0]; | ||
164 | register mpeg3_real_t const cos1 = mpeg3_pnts[3][1]; | ||
165 | |||
166 | b2[0x00] = b1[0x00] + b1[0x03]; | ||
167 | b2[0x03] = (b1[0x00] - b1[0x03]) * cos0; | ||
168 | b2[0x01] = b1[0x01] + b1[0x02]; | ||
169 | b2[0x02] = (b1[0x01] - b1[0x02]) * cos1; | ||
170 | |||
171 | b2[0x04] = b1[0x04] + b1[0x07]; | ||
172 | b2[0x07] = (b1[0x07] - b1[0x04]) * cos0; | ||
173 | b2[0x05] = b1[0x05] + b1[0x06]; | ||
174 | b2[0x06] = (b1[0x06] - b1[0x05]) * cos1; | ||
175 | |||
176 | b2[0x08] = b1[0x08] + b1[0x0B]; | ||
177 | b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0; | ||
178 | b2[0x09] = b1[0x09] + b1[0x0A]; | ||
179 | b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1; | ||
180 | |||
181 | b2[0x0C] = b1[0x0C] + b1[0x0F]; | ||
182 | b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0; | ||
183 | b2[0x0D] = b1[0x0D] + b1[0x0E]; | ||
184 | b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1; | ||
185 | |||
186 | b2[0x10] = b1[0x10] + b1[0x13]; | ||
187 | b2[0x13] = (b1[0x10] - b1[0x13]) * cos0; | ||
188 | b2[0x11] = b1[0x11] + b1[0x12]; | ||
189 | b2[0x12] = (b1[0x11] - b1[0x12]) * cos1; | ||
190 | |||
191 | b2[0x14] = b1[0x14] + b1[0x17]; | ||
192 | b2[0x17] = (b1[0x17] - b1[0x14]) * cos0; | ||
193 | b2[0x15] = b1[0x15] + b1[0x16]; | ||
194 | b2[0x16] = (b1[0x16] - b1[0x15]) * cos1; | ||
195 | |||
196 | b2[0x18] = b1[0x18] + b1[0x1B]; | ||
197 | b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0; | ||
198 | b2[0x19] = b1[0x19] + b1[0x1A]; | ||
199 | b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1; | ||
200 | |||
201 | b2[0x1C] = b1[0x1C] + b1[0x1F]; | ||
202 | b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0; | ||
203 | b2[0x1D] = b1[0x1D] + b1[0x1E]; | ||
204 | b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1; | ||
205 | } | ||
206 | |||
207 | { | ||
208 | register mpeg3_real_t const cos0 = mpeg3_pnts[4][0]; | ||
209 | |||
210 | b1[0x00] = b2[0x00] + b2[0x01]; | ||
211 | b1[0x01] = (b2[0x00] - b2[0x01]) * cos0; | ||
212 | b1[0x02] = b2[0x02] + b2[0x03]; | ||
213 | b1[0x03] = (b2[0x03] - b2[0x02]) * cos0; | ||
214 | b1[0x02] += b1[0x03]; | ||
215 | |||
216 | b1[0x04] = b2[0x04] + b2[0x05]; | ||
217 | b1[0x05] = (b2[0x04] - b2[0x05]) * cos0; | ||
218 | b1[0x06] = b2[0x06] + b2[0x07]; | ||
219 | b1[0x07] = (b2[0x07] - b2[0x06]) * cos0; | ||
220 | b1[0x06] += b1[0x07]; | ||
221 | b1[0x04] += b1[0x06]; | ||
222 | b1[0x06] += b1[0x05]; | ||
223 | b1[0x05] += b1[0x07]; | ||
224 | |||
225 | b1[0x08] = b2[0x08] + b2[0x09]; | ||
226 | b1[0x09] = (b2[0x08] - b2[0x09]) * cos0; | ||
227 | b1[0x0A] = b2[0x0A] + b2[0x0B]; | ||
228 | b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0; | ||
229 | b1[0x0A] += b1[0x0B]; | ||
230 | |||
231 | b1[0x0C] = b2[0x0C] + b2[0x0D]; | ||
232 | b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0; | ||
233 | b1[0x0E] = b2[0x0E] + b2[0x0F]; | ||
234 | b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0; | ||
235 | b1[0x0E] += b1[0x0F]; | ||
236 | b1[0x0C] += b1[0x0E]; | ||
237 | b1[0x0E] += b1[0x0D]; | ||
238 | b1[0x0D] += b1[0x0F]; | ||
239 | |||
240 | b1[0x10] = b2[0x10] + b2[0x11]; | ||
241 | b1[0x11] = (b2[0x10] - b2[0x11]) * cos0; | ||
242 | b1[0x12] = b2[0x12] + b2[0x13]; | ||
243 | b1[0x13] = (b2[0x13] - b2[0x12]) * cos0; | ||
244 | b1[0x12] += b1[0x13]; | ||
245 | |||
246 | b1[0x14] = b2[0x14] + b2[0x15]; | ||
247 | b1[0x15] = (b2[0x14] - b2[0x15]) * cos0; | ||
248 | b1[0x16] = b2[0x16] + b2[0x17]; | ||
249 | b1[0x17] = (b2[0x17] - b2[0x16]) * cos0; | ||
250 | b1[0x16] += b1[0x17]; | ||
251 | b1[0x14] += b1[0x16]; | ||
252 | b1[0x16] += b1[0x15]; | ||
253 | b1[0x15] += b1[0x17]; | ||
254 | |||
255 | b1[0x18] = b2[0x18] + b2[0x19]; | ||
256 | b1[0x19] = (b2[0x18] - b2[0x19]) * cos0; | ||
257 | b1[0x1A] = b2[0x1A] + b2[0x1B]; | ||
258 | b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0; | ||
259 | b1[0x1A] += b1[0x1B]; | ||
260 | |||
261 | b1[0x1C] = b2[0x1C] + b2[0x1D]; | ||
262 | b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0; | ||
263 | b1[0x1E] = b2[0x1E] + b2[0x1F]; | ||
264 | b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0; | ||
265 | b1[0x1E] += b1[0x1F]; | ||
266 | b1[0x1C] += b1[0x1E]; | ||
267 | b1[0x1E] += b1[0x1D]; | ||
268 | b1[0x1D] += b1[0x1F]; | ||
269 | } | ||
270 | |||
271 | out0[0x10*16] = b1[0x00]; | ||
272 | out0[0x10*12] = b1[0x04]; | ||
273 | out0[0x10* 8] = b1[0x02]; | ||
274 | out0[0x10* 4] = b1[0x06]; | ||
275 | out0[0x10* 0] = b1[0x01]; | ||
276 | out1[0x10* 0] = b1[0x01]; | ||
277 | out1[0x10* 4] = b1[0x05]; | ||
278 | out1[0x10* 8] = b1[0x03]; | ||
279 | out1[0x10*12] = b1[0x07]; | ||
280 | |||
281 | out0[0x10*14] = b1[0x08] + b1[0x0C]; | ||
282 | out0[0x10*10] = b1[0x0C] + b1[0x0a]; | ||
283 | out0[0x10* 6] = b1[0x0A] + b1[0x0E]; | ||
284 | out0[0x10* 2] = b1[0x0E] + b1[0x09]; | ||
285 | out1[0x10* 2] = b1[0x09] + b1[0x0D]; | ||
286 | out1[0x10* 6] = b1[0x0D] + b1[0x0B]; | ||
287 | out1[0x10*10] = b1[0x0B] + b1[0x0F]; | ||
288 | out1[0x10*14] = b1[0x0F]; | ||
289 | |||
290 | { | ||
291 | register mpeg3_real_t tmp; | ||
292 | tmp = b1[0x18] + b1[0x1C]; | ||
293 | out0[0x10*15] = tmp + b1[0x10]; | ||
294 | out0[0x10*13] = tmp + b1[0x14]; | ||
295 | tmp = b1[0x1C] + b1[0x1A]; | ||
296 | out0[0x10*11] = tmp + b1[0x14]; | ||
297 | out0[0x10* 9] = tmp + b1[0x12]; | ||
298 | tmp = b1[0x1A] + b1[0x1E]; | ||
299 | out0[0x10* 7] = tmp + b1[0x12]; | ||
300 | out0[0x10* 5] = tmp + b1[0x16]; | ||
301 | tmp = b1[0x1E] + b1[0x19]; | ||
302 | out0[0x10* 3] = tmp + b1[0x16]; | ||
303 | out0[0x10* 1] = tmp + b1[0x11]; | ||
304 | tmp = b1[0x19] + b1[0x1D]; | ||
305 | out1[0x10* 1] = tmp + b1[0x11]; | ||
306 | out1[0x10* 3] = tmp + b1[0x15]; | ||
307 | tmp = b1[0x1D] + b1[0x1B]; | ||
308 | out1[0x10* 5] = tmp + b1[0x15]; | ||
309 | out1[0x10* 7] = tmp + b1[0x13]; | ||
310 | tmp = b1[0x1B] + b1[0x1F]; | ||
311 | out1[0x10* 9] = tmp + b1[0x13]; | ||
312 | out1[0x10*11] = tmp + b1[0x17]; | ||
313 | out1[0x10*13] = b1[0x17] + b1[0x1F]; | ||
314 | out1[0x10*15] = b1[0x1F]; | ||
315 | } | ||
316 | return 0; | ||
317 | } | ||
318 | |||
319 | /* | ||
320 | * the call via dct64 is a trick to force GCC to use | ||
321 | * (new) registers for the b1,b2 pointer to the bufs[xx] field | ||
322 | */ | ||
323 | int mpeg3audio_dct64(mpeg3_real_t *a, mpeg3_real_t *b, mpeg3_real_t *c) | ||
324 | { | ||
325 | mpeg3_real_t bufs[0x40]; | ||
326 | return mpeg3audio_dct64_1(a, b, bufs, bufs + 0x20, c); | ||
327 | } | ||
328 | |||
329 | /*//////////////////////////////////////////////////////////////// */ | ||
330 | /* */ | ||
331 | /* 9 Point Inverse Discrete Cosine Transform */ | ||
332 | /* */ | ||
333 | /* This piece of code is Copyright 1997 Mikko Tommila and is freely usable */ | ||
334 | /* by anybody. The algorithm itself is of course in the public domain. */ | ||
335 | /* */ | ||
336 | /* Again derived heuristically from the 9-point WFTA. */ | ||
337 | /* */ | ||
338 | /* The algorithm is optimized (?) for speed, not for small rounding errors or */ | ||
339 | /* good readability. */ | ||
340 | /* */ | ||
341 | /* 36 additions, 11 multiplications */ | ||
342 | /* */ | ||
343 | /* Again this is very likely sub-optimal. */ | ||
344 | /* */ | ||
345 | /* The code is optimized to use a minimum number of temporary variables, */ | ||
346 | /* so it should compile quite well even on 8-register Intel x86 processors. */ | ||
347 | /* This makes the code quite obfuscated and very difficult to understand. */ | ||
348 | /* */ | ||
349 | /* References: */ | ||
350 | /* [1] S. Winograd: "On Computing the Discrete Fourier Transform", */ | ||
351 | /* Mathematics of Computation, Volume 32, Number 141, January 1978, */ | ||
352 | /* Pages 175-199 */ | ||
353 | |||
354 | |||
355 | /*------------------------------------------------------------------*/ | ||
356 | /* */ | ||
357 | /* Function: Calculation of the inverse MDCT */ | ||
358 | /* */ | ||
359 | /*------------------------------------------------------------------*/ | ||
360 | |||
361 | int mpeg3audio_dct36(mpeg3_real_t *inbuf, mpeg3_real_t *o1, mpeg3_real_t *o2, mpeg3_real_t *wintab, mpeg3_real_t *tsbuf) | ||
362 | { | ||
363 | mpeg3_real_t tmp[18]; | ||
364 | |||
365 | { | ||
366 | register mpeg3_real_t *in = inbuf; | ||
367 | |||
368 | in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; | ||
369 | in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11]; | ||
370 | in[11]+=in[10]; in[10]+=in[9]; in[9] +=in[8]; | ||
371 | in[8] +=in[7]; in[7] +=in[6]; in[6] +=in[5]; | ||
372 | in[5] +=in[4]; in[4] +=in[3]; in[3] +=in[2]; | ||
373 | in[2] +=in[1]; in[1] +=in[0]; | ||
374 | |||
375 | in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9]; | ||
376 | in[9] +=in[7]; in[7] +=in[5]; in[5] +=in[3]; in[3] +=in[1]; | ||
377 | |||
378 | |||
379 | { | ||
380 | mpeg3_real_t t3; | ||
381 | { | ||
382 | mpeg3_real_t t0, t1, t2; | ||
383 | |||
384 | t0 = mpeg3_COS6_2 * (in[8] + in[16] - in[4]); | ||
385 | t1 = mpeg3_COS6_2 * in[12]; | ||
386 | |||
387 | t3 = in[0]; | ||
388 | t2 = t3 - t1 - t1; | ||
389 | tmp[1] = tmp[7] = t2 - t0; | ||
390 | tmp[4] = t2 + t0 + t0; | ||
391 | t3 += t1; | ||
392 | |||
393 | t2 = mpeg3_COS6_1 * (in[10] + in[14] - in[2]); | ||
394 | tmp[1] -= t2; | ||
395 | tmp[7] += t2; | ||
396 | } | ||
397 | { | ||
398 | mpeg3_real_t t0, t1, t2; | ||
399 | |||
400 | t0 = mpeg3_cos9[0] * (in[4] + in[8] ); | ||
401 | t1 = mpeg3_cos9[1] * (in[8] - in[16]); | ||
402 | t2 = mpeg3_cos9[2] * (in[4] + in[16]); | ||
403 | |||
404 | tmp[2] = tmp[6] = t3 - t0 - t2; | ||
405 | tmp[0] = tmp[8] = t3 + t0 + t1; | ||
406 | tmp[3] = tmp[5] = t3 - t1 + t2; | ||
407 | } | ||
408 | } | ||
409 | { | ||
410 | mpeg3_real_t t1, t2, t3; | ||
411 | |||
412 | t1 = mpeg3_cos18[0] * (in[2] + in[10]); | ||
413 | t2 = mpeg3_cos18[1] * (in[10] - in[14]); | ||
414 | t3 = mpeg3_COS6_1 * in[6]; | ||
415 | |||
416 | { | ||
417 | mpeg3_real_t t0 = t1 + t2 + t3; | ||
418 | tmp[0] += t0; | ||
419 | tmp[8] -= t0; | ||
420 | } | ||
421 | |||
422 | t2 -= t3; | ||
423 | t1 -= t3; | ||
424 | |||
425 | t3 = mpeg3_cos18[2] * (in[2] + in[14]); | ||
426 | |||
427 | t1 += t3; | ||
428 | tmp[3] += t1; | ||
429 | tmp[5] -= t1; | ||
430 | |||
431 | t2 -= t3; | ||
432 | tmp[2] += t2; | ||
433 | tmp[6] -= t2; | ||
434 | } | ||
435 | |||
436 | |||
437 | { | ||
438 | mpeg3_real_t t0, t1, t2, t3, t4, t5, t6, t7; | ||
439 | |||
440 | t1 = mpeg3_COS6_2 * in[13]; | ||
441 | t2 = mpeg3_COS6_2 * (in[9] + in[17] - in[5]); | ||
442 | |||
443 | t3 = in[1] + t1; | ||
444 | t4 = in[1] - t1 - t1; | ||
445 | t5 = t4 - t2; | ||
446 | |||
447 | t0 = mpeg3_cos9[0] * (in[5] + in[9]); | ||
448 | t1 = mpeg3_cos9[1] * (in[9] - in[17]); | ||
449 | |||
450 | tmp[13] = (t4 + t2 + t2) * mpeg3_tfcos36[17-13]; | ||
451 | t2 = mpeg3_cos9[2] * (in[5] + in[17]); | ||
452 | |||
453 | t6 = t3 - t0 - t2; | ||
454 | t0 += t3 + t1; | ||
455 | t3 += t2 - t1; | ||
456 | |||
457 | t2 = mpeg3_cos18[0] * (in[3] + in[11]); | ||
458 | t4 = mpeg3_cos18[1] * (in[11] - in[15]); | ||
459 | t7 = mpeg3_COS6_1 * in[7]; | ||
460 | |||
461 | t1 = t2 + t4 + t7; | ||
462 | tmp[17] = (t0 + t1) * mpeg3_tfcos36[17-17]; | ||
463 | tmp[9] = (t0 - t1) * mpeg3_tfcos36[17-9]; | ||
464 | t1 = mpeg3_cos18[2] * (in[3] + in[15]); | ||
465 | t2 += t1 - t7; | ||
466 | |||
467 | tmp[14] = (t3 + t2) * mpeg3_tfcos36[17-14]; | ||
468 | t0 = mpeg3_COS6_1 * (in[11] + in[15] - in[3]); | ||
469 | tmp[12] = (t3 - t2) * mpeg3_tfcos36[17-12]; | ||
470 | |||
471 | t4 -= t1 + t7; | ||
472 | |||
473 | tmp[16] = (t5 - t0) * mpeg3_tfcos36[17-16]; | ||
474 | tmp[10] = (t5 + t0) * mpeg3_tfcos36[17-10]; | ||
475 | tmp[15] = (t6 + t4) * mpeg3_tfcos36[17-15]; | ||
476 | tmp[11] = (t6 - t4) * mpeg3_tfcos36[17-11]; | ||
477 | } | ||
478 | |||
479 | #define MACRO(v) \ | ||
480 | { \ | ||
481 | mpeg3_real_t tmpval; \ | ||
482 | tmpval = tmp[(v)] + tmp[17-(v)]; \ | ||
483 | out2[9+(v)] = tmpval * w[27+(v)]; \ | ||
484 | out2[8-(v)] = tmpval * w[26-(v)]; \ | ||
485 | tmpval = tmp[(v)] - tmp[17-(v)]; \ | ||
486 | ts[SBLIMIT*(8-(v))] = out1[8-(v)] + tmpval * w[8-(v)]; \ | ||
487 | ts[SBLIMIT*(9+(v))] = out1[9+(v)] + tmpval * w[9+(v)]; \ | ||
488 | } | ||
489 | |||
490 | { | ||
491 | register mpeg3_real_t *out2 = o2; | ||
492 | register mpeg3_real_t *w = wintab; | ||
493 | register mpeg3_real_t *out1 = o1; | ||
494 | register mpeg3_real_t *ts = tsbuf; | ||
495 | |||
496 | MACRO(0); | ||
497 | MACRO(1); | ||
498 | MACRO(2); | ||
499 | MACRO(3); | ||
500 | MACRO(4); | ||
501 | MACRO(5); | ||
502 | MACRO(6); | ||
503 | MACRO(7); | ||
504 | MACRO(8); | ||
505 | } | ||
506 | } | ||
507 | return 0; | ||
508 | } | ||
509 | |||
510 | /* | ||
511 | * new DCT12 | ||
512 | */ | ||
513 | int mpeg3audio_dct12(mpeg3_real_t *in,mpeg3_real_t *rawout1,mpeg3_real_t *rawout2,register mpeg3_real_t *wi,register mpeg3_real_t *ts) | ||
514 | { | ||
515 | #define DCT12_PART1 \ | ||
516 | in5 = in[5*3]; \ | ||
517 | in5 += (in4 = in[4*3]); \ | ||
518 | in4 += (in3 = in[3*3]); \ | ||
519 | in3 += (in2 = in[2*3]); \ | ||
520 | in2 += (in1 = in[1*3]); \ | ||
521 | in1 += (in0 = in[0*3]); \ | ||
522 | \ | ||
523 | in5 += in3; in3 += in1; \ | ||
524 | \ | ||
525 | in2 *= mpeg3_COS6_1; \ | ||
526 | in3 *= mpeg3_COS6_1; \ | ||
527 | |||
528 | #define DCT12_PART2 \ | ||
529 | in0 += in4 * mpeg3_COS6_2; \ | ||
530 | \ | ||
531 | in4 = in0 + in2; \ | ||
532 | in0 -= in2; \ | ||
533 | \ | ||
534 | in1 += in5 * mpeg3_COS6_2; \ | ||
535 | \ | ||
536 | in5 = (in1 + in3) * mpeg3_tfcos12[0]; \ | ||
537 | in1 = (in1 - in3) * mpeg3_tfcos12[2]; \ | ||
538 | \ | ||
539 | in3 = in4 + in5; \ | ||
540 | in4 -= in5; \ | ||
541 | \ | ||
542 | in2 = in0 + in1; \ | ||
543 | in0 -= in1; | ||
544 | |||
545 | |||
546 | { | ||
547 | mpeg3_real_t in0,in1,in2,in3,in4,in5; | ||
548 | register mpeg3_real_t *out1 = rawout1; | ||
549 | ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2]; | ||
550 | ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5]; | ||
551 | |||
552 | DCT12_PART1 | ||
553 | |||
554 | { | ||
555 | mpeg3_real_t tmp0,tmp1 = (in0 - in4); | ||
556 | { | ||
557 | mpeg3_real_t tmp2 = (in1 - in5) * mpeg3_tfcos12[1]; | ||
558 | tmp0 = tmp1 + tmp2; | ||
559 | tmp1 -= tmp2; | ||
560 | } | ||
561 | ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1]; | ||
562 | ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1]; | ||
563 | ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1]; | ||
564 | ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1]; | ||
565 | } | ||
566 | |||
567 | DCT12_PART2 | ||
568 | |||
569 | ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0]; | ||
570 | ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0]; | ||
571 | ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2]; | ||
572 | ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2]; | ||
573 | |||
574 | ts[(6+0)*SBLIMIT] = out1[6+0] + in0 * wi[0]; | ||
575 | ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0]; | ||
576 | ts[(6+2)*SBLIMIT] = out1[6+2] + in4 * wi[2]; | ||
577 | ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2]; | ||
578 | } | ||
579 | |||
580 | in++; | ||
581 | |||
582 | { | ||
583 | mpeg3_real_t in0,in1,in2,in3,in4,in5; | ||
584 | register mpeg3_real_t *out2 = rawout2; | ||
585 | |||
586 | DCT12_PART1 | ||
587 | |||
588 | { | ||
589 | mpeg3_real_t tmp0,tmp1 = (in0 - in4); | ||
590 | { | ||
591 | mpeg3_real_t tmp2 = (in1 - in5) * mpeg3_tfcos12[1]; | ||
592 | tmp0 = tmp1 + tmp2; | ||
593 | tmp1 -= tmp2; | ||
594 | } | ||
595 | out2[5-1] = tmp0 * wi[11-1]; | ||
596 | out2[0+1] = tmp0 * wi[6+1]; | ||
597 | ts[(12+1)*SBLIMIT] += tmp1 * wi[1]; | ||
598 | ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1]; | ||
599 | } | ||
600 | |||
601 | DCT12_PART2 | ||
602 | |||
603 | out2[5-0] = in2 * wi[11-0]; | ||
604 | out2[0+0] = in2 * wi[6+0]; | ||
605 | out2[0+2] = in3 * wi[6+2]; | ||
606 | out2[5-2] = in3 * wi[11-2]; | ||
607 | |||
608 | ts[(12+0)*SBLIMIT] += in0 * wi[0]; | ||
609 | ts[(17-0)*SBLIMIT] += in0 * wi[5-0]; | ||
610 | ts[(12+2)*SBLIMIT] += in4 * wi[2]; | ||
611 | ts[(17-2)*SBLIMIT] += in4 * wi[5-2]; | ||
612 | } | ||
613 | |||
614 | in++; | ||
615 | |||
616 | { | ||
617 | mpeg3_real_t in0,in1,in2,in3,in4,in5; | ||
618 | register mpeg3_real_t *out2 = rawout2; | ||
619 | out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0; | ||
620 | |||
621 | DCT12_PART1 | ||
622 | |||
623 | { | ||
624 | mpeg3_real_t tmp0,tmp1 = (in0 - in4); | ||
625 | { | ||
626 | mpeg3_real_t tmp2 = (in1 - in5) * mpeg3_tfcos12[1]; | ||
627 | tmp0 = tmp1 + tmp2; | ||
628 | tmp1 -= tmp2; | ||
629 | } | ||
630 | out2[11-1] = tmp0 * wi[11-1]; | ||
631 | out2[6 +1] = tmp0 * wi[6+1]; | ||
632 | out2[0+1] += tmp1 * wi[1]; | ||
633 | out2[5-1] += tmp1 * wi[5-1]; | ||
634 | } | ||
635 | |||
636 | DCT12_PART2 | ||
637 | |||
638 | out2[11-0] = in2 * wi[11-0]; | ||
639 | out2[6 +0] = in2 * wi[6+0]; | ||
640 | out2[6 +2] = in3 * wi[6+2]; | ||
641 | out2[11-2] = in3 * wi[11-2]; | ||
642 | |||
643 | out2[0+0] += in0 * wi[0]; | ||
644 | out2[5-0] += in0 * wi[5-0]; | ||
645 | out2[0+2] += in4 * wi[2]; | ||
646 | out2[5-2] += in4 * wi[5-2]; | ||
647 | } | ||
648 | return 0; | ||
649 | } | ||
650 | |||
651 | /* AC3 IMDCT tables */ | ||
652 | |||
653 | /* Twiddle factors for IMDCT */ | ||
654 | #if !defined(USE_FIXED_POINT) || defined(PRINT_FIXED_POINT_TABLES) | ||
655 | static mpeg3_real_t mpeg3_xcos1[AC3_N / 4]; | ||
656 | static mpeg3_real_t mpeg3_xsin1[AC3_N / 4]; | ||
657 | static mpeg3_real_t mpeg3_xcos2[AC3_N / 8]; | ||
658 | static mpeg3_real_t mpeg3_xsin2[AC3_N / 8]; | ||
659 | #else | ||
660 | #define USE_FP_TABLES | ||
661 | #include "fptables.h" | ||
662 | #endif | ||
663 | |||
664 | /* 128 point bit-reverse LUT */ | ||
665 | static unsigned char mpeg3_bit_reverse_512[] = | ||
666 | { | ||
667 | 0x00, 0x40, 0x20, 0x60, 0x10, 0x50, 0x30, 0x70, | ||
668 | 0x08, 0x48, 0x28, 0x68, 0x18, 0x58, 0x38, 0x78, | ||
669 | 0x04, 0x44, 0x24, 0x64, 0x14, 0x54, 0x34, 0x74, | ||
670 | 0x0c, 0x4c, 0x2c, 0x6c, 0x1c, 0x5c, 0x3c, 0x7c, | ||
671 | 0x02, 0x42, 0x22, 0x62, 0x12, 0x52, 0x32, 0x72, | ||
672 | 0x0a, 0x4a, 0x2a, 0x6a, 0x1a, 0x5a, 0x3a, 0x7a, | ||
673 | 0x06, 0x46, 0x26, 0x66, 0x16, 0x56, 0x36, 0x76, | ||
674 | 0x0e, 0x4e, 0x2e, 0x6e, 0x1e, 0x5e, 0x3e, 0x7e, | ||
675 | 0x01, 0x41, 0x21, 0x61, 0x11, 0x51, 0x31, 0x71, | ||
676 | 0x09, 0x49, 0x29, 0x69, 0x19, 0x59, 0x39, 0x79, | ||
677 | 0x05, 0x45, 0x25, 0x65, 0x15, 0x55, 0x35, 0x75, | ||
678 | 0x0d, 0x4d, 0x2d, 0x6d, 0x1d, 0x5d, 0x3d, 0x7d, | ||
679 | 0x03, 0x43, 0x23, 0x63, 0x13, 0x53, 0x33, 0x73, | ||
680 | 0x0b, 0x4b, 0x2b, 0x6b, 0x1b, 0x5b, 0x3b, 0x7b, | ||
681 | 0x07, 0x47, 0x27, 0x67, 0x17, 0x57, 0x37, 0x77, | ||
682 | 0x0f, 0x4f, 0x2f, 0x6f, 0x1f, 0x5f, 0x3f, 0x7f | ||
683 | }; | ||
684 | |||
685 | static unsigned char mpeg3_bit_reverse_256[] = | ||
686 | { | ||
687 | 0x00, 0x20, 0x10, 0x30, 0x08, 0x28, 0x18, 0x38, | ||
688 | 0x04, 0x24, 0x14, 0x34, 0x0c, 0x2c, 0x1c, 0x3c, | ||
689 | 0x02, 0x22, 0x12, 0x32, 0x0a, 0x2a, 0x1a, 0x3a, | ||
690 | 0x06, 0x26, 0x16, 0x36, 0x0e, 0x2e, 0x1e, 0x3e, | ||
691 | 0x01, 0x21, 0x11, 0x31, 0x09, 0x29, 0x19, 0x39, | ||
692 | 0x05, 0x25, 0x15, 0x35, 0x0d, 0x2d, 0x1d, 0x3d, | ||
693 | 0x03, 0x23, 0x13, 0x33, 0x0b, 0x2b, 0x1b, 0x3b, | ||
694 | 0x07, 0x27, 0x17, 0x37, 0x0f, 0x2f, 0x1f, 0x3f | ||
695 | }; | ||
696 | |||
697 | /* Windowing function for Modified DCT - Thank you acroread */ | ||
698 | static mpeg3_real_t mpeg3_window[] = | ||
699 | { | ||
700 | 0.00014, 0.00024, 0.00037, 0.00051, 0.00067, 0.00086, 0.00107, 0.00130, | ||
701 | 0.00157, 0.00187, 0.00220, 0.00256, 0.00297, 0.00341, 0.00390, 0.00443, | ||
702 | 0.00501, 0.00564, 0.00632, 0.00706, 0.00785, 0.00871, 0.00962, 0.01061, | ||
703 | 0.01166, 0.01279, 0.01399, 0.01526, 0.01662, 0.01806, 0.01959, 0.02121, | ||
704 | 0.02292, 0.02472, 0.02662, 0.02863, 0.03073, 0.03294, 0.03527, 0.03770, | ||
705 | 0.04025, 0.04292, 0.04571, 0.04862, 0.05165, 0.05481, 0.05810, 0.06153, | ||
706 | 0.06508, 0.06878, 0.07261, 0.07658, 0.08069, 0.08495, 0.08935, 0.09389, | ||
707 | 0.09859, 0.10343, 0.10842, 0.11356, 0.11885, 0.12429, 0.12988, 0.13563, | ||
708 | 0.14152, 0.14757, 0.15376, 0.16011, 0.16661, 0.17325, 0.18005, 0.18699, | ||
709 | 0.19407, 0.20130, 0.20867, 0.21618, 0.22382, 0.23161, 0.23952, 0.24757, | ||
710 | 0.25574, 0.26404, 0.27246, 0.28100, 0.28965, 0.29841, 0.30729, 0.31626, | ||
711 | 0.32533, 0.33450, 0.34376, 0.35311, 0.36253, 0.37204, 0.38161, 0.39126, | ||
712 | 0.40096, 0.41072, 0.42054, 0.43040, 0.44030, 0.45023, 0.46020, 0.47019, | ||
713 | 0.48020, 0.49022, 0.50025, 0.51028, 0.52031, 0.53033, 0.54033, 0.55031, | ||
714 | 0.56026, 0.57019, 0.58007, 0.58991, 0.59970, 0.60944, 0.61912, 0.62873, | ||
715 | 0.63827, 0.64774, 0.65713, 0.66643, 0.67564, 0.68476, 0.69377, 0.70269, | ||
716 | 0.71150, 0.72019, 0.72877, 0.73723, 0.74557, 0.75378, 0.76186, 0.76981, | ||
717 | 0.77762, 0.78530, 0.79283, 0.80022, 0.80747, 0.81457, 0.82151, 0.82831, | ||
718 | 0.83496, 0.84145, 0.84779, 0.85398, 0.86001, 0.86588, 0.87160, 0.87716, | ||
719 | 0.88257, 0.88782, 0.89291, 0.89785, 0.90264, 0.90728, 0.91176, 0.91610, | ||
720 | 0.92028, 0.92432, 0.92822, 0.93197, 0.93558, 0.93906, 0.94240, 0.94560, | ||
721 | 0.94867, 0.95162, 0.95444, 0.95713, 0.95971, 0.96217, 0.96451, 0.96674, | ||
722 | 0.96887, 0.97089, 0.97281, 0.97463, 0.97635, 0.97799, 0.97953, 0.98099, | ||
723 | 0.98236, 0.98366, 0.98488, 0.98602, 0.98710, 0.98811, 0.98905, 0.98994, | ||
724 | 0.99076, 0.99153, 0.99225, 0.99291, 0.99353, 0.99411, 0.99464, 0.99513, | ||
725 | 0.99558, 0.99600, 0.99639, 0.99674, 0.99706, 0.99736, 0.99763, 0.99788, | ||
726 | 0.99811, 0.99831, 0.99850, 0.99867, 0.99882, 0.99895, 0.99908, 0.99919, | ||
727 | 0.99929, 0.99938, 0.99946, 0.99953, 0.99959, 0.99965, 0.99969, 0.99974, | ||
728 | 0.99978, 0.99981, 0.99984, 0.99986, 0.99988, 0.99990, 0.99992, 0.99993, | ||
729 | 0.99994, 0.99995, 0.99996, 0.99997, 0.99998, 0.99998, 0.99998, 0.99999, | ||
730 | 0.99999, 0.99999, 0.99999, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, | ||
731 | 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000 | ||
732 | }; | ||
733 | |||
734 | mpeg3_complex_t cmplx_mult(mpeg3_complex_t a, mpeg3_complex_t b) | ||
735 | { | ||
736 | mpeg3_complex_t ret; | ||
737 | |||
738 | ret.real = a.real * b.real - a.imag * b.imag; | ||
739 | ret.imag = a.real * b.imag + a.imag * b.real; | ||
740 | |||
741 | return ret; | ||
742 | } | ||
743 | |||
744 | int mpeg3audio_imdct_init(mpeg3audio_t *audio) | ||
745 | { | ||
746 | int i, k; | ||
747 | mpeg3_complex_t angle_step; | ||
748 | mpeg3_complex_t current_angle; | ||
749 | |||
750 | /* Twiddle factors to turn IFFT into IMDCT */ | ||
751 | for(i = 0; i < AC3_N / 4; i++) | ||
752 | { | ||
753 | mpeg3_xcos1[i] = -cos(2.0f * M_PI * (8 * i + 1 ) / ( 8 * AC3_N)); | ||
754 | mpeg3_xsin1[i] = -sin(2.0f * M_PI * (8 * i + 1 ) / ( 8 * AC3_N)); | ||
755 | } | ||
756 | |||
757 | /* More twiddle factors to turn IFFT into IMDCT */ | ||
758 | for(i = 0; i < AC3_N / 8; i++) | ||
759 | { | ||
760 | mpeg3_xcos2[i] = -cos(2.0f * M_PI * (8 * i + 1 ) / ( 4 * AC3_N)); | ||
761 | mpeg3_xsin2[i] = -sin(2.0f * M_PI * (8 * i + 1 ) / ( 4 * AC3_N)); | ||
762 | } | ||
763 | |||
764 | /* Canonical twiddle factors for FFT */ | ||
765 | #if defined(USE_FIXED_POINT) && !defined(PRINT_FIXED_POINT_TABLES) | ||
766 | for(i = 0; i < 7; i++) | ||
767 | { | ||
768 | audio->ac3_w[i] = (mpeg3_complex_t*)ac3_w_fixedpoints[i]; | ||
769 | } | ||
770 | #else | ||
771 | audio->ac3_w[0] = audio->ac3_w_1; | ||
772 | audio->ac3_w[1] = audio->ac3_w_2; | ||
773 | audio->ac3_w[2] = audio->ac3_w_4; | ||
774 | audio->ac3_w[3] = audio->ac3_w_8; | ||
775 | audio->ac3_w[4] = audio->ac3_w_16; | ||
776 | audio->ac3_w[5] = audio->ac3_w_32; | ||
777 | audio->ac3_w[6] = audio->ac3_w_64; | ||
778 | |||
779 | for(i = 0; i < 7; i++) | ||
780 | { | ||
781 | angle_step.real = cos(-2.0f * M_PI / (1 << (i + 1))); | ||
782 | angle_step.imag = sin(-2.0f * M_PI / (1 << (i + 1))); | ||
783 | |||
784 | current_angle.real = 1.0f; | ||
785 | current_angle.imag = 0.0f; | ||
786 | |||
787 | for (k = 0; k < 1 << i; k++) | ||
788 | { | ||
789 | audio->ac3_w[i][k] = current_angle; | ||
790 | current_angle = cmplx_mult(current_angle, angle_step); | ||
791 | } | ||
792 | } | ||
793 | |||
794 | #ifdef PRINT_FIXED_POINT_TABLES | ||
795 | printf("#ifdef USE_FP_TABLES\n"); | ||
796 | printf("static long mpeg3_xcos1_fixedpoints[] = {"); | ||
797 | for(i = 0; i < AC3_N / 4; i++) { | ||
798 | printf("%c0x%08x,", i%8?' ':'\n', mpeg3_xcos1[i].fixedPoint()); | ||
799 | } | ||
800 | printf("\n};\nstatic mpeg3_real_t *mpeg3_xcos1 = \n" | ||
801 | "(mpeg3_real_t*)mpeg3_xcos1_fixedpoints;\n"); | ||
802 | |||
803 | printf("static long mpeg3_xsin1_fixedpoints[] = {"); | ||
804 | for(i = 0; i < AC3_N / 4; i++) { | ||
805 | printf("%c0x%08x,", i%8?' ':'\n', mpeg3_xsin1[i].fixedPoint()); | ||
806 | } | ||
807 | printf("\n};\nstatic mpeg3_real_t *mpeg3_xsin1 = \n" | ||
808 | "(mpeg3_real_t*)mpeg3_xsin1_fixedpoints;\n"); | ||
809 | |||
810 | |||
811 | printf("static long mpeg3_xcos2_fixedpoints[] = {"); | ||
812 | for(i = 0; i < AC3_N / 4; i++) { | ||
813 | printf("%c0x%08x,", i%8?' ':'\n', mpeg3_xcos2[i].fixedPoint()); | ||
814 | } | ||
815 | printf("\n};\nstatic mpeg3_real_t *mpeg3_xcos2 = \n" | ||
816 | "(mpeg3_real_t*)mpeg3_xcos2_fixedpoints;\n"); | ||
817 | |||
818 | printf("static long mpeg3_xsin2_fixedpoints[] = {"); | ||
819 | for(i = 0; i < AC3_N / 4; i++) { | ||
820 | printf("%c0x%08x,", i%8?' ':'\n', mpeg3_xsin2[i].fixedPoint()); | ||
821 | } | ||
822 | printf("\n};\nstatic mpeg3_real_t *mpeg3_xsin2 = \n" | ||
823 | "(mpeg3_real_t*)mpeg3_xsin2_fixedpoints;\n"); | ||
824 | |||
825 | |||
826 | printf("typedef struct { long r, i; } fixed_cmplx;\n"); | ||
827 | for(i = 0; i < 7; i++) | ||
828 | { | ||
829 | printf("fixed_cmplx ac3_w_d%d[] = { ", 1<<i); | ||
830 | for (k = 0; k < 1 << i; k++) | ||
831 | { | ||
832 | printf("%s{ 0x%08x, 0x%08x },", k%4?" ":"\n ", | ||
833 | audio->ac3_w[i][k].real.fixedPoint(), | ||
834 | audio->ac3_w[i][k].imag.fixedPoint()); | ||
835 | } | ||
836 | printf("};\n"); | ||
837 | } | ||
838 | |||
839 | printf("fixed_cmplx *ac3_w_fixedpoints[] = {\n"); | ||
840 | for(i = 0; i < 7; i++) | ||
841 | { | ||
842 | printf("ac3_w_d%d, ", 1<<i); | ||
843 | } | ||
844 | printf("};\n"); | ||
845 | printf("#endif\n"); | ||
846 | #endif | ||
847 | #endif | ||
848 | |||
849 | return 0; | ||
850 | } | ||
851 | |||
852 | |||
853 | inline void swap_cmplx(mpeg3_complex_t *a, mpeg3_complex_t *b) | ||
854 | { | ||
855 | mpeg3_complex_t tmp; | ||
856 | |||
857 | tmp = *a; | ||
858 | *a = *b; | ||
859 | *b = tmp; | ||
860 | } | ||
861 | |||
862 | void mpeg3audio_ac3_imdct_do_512(mpeg3audio_t *audio, | ||
863 | mpeg3_real_t data[], | ||
864 | mpeg3_real_t *y, | ||
865 | int step, | ||
866 | mpeg3_real_t *delay) | ||
867 | { | ||
868 | int i, k; | ||
869 | int p, q; | ||
870 | int m; | ||
871 | int two_m; | ||
872 | int two_m_plus_one; | ||
873 | |||
874 | mpeg3_real_t tmp_a_i; | ||
875 | mpeg3_real_t tmp_a_r; | ||
876 | mpeg3_real_t tmp_b_i; | ||
877 | mpeg3_real_t tmp_b_r; | ||
878 | |||
879 | mpeg3_real_t *y_ptr; | ||
880 | mpeg3_real_t *delay_ptr; | ||
881 | mpeg3_real_t *window_ptr; | ||
882 | mpeg3_complex_t *buf = audio->ac3_imdct_buf; | ||
883 | |||
884 | /* Pre IFFT complex multiply plus IFFT cmplx conjugate */ | ||
885 | for(i = 0; i < AC3_N / 4; i++) | ||
886 | { | ||
887 | buf[i].real = (data[AC3_N / 2 - 2 * i - 1] * mpeg3_xcos1[i]) - (data[2 * i] * mpeg3_xsin1[i]); | ||
888 | buf[i].imag = -((data[2 * i] * mpeg3_xcos1[i]) + (data[AC3_N / 2 - 2 * i - 1] * mpeg3_xsin1[i])); | ||
889 | } | ||
890 | |||
891 | /* Bit reversed shuffling */ | ||
892 | for(i = 0; i < AC3_N / 4; i++) | ||
893 | { | ||
894 | k = mpeg3_bit_reverse_512[i]; | ||
895 | if(k < i) | ||
896 | swap_cmplx(&buf[i], &buf[k]); | ||
897 | } | ||
898 | |||
899 | /* FFT Merge */ | ||
900 | for(m = 0; m < 7; m++) | ||
901 | { | ||
902 | if(m) | ||
903 | two_m = (1 << m); | ||
904 | else | ||
905 | two_m = 1; | ||
906 | |||
907 | two_m_plus_one = (1 << (m + 1)); | ||
908 | |||
909 | for(k = 0; k < two_m; k++) | ||
910 | { | ||
911 | for(i = 0; i < AC3_N / 4; i += two_m_plus_one) | ||
912 | { | ||
913 | p = k + i; | ||
914 | q = p + two_m; | ||
915 | tmp_a_r = buf[p].real; | ||
916 | tmp_a_i = buf[p].imag; | ||
917 | tmp_b_r = buf[q].real * audio->ac3_w[m][k].real - buf[q].imag * audio->ac3_w[m][k].imag; | ||
918 | tmp_b_i = buf[q].imag * audio->ac3_w[m][k].real + buf[q].real * audio->ac3_w[m][k].imag; | ||
919 | buf[p].real = tmp_a_r + tmp_b_r; | ||
920 | buf[p].imag = tmp_a_i + tmp_b_i; | ||
921 | buf[q].real = tmp_a_r - tmp_b_r; | ||
922 | buf[q].imag = tmp_a_i - tmp_b_i; | ||
923 | } | ||
924 | } | ||
925 | } | ||
926 | |||
927 | /* Post IFFT complex multiply plus IFFT complex conjugate*/ | ||
928 | for(i = 0; i < AC3_N / 4; i++) | ||
929 | { | ||
930 | tmp_a_r = buf[i].real; | ||
931 | tmp_a_i = -buf[i].imag; | ||
932 | buf[i].real = (tmp_a_r * mpeg3_xcos1[i]) - (tmp_a_i * mpeg3_xsin1[i]); | ||
933 | buf[i].imag = (tmp_a_r * mpeg3_xsin1[i]) + (tmp_a_i * mpeg3_xcos1[i]); | ||
934 | } | ||
935 | |||
936 | y_ptr = y; | ||
937 | delay_ptr = delay; | ||
938 | window_ptr = mpeg3_window; | ||
939 | |||
940 | /* Window and convert to real valued signal */ | ||
941 | for(i = 0; i < AC3_N / 8; i++) | ||
942 | { | ||
943 | *y_ptr = -buf[AC3_N / 8 + i].imag * *window_ptr++ + *delay_ptr++; | ||
944 | y_ptr += step; | ||
945 | *y_ptr = buf[AC3_N / 8 - i - 1].real * *window_ptr++ + *delay_ptr++; | ||
946 | y_ptr += step; | ||
947 | } | ||
948 | |||
949 | for(i = 0; i < AC3_N / 8; i++) | ||
950 | { | ||
951 | *y_ptr = -buf[i].real * *window_ptr++ + *delay_ptr++; | ||
952 | y_ptr += step; | ||
953 | *y_ptr = buf[AC3_N / 4 - i - 1].imag * *window_ptr++ + *delay_ptr++; | ||
954 | y_ptr += step; | ||
955 | } | ||
956 | |||
957 | /* The trailing edge of the window goes into the delay line */ | ||
958 | delay_ptr = delay; | ||
959 | |||
960 | for(i = 0; i < AC3_N / 8; i++) | ||
961 | { | ||
962 | *delay_ptr++ = -buf[AC3_N / 8 + i].real * *--window_ptr; | ||
963 | *delay_ptr++ = buf[AC3_N / 8 - i - 1].imag * *--window_ptr; | ||
964 | } | ||
965 | |||
966 | for(i = 0; i < AC3_N / 8; i++) | ||
967 | { | ||
968 | *delay_ptr++ = buf[i].imag * *--window_ptr; | ||
969 | *delay_ptr++ = -buf[AC3_N / 4 - i - 1].real * *--window_ptr; | ||
970 | } | ||
971 | } | ||
972 | |||
973 | void mpeg3audio_ac3_imdct_do_256(mpeg3audio_t *audio, | ||
974 | mpeg3_real_t data[], | ||
975 | mpeg3_real_t *y, | ||
976 | int step, | ||
977 | mpeg3_real_t *delay) | ||
978 | { | ||
979 | int i, k; | ||
980 | int p, q; | ||
981 | int m; | ||
982 | int two_m; | ||
983 | int two_m_plus_one; | ||
984 | mpeg3_complex_t *buf = audio->ac3_imdct_buf; | ||
985 | mpeg3_real_t *y_ptr; | ||
986 | mpeg3_real_t *delay_ptr; | ||
987 | mpeg3_real_t *window_ptr; | ||
988 | |||
989 | mpeg3_real_t tmp_a_i; | ||
990 | mpeg3_real_t tmp_a_r; | ||
991 | mpeg3_real_t tmp_b_i; | ||
992 | mpeg3_real_t tmp_b_r; | ||
993 | |||
994 | mpeg3_complex_t *buf_1, *buf_2; | ||
995 | |||
996 | buf_1 = &buf[0]; | ||
997 | buf_2 = &buf[64]; | ||
998 | |||
999 | /* Pre IFFT complex multiply plus IFFT cmplx conjugate */ | ||
1000 | for(k = 0; k < AC3_N / 8; k++) | ||
1001 | { | ||
1002 | p = 2 * (AC3_N / 4 - 2 * k - 1); | ||
1003 | q = 2 * (2 * k); | ||
1004 | |||
1005 | buf_1[k].real = data[p] * mpeg3_xcos2[k] - data[q] * mpeg3_xsin2[k]; | ||
1006 | buf_1[k].imag = - (data[q] * mpeg3_xcos2[k] + data[p] * mpeg3_xsin2[k]); | ||
1007 | buf_2[k].real = data[p + 1] * mpeg3_xcos2[k] - data[q + 1] * mpeg3_xsin2[k]; | ||
1008 | buf_2[k].imag = - (data[q + 1] * mpeg3_xcos2[k] + data[p + 1] * mpeg3_xsin2[k]); | ||
1009 | } | ||
1010 | |||
1011 | /* IFFT Bit reversed shuffling */ | ||
1012 | for(i = 0; i < AC3_N / 8; i++) | ||
1013 | { | ||
1014 | k = mpeg3_bit_reverse_256[i]; | ||
1015 | if(k < i) | ||
1016 | { | ||
1017 | swap_cmplx(&buf_1[i], &buf_1[k]); | ||
1018 | swap_cmplx(&buf_2[i], &buf_2[k]); | ||
1019 | } | ||
1020 | } | ||
1021 | |||
1022 | /* FFT Merge */ | ||
1023 | for(m = 0; m < 6; m++) | ||
1024 | { | ||
1025 | if(m) | ||
1026 | two_m = (1 << m); | ||
1027 | else | ||
1028 | two_m = 1; | ||
1029 | |||
1030 | two_m_plus_one = (1 << (m + 1)); | ||
1031 | |||
1032 | for(k = 0; k < two_m; k++) | ||
1033 | { | ||
1034 | for(i = 0; i < AC3_N / 8; i += two_m_plus_one) | ||
1035 | { | ||
1036 | p = k + i; | ||
1037 | q = p + two_m; | ||
1038 | /* Do block 1 */ | ||
1039 | tmp_a_r = buf_1[p].real; | ||
1040 | tmp_a_i = buf_1[p].imag; | ||
1041 | tmp_b_r = buf_1[q].real * audio->ac3_w[m][k].real - buf_1[q].imag * audio->ac3_w[m][k].imag; | ||
1042 | tmp_b_i = buf_1[q].imag * audio->ac3_w[m][k].real + buf_1[q].real * audio->ac3_w[m][k].imag; | ||
1043 | buf_1[p].real = tmp_a_r + tmp_b_r; | ||
1044 | buf_1[p].imag = tmp_a_i + tmp_b_i; | ||
1045 | buf_1[q].real = tmp_a_r - tmp_b_r; | ||
1046 | buf_1[q].imag = tmp_a_i - tmp_b_i; | ||
1047 | |||
1048 | /* Do block 2 */ | ||
1049 | tmp_a_r = buf_2[p].real; | ||
1050 | tmp_a_i = buf_2[p].imag; | ||
1051 | tmp_b_r = buf_2[q].real * audio->ac3_w[m][k].real - buf_2[q].imag * audio->ac3_w[m][k].imag; | ||
1052 | tmp_b_i = buf_2[q].imag * audio->ac3_w[m][k].real + buf_2[q].real * audio->ac3_w[m][k].imag; | ||
1053 | buf_2[p].real = tmp_a_r + tmp_b_r; | ||
1054 | buf_2[p].imag = tmp_a_i + tmp_b_i; | ||
1055 | buf_2[q].real = tmp_a_r - tmp_b_r; | ||
1056 | buf_2[q].imag = tmp_a_i - tmp_b_i; | ||
1057 | } | ||
1058 | } | ||
1059 | } | ||
1060 | |||
1061 | /* Post IFFT complex multiply */ | ||
1062 | for(i = 0; i < AC3_N / 8; i++) | ||
1063 | { | ||
1064 | tmp_a_r = buf_1[i].real; | ||
1065 | tmp_a_i = -buf_1[i].imag; | ||
1066 | buf_1[i].real = (tmp_a_r * mpeg3_xcos2[i]) - (tmp_a_i * mpeg3_xsin2[i]); | ||
1067 | buf_1[i].imag = (tmp_a_r * mpeg3_xsin2[i]) + (tmp_a_i * mpeg3_xcos2[i]); | ||
1068 | tmp_a_r = buf_2[i].real; | ||
1069 | tmp_a_i = -buf_2[i].imag; | ||
1070 | buf_2[i].real = (tmp_a_r * mpeg3_xcos2[i]) - (tmp_a_i * mpeg3_xsin2[i]); | ||
1071 | buf_2[i].imag = (tmp_a_r * mpeg3_xsin2[i]) + (tmp_a_i * mpeg3_xcos2[i]); | ||
1072 | } | ||
1073 | |||
1074 | /* Window and convert to real valued signal */ | ||
1075 | y_ptr = y; | ||
1076 | delay_ptr = delay; | ||
1077 | window_ptr = mpeg3_window; | ||
1078 | |||
1079 | for(i = 0; i < AC3_N / 8; i++) | ||
1080 | { | ||
1081 | *y_ptr = -buf[AC3_N / 8 + i].imag * *window_ptr++ + *delay_ptr++; | ||
1082 | y_ptr += step; | ||
1083 | *y_ptr = buf[AC3_N / 8 - i - 1].real * *window_ptr++ + *delay_ptr++; | ||
1084 | y_ptr += step; | ||
1085 | } | ||
1086 | |||
1087 | for(i = 0; i < AC3_N / 8; i++) | ||
1088 | { | ||
1089 | *y_ptr = -buf[i].real * *window_ptr++ + *delay_ptr++; | ||
1090 | y_ptr += step; | ||
1091 | *y_ptr = buf[AC3_N / 4 - i - 1].imag * *window_ptr++ + *delay_ptr++; | ||
1092 | y_ptr += step; | ||
1093 | } | ||
1094 | |||
1095 | /* The trailing edge of the window goes into the delay line */ | ||
1096 | delay_ptr = delay; | ||
1097 | |||
1098 | for(i = 0; i < AC3_N / 8; i++) | ||
1099 | { | ||
1100 | *delay_ptr++ = -buf[AC3_N / 8 + i].real * *--window_ptr; | ||
1101 | *delay_ptr++ = buf[AC3_N / 8 - i - 1].imag * *--window_ptr; | ||
1102 | } | ||
1103 | |||
1104 | for(i = 0; i < AC3_N / 8; i++) | ||
1105 | { | ||
1106 | *delay_ptr++ = buf[i].imag * *--window_ptr; | ||
1107 | *delay_ptr++ = -buf[AC3_N / 4 - i - 1].real * *--window_ptr; | ||
1108 | } | ||
1109 | } | ||
1110 | |||
1111 | int mpeg3audio_ac3_imdct(mpeg3audio_t *audio, | ||
1112 | mpeg3_ac3bsi_t *bsi, | ||
1113 | mpeg3_ac3audblk_t *audblk, | ||
1114 | mpeg3ac3_stream_samples_t samples) | ||
1115 | { | ||
1116 | int i; | ||
1117 | |||
1118 | for(i = 0; i < bsi->nfchans; i++) | ||
1119 | { | ||
1120 | if(audblk->blksw[i]) | ||
1121 | mpeg3audio_ac3_imdct_do_256(audio, | ||
1122 | samples[i], | ||
1123 | audio->pcm_sample + audio->pcm_point + i, | ||
1124 | bsi->nfchans, | ||
1125 | audio->ac3_delay[i]); | ||
1126 | else | ||
1127 | mpeg3audio_ac3_imdct_do_512(audio, | ||
1128 | samples[i], | ||
1129 | audio->pcm_sample + audio->pcm_point + i, | ||
1130 | bsi->nfchans, | ||
1131 | audio->ac3_delay[i]); | ||
1132 | } | ||
1133 | audio->pcm_point += AC3_N / 2 * bsi->nfchans; | ||
1134 | return 0; | ||
1135 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/exponents.c b/core/multimedia/opieplayer/libmpeg3/audio/exponents.c new file mode 100644 index 0000000..deda9b9 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/exponents.c | |||
@@ -0,0 +1,141 @@ | |||
1 | /* | ||
2 | * | ||
3 | *exponents.c Copyright (C) Aaron Holtzman - May 1999 | ||
4 | * | ||
5 | * This file is part of libmpeg3 | ||
6 | * | ||
7 | * libmpeg3 is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2, or (at your option) | ||
10 | * any later version. | ||
11 | * | ||
12 | * libmpeg3 is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with GNU Make; see the file COPYING. If not, write to | ||
19 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | ||
20 | * | ||
21 | */ | ||
22 | |||
23 | #include "mpeg3audio.h" | ||
24 | #include "../libmpeg3.h" | ||
25 | #include "../mpeg3protos.h" | ||
26 | #include <stdio.h> | ||
27 | |||
28 | /* Exponent defines */ | ||
29 | #define UNPACK_FBW 1 | ||
30 | #define UNPACK_CPL 2 | ||
31 | #define UNPACK_LFE 4 | ||
32 | |||
33 | static inline int mpeg3audio_ac3_exp_unpack_ch(unsigned int type, | ||
34 | unsigned int expstr, | ||
35 | unsigned int ngrps, | ||
36 | unsigned int initial_exp, | ||
37 | unsigned short exps[], | ||
38 | unsigned short *dest) | ||
39 | { | ||
40 | int i, j; | ||
41 | int exp_acc; | ||
42 | int exp_1, exp_2, exp_3; | ||
43 | |||
44 | if(expstr == MPEG3_EXP_REUSE) | ||
45 | return 0; | ||
46 | |||
47 | /* Handle the initial absolute exponent */ | ||
48 | exp_acc = initial_exp; | ||
49 | j = 0; | ||
50 | |||
51 | /* In the case of a fbw channel then the initial absolute value is | ||
52 | * also an exponent */ | ||
53 | if(type != UNPACK_CPL) | ||
54 | dest[j++] = exp_acc; | ||
55 | |||
56 | /* Loop through the groups and fill the dest array appropriately */ | ||
57 | for(i = 0; i < ngrps; i++) | ||
58 | { | ||
59 | if(exps[i] > 124) | ||
60 | { | ||
61 | fprintf(stderr, "mpeg3audio_ac3_exp_unpack_ch: Invalid exponent %d\n", exps[i]); | ||
62 | return 1; | ||
63 | } | ||
64 | |||
65 | exp_1 = exps[i] / 25; | ||
66 | exp_2 = (exps[i] % 25) / 5; | ||
67 | exp_3 = (exps[i] % 25) % 5; | ||
68 | |||
69 | exp_acc += (exp_1 - 2); | ||
70 | |||
71 | switch(expstr) | ||
72 | { | ||
73 | case MPEG3_EXP_D45: | ||
74 | dest[j++] = exp_acc; | ||
75 | dest[j++] = exp_acc; | ||
76 | case MPEG3_EXP_D25: | ||
77 | dest[j++] = exp_acc; | ||
78 | case MPEG3_EXP_D15: | ||
79 | dest[j++] = exp_acc; | ||
80 | } | ||
81 | |||
82 | exp_acc += (exp_2 - 2); | ||
83 | |||
84 | switch(expstr) | ||
85 | { | ||
86 | case MPEG3_EXP_D45: | ||
87 | dest[j++] = exp_acc; | ||
88 | dest[j++] = exp_acc; | ||
89 | case MPEG3_EXP_D25: | ||
90 | dest[j++] = exp_acc; | ||
91 | case MPEG3_EXP_D15: | ||
92 | dest[j++] = exp_acc; | ||
93 | } | ||
94 | |||
95 | exp_acc += (exp_3 - 2); | ||
96 | |||
97 | switch(expstr) | ||
98 | { | ||
99 | case MPEG3_EXP_D45: | ||
100 | dest[j++] = exp_acc; | ||
101 | dest[j++] = exp_acc; | ||
102 | case MPEG3_EXP_D25: | ||
103 | dest[j++] = exp_acc; | ||
104 | case MPEG3_EXP_D15: | ||
105 | dest[j++] = exp_acc; | ||
106 | } | ||
107 | } | ||
108 | return 0; | ||
109 | } | ||
110 | |||
111 | int mpeg3audio_ac3_exponent_unpack(mpeg3audio_t *audio, | ||
112 | mpeg3_ac3bsi_t *bsi, | ||
113 | mpeg3_ac3audblk_t *audblk) | ||
114 | { | ||
115 | int i, result = 0; | ||
116 | |||
117 | for(i = 0; i < bsi->nfchans; i++) | ||
118 | result |= mpeg3audio_ac3_exp_unpack_ch(UNPACK_FBW, | ||
119 | audblk->chexpstr[i], | ||
120 | audblk->nchgrps[i], | ||
121 | audblk->exps[i][0], | ||
122 | &audblk->exps[i][1], | ||
123 | audblk->fbw_exp[i]); | ||
124 | |||
125 | if(audblk->cplinu && !result) | ||
126 | result |= mpeg3audio_ac3_exp_unpack_ch(UNPACK_CPL, | ||
127 | audblk->cplexpstr, | ||
128 | audblk->ncplgrps, | ||
129 | audblk->cplabsexp << 1, | ||
130 | audblk->cplexps, | ||
131 | &audblk->cpl_exp[audblk->cplstrtmant]); | ||
132 | |||
133 | if(bsi->lfeon && !result) | ||
134 | result |= mpeg3audio_ac3_exp_unpack_ch(UNPACK_LFE, | ||
135 | audblk->lfeexpstr, | ||
136 | 2, | ||
137 | audblk->lfeexps[0], | ||
138 | &audblk->lfeexps[1], | ||
139 | audblk->lfe_exp); | ||
140 | return result; | ||
141 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/fptables.h b/core/multimedia/opieplayer/libmpeg3/audio/fptables.h new file mode 100644 index 0000000..2836984 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/fptables.h | |||
@@ -0,0 +1,1556 @@ | |||
1 | #ifdef USE_FP_TABLES | ||
2 | static long mpeg3_xcos1_fixedpoints[] = { | ||
3 | 0xffff8001, 0xffff8004, 0xffff800c, 0xffff8019, 0xffff802a, 0xffff8041, 0xffff805d, 0xffff807e, | ||
4 | 0xffff80a3, 0xffff80ce, 0xffff80fd, 0xffff8131, 0xffff816b, 0xffff81a9, 0xffff81ec, 0xffff8233, | ||
5 | 0xffff8280, 0xffff82d1, 0xffff8328, 0xffff8383, 0xffff83e3, 0xffff8447, 0xffff84b1, 0xffff851f, | ||
6 | 0xffff8592, 0xffff860a, 0xffff8686, 0xffff8707, 0xffff878d, 0xffff8817, 0xffff88a6, 0xffff893a, | ||
7 | 0xffff89d2, 0xffff8a6f, 0xffff8b10, 0xffff8bb6, 0xffff8c60, 0xffff8d0f, 0xffff8dc2, 0xffff8e7a, | ||
8 | 0xffff8f35, 0xffff8ff6, 0xffff90ba, 0xffff9183, 0xffff9250, 0xffff9322, 0xffff93f7, 0xffff94d1, | ||
9 | 0xffff95af, 0xffff9691, 0xffff9777, 0xffff9861, 0xffff994f, 0xffff9a41, 0xffff9b37, 0xffff9c31, | ||
10 | 0xffff9d2e, 0xffff9e30, 0xffff9f35, 0xffffa03e, 0xffffa14b, 0xffffa25b, 0xffffa36f, 0xffffa487, | ||
11 | 0xffffa5a2, 0xffffa6c0, 0xffffa7e2, 0xffffa907, 0xffffaa30, 0xffffab5c, 0xffffac8b, 0xffffadbe, | ||
12 | 0xffffaef4, 0xffffb02c, 0xffffb168, 0xffffb2a7, 0xffffb3e9, 0xffffb52e, 0xffffb676, 0xffffb7c0, | ||
13 | 0xffffb90d, 0xffffba5d, 0xffffbbb0, 0xffffbd06, 0xffffbe5e, 0xffffbfb8, 0xffffc115, 0xffffc274, | ||
14 | 0xffffc3d6, 0xffffc53a, 0xffffc6a1, 0xffffc809, 0xffffc974, 0xffffcae1, 0xffffcc50, 0xffffcdc0, | ||
15 | 0xffffcf33, 0xffffd0a8, 0xffffd21e, 0xffffd397, 0xffffd511, 0xffffd68c, 0xffffd80a, 0xffffd988, | ||
16 | 0xffffdb09, 0xffffdc8a, 0xffffde0d, 0xffffdf92, 0xffffe117, 0xffffe29e, 0xffffe426, 0xffffe5af, | ||
17 | 0xffffe739, 0xffffe8c4, 0xffffea50, 0xffffebdd, 0xffffed6a, 0xffffeef8, 0xfffff087, 0xfffff217, | ||
18 | 0xfffff3a7, 0xfffff537, 0xfffff6c8, 0xfffff859, 0xfffff9eb, 0xfffffb7d, 0xfffffd0f, 0xfffffea1, | ||
19 | }; | ||
20 | static mpeg3_real_t *mpeg3_xcos1 = | ||
21 | (mpeg3_real_t*)mpeg3_xcos1_fixedpoints; | ||
22 | static long mpeg3_xsin1_fixedpoints[] = { | ||
23 | 0xffffffce, 0xfffffe3c, 0xfffffcaa, 0xfffffb18, 0xfffff986, 0xfffff7f5, 0xfffff664, 0xfffff4d3, | ||
24 | 0xfffff343, 0xfffff1b3, 0xfffff023, 0xffffee95, 0xffffed07, 0xffffeb79, 0xffffe9ed, 0xffffe861, | ||
25 | 0xffffe6d6, 0xffffe54d, 0xffffe3c4, 0xffffe23c, 0xffffe0b6, 0xffffdf30, 0xffffddac, 0xffffdc2a, | ||
26 | 0xffffdaa8, 0xffffd928, 0xffffd7aa, 0xffffd62d, 0xffffd4b2, 0xffffd338, 0xffffd1c1, 0xffffd04b, | ||
27 | 0xffffced6, 0xffffcd64, 0xffffcbf4, 0xffffca85, 0xffffc919, 0xffffc7af, 0xffffc647, 0xffffc4e1, | ||
28 | 0xffffc37d, 0xffffc21c, 0xffffc0bd, 0xffffbf61, 0xffffbe07, 0xffffbcb0, 0xffffbb5b, 0xffffba09, | ||
29 | 0xffffb8ba, 0xffffb76d, 0xffffb623, 0xffffb4dc, 0xffffb398, 0xffffb257, 0xffffb119, 0xffffafde, | ||
30 | 0xffffaea6, 0xffffad71, 0xffffac3f, 0xffffab11, 0xffffa9e6, 0xffffa8be, 0xffffa799, 0xffffa678, | ||
31 | 0xffffa55b, 0xffffa440, 0xffffa32a, 0xffffa217, 0xffffa107, 0xffff9ffc, 0xffff9ef3, 0xffff9def, | ||
32 | 0xffff9cef, 0xffff9bf2, 0xffff9af9, 0xffff9a04, 0xffff9913, 0xffff9826, 0xffff973d, 0xffff9658, | ||
33 | 0xffff9577, 0xffff949a, 0xffff93c1, 0xffff92ed, 0xffff921d, 0xffff9151, 0xffff9089, 0xffff8fc5, | ||
34 | 0xffff8f06, 0xffff8e4b, 0xffff8d95, 0xffff8ce3, 0xffff8c35, 0xffff8b8c, 0xffff8ae7, 0xffff8a47, | ||
35 | 0xffff89ac, 0xffff8915, 0xffff8882, 0xffff87f4, 0xffff876b, 0xffff86e7, 0xffff8667, 0xffff85eb, | ||
36 | 0xffff8575, 0xffff8503, 0xffff8496, 0xffff842e, 0xffff83ca, 0xffff836c, 0xffff8312, 0xffff82bd, | ||
37 | 0xffff826c, 0xffff8221, 0xffff81da, 0xffff8199, 0xffff815c, 0xffff8124, 0xffff80f1, 0xffff80c3, | ||
38 | 0xffff8099, 0xffff8075, 0xffff8056, 0xffff803b, 0xffff8026, 0xffff8015, 0xffff8009, 0xffff8002, | ||
39 | }; | ||
40 | static mpeg3_real_t *mpeg3_xsin1 = | ||
41 | (mpeg3_real_t*)mpeg3_xsin1_fixedpoints; | ||
42 | static long mpeg3_xcos2_fixedpoints[] = { | ||
43 | 0xffff8001, 0xffff800d, 0xffff802d, 0xffff8061, 0xffff80a8, 0xffff8103, 0xffff8172, 0xffff81f4, | ||
44 | 0xffff828a, 0xffff8333, 0xffff83ef, 0xffff84be, 0xffff85a1, 0xffff8696, 0xffff879e, 0xffff88b9, | ||
45 | 0xffff89e5, 0xffff8b25, 0xffff8c76, 0xffff8dd9, 0xffff8f4d, 0xffff90d3, 0xffff926a, 0xffff9412, | ||
46 | 0xffff95cb, 0xffff9794, 0xffff996d, 0xffff9b56, 0xffff9d4e, 0xffff9f56, 0xffffa16d, 0xffffa392, | ||
47 | 0xffffa5c5, 0xffffa807, 0xffffaa55, 0xffffacb2, 0xffffaf1b, 0xffffb190, 0xffffb411, 0xffffb69f, | ||
48 | 0xffffb937, 0xffffbbdb, 0xffffbe89, 0xffffc141, 0xffffc403, 0xffffc6ce, 0xffffc9a1, 0xffffcc7e, | ||
49 | 0xffffcf62, 0xffffd24d, 0xffffd540, 0xffffd839, 0xffffdb39, 0xffffde3e, 0xffffe148, 0xffffe457, | ||
50 | 0xffffe76a, 0xffffea81, 0xffffed9c, 0xfffff0b9, 0xfffff3d9, 0xfffff6fa, 0xfffffa1d, 0xfffffd41, | ||
51 | 0xffffff9c, 0xfffffc78, 0xfffff954, 0xfffff632, 0xfffff311, 0xffffeff2, 0xffffecd5, 0xffffe9bb, | ||
52 | 0xffffe6a5, 0xffffe393, 0xffffe085, 0xffffdd7c, 0xffffda78, 0xffffd77a, 0xffffd483, 0xffffd192, | ||
53 | 0xffffcea8, 0xffffcbc6, 0xffffc8ec, 0xffffc61a, 0xffffc351, 0xffffc092, 0xffffbddc, 0xffffbb31, | ||
54 | 0xffffb890, 0xffffb5fa, 0xffffb370, 0xffffb0f1, 0xffffae7f, 0xffffac19, 0xffffa9c0, 0xffffa775, | ||
55 | 0xffffa537, 0xffffa307, 0xffffa0e6, 0xffff9ed3, 0xffff9ccf, 0xffff9ada, 0xffff98f5, 0xffff9720, | ||
56 | 0xffff955b, 0xffff93a7, 0xffff9203, 0xffff9070, 0xffff8eee, 0xffff8d7e, 0xffff8c20, 0xffff8ad3, | ||
57 | 0xffff8998, 0xffff8870, 0xffff875a, 0xffff8657, 0xffff8566, 0xffff8489, 0xffff83be, 0xffff8307, | ||
58 | 0xffff8263, 0xffff81d2, 0xffff8155, 0xffff80eb, 0xffff8095, 0xffff8052, 0xffff8023, 0xffff8008, | ||
59 | }; | ||
60 | static mpeg3_real_t *mpeg3_xcos2 = | ||
61 | (mpeg3_real_t*)mpeg3_xcos2_fixedpoints; | ||
62 | static long mpeg3_xsin2_fixedpoints[] = { | ||
63 | 0xffffff9c, 0xfffffc78, 0xfffff954, 0xfffff632, 0xfffff311, 0xffffeff2, 0xffffecd5, 0xffffe9bb, | ||
64 | 0xffffe6a5, 0xffffe393, 0xffffe085, 0xffffdd7c, 0xffffda78, 0xffffd77a, 0xffffd483, 0xffffd192, | ||
65 | 0xffffcea8, 0xffffcbc6, 0xffffc8ec, 0xffffc61a, 0xffffc351, 0xffffc092, 0xffffbddc, 0xffffbb31, | ||
66 | 0xffffb890, 0xffffb5fa, 0xffffb370, 0xffffb0f1, 0xffffae7f, 0xffffac19, 0xffffa9c0, 0xffffa775, | ||
67 | 0xffffa537, 0xffffa307, 0xffffa0e6, 0xffff9ed3, 0xffff9ccf, 0xffff9ada, 0xffff98f5, 0xffff9720, | ||
68 | 0xffff955b, 0xffff93a7, 0xffff9203, 0xffff9070, 0xffff8eee, 0xffff8d7e, 0xffff8c20, 0xffff8ad3, | ||
69 | 0xffff8998, 0xffff8870, 0xffff875a, 0xffff8657, 0xffff8566, 0xffff8489, 0xffff83be, 0xffff8307, | ||
70 | 0xffff8263, 0xffff81d2, 0xffff8155, 0xffff80eb, 0xffff8095, 0xffff8052, 0xffff8023, 0xffff8008, | ||
71 | 0x00000004, 0x00000007, 0x0000000c, 0x00000010, 0x00000015, 0x0000001c, 0x00000023, 0x0000002a, | ||
72 | 0x00000033, 0x0000003d, 0x00000048, 0x00000053, 0x00000061, 0x0000006f, 0x0000007f, 0x00000091, | ||
73 | 0x000000a4, 0x000000b8, 0x000000cf, 0x000000e7, 0x00000101, 0x0000011d, 0x0000013b, 0x0000015b, | ||
74 | 0x0000017e, 0x000001a3, 0x000001ca, 0x000001f4, 0x00000220, 0x0000024f, 0x00000281, 0x000002b7, | ||
75 | 0x000002ef, 0x0000032a, 0x00000368, 0x000003aa, 0x000003ee, 0x00000437, 0x00000483, 0x000004d3, | ||
76 | 0x00000526, 0x0000057e, 0x000005d9, 0x00000639, 0x0000069c, 0x00000704, 0x0000076f, 0x000007e0, | ||
77 | 0x00000854, 0x000008cd, 0x0000094b, 0x000009cd, 0x00000a54, 0x00000adf, 0x00000b6f, 0x00000c04, | ||
78 | 0x00000c9e, 0x00000d3d, 0x00000de0, 0x00000e89, 0x00000f36, 0x00000fe8, 0x0000109f, 0x0000115c, | ||
79 | }; | ||
80 | static mpeg3_real_t *mpeg3_xsin2 = | ||
81 | (mpeg3_real_t*)mpeg3_xsin2_fixedpoints; | ||
82 | typedef struct { long r, i; } fixed_cmplx; | ||
83 | fixed_cmplx ac3_w_d1[] = { | ||
84 | { 0x00008000, 0x00000000 },}; | ||
85 | fixed_cmplx ac3_w_d2[] = { | ||
86 | { 0x00008000, 0x00000000 }, { 0x00000000, 0xffff8000 },}; | ||
87 | fixed_cmplx ac3_w_d4[] = { | ||
88 | { 0x00008000, 0x00000000 }, { 0x00005a82, 0xffffa57e }, { 0x00000000, 0xffff8002 }, { 0xffffa580, 0xffffa580 },}; | ||
89 | fixed_cmplx ac3_w_d8[] = { | ||
90 | { 0x00008000, 0x00000000 }, { 0x00007641, 0xffffcf05 }, { 0x00005a81, 0xffffa580 }, { 0x000030fb, 0xffff89c4 }, | ||
91 | { 0x00000002, 0xffff8007 }, { 0xffffcf09, 0xffff89c6 }, { 0xffffa587, 0xffffa583 }, { 0xffff89cb, 0xffffcf05 },}; | ||
92 | fixed_cmplx ac3_w_d16[] = { | ||
93 | { 0x00008000, 0x00000000 }, { 0x00007d8a, 0xffffe708 }, { 0x00007642, 0xffffcf06 }, { 0x00006a6e, 0xffffb8e7 }, | ||
94 | { 0x00005a84, 0xffffa583 }, { 0x00004720, 0xffff9599 }, { 0x00003100, 0xffff89c6 }, { 0x000018ff, 0xffff827e }, | ||
95 | { 0x00000008, 0xffff8008 }, { 0xffffe711, 0xffff827d }, { 0xffffcf11, 0xffff89c4 }, { 0xffffb8f2, 0xffff9595 }, | ||
96 | { 0xffffa58e, 0xffffa57d }, { 0xffff95a5, 0xffffb8df }, { 0xffff89d2, 0xffffcefd }, { 0xffff8289, 0xffffe6fc },}; | ||
97 | fixed_cmplx ac3_w_d32[] = { | ||
98 | { 0x00008000, 0x00000000 }, { 0x00007f62, 0xfffff375 }, { 0x00007d8a, 0xffffe70a }, { 0x00007a7d, 0xffffdadc }, | ||
99 | { 0x00007642, 0xffffcf0a }, { 0x000070e4, 0xffffc3b1 }, { 0x00006a70, 0xffffb8ed }, { 0x000062f6, 0xffffaed7 }, | ||
100 | { 0x00005a88, 0xffffa58a }, { 0x0000513b, 0xffff9d1b }, { 0x00004726, 0xffff95a1 }, { 0x00003c62, 0xffff8f2d }, | ||
101 | { 0x00003109, 0xffff89cf }, { 0x00002538, 0xffff8593 }, { 0x0000190b, 0xffff8286 }, { 0x00000ca1, 0xffff80ad }, | ||
102 | { 0x00000017, 0xffff800f }, { 0xfffff38d, 0xffff80ab }, { 0xffffe723, 0xffff8281 }, { 0xffffdaf6, 0xffff858b }, | ||
103 | { 0xffffcf25, 0xffff89c4 }, { 0xffffc3cc, 0xffff8f1f }, { 0xffffb908, 0xffff9591 }, { 0xffffaef3, 0xffff9d09 }, | ||
104 | { 0xffffa5a6, 0xffffa575 }, { 0xffff9d37, 0xffffaebf }, { 0xffff95bb, 0xffffb8d2 }, { 0xffff8f46, 0xffffc393 }, | ||
105 | { 0xffff89e7, 0xffffcee9 }, { 0xffff85aa, 0xffffdab8 }, { 0xffff829b, 0xffffe6e3 }, { 0xffff80c1, 0xfffff34b },}; | ||
106 | fixed_cmplx ac3_w_d64[] = { | ||
107 | { 0x00008000, 0x00000000 }, { 0x00007fd8, 0xfffff9b9 }, { 0x00007f62, 0xfffff376 }, { 0x00007e9d, 0xffffed3b }, | ||
108 | { 0x00007d8a, 0xffffe70c }, { 0x00007c29, 0xffffe0ec }, { 0x00007a7c, 0xffffdae0 }, { 0x00007883, 0xffffd4eb }, | ||
109 | { 0x00007641, 0xffffcf11 }, { 0x000073b6, 0xffffc955 }, { 0x000070e3, 0xffffc3bb }, { 0x00006dcb, 0xffffbe45 }, | ||
110 | { 0x00006a6f, 0xffffb8f8 }, { 0x000066d2, 0xffffb3d7 }, { 0x000062f5, 0xffffaee5 }, { 0x00005edc, 0xffffaa25 }, | ||
111 | { 0x00005a89, 0xffffa59a }, { 0x000055fe, 0xffffa147 }, { 0x0000513e, 0xffff9d2e }, { 0x00004c4c, 0xffff9952 }, | ||
112 | { 0x0000472b, 0xffff95b6 }, { 0x000041de, 0xffff925b }, { 0x00003c69, 0xffff8f44 }, { 0x000036cf, 0xffff8c72 }, | ||
113 | { 0x00003113, 0xffff89e7 }, { 0x00002b39, 0xffff87a4 }, { 0x00002544, 0xffff85ac }, { 0x00001f39, 0xffff8400 }, | ||
114 | { 0x0000191b, 0xffff82a0 }, { 0x000012ed, 0xffff818d }, { 0x00000cb4, 0xffff80c8 }, { 0x00000673, 0xffff8051 }, | ||
115 | { 0x0000002d, 0xffff8029 }, { 0xfffff9e8, 0xffff804f }, { 0xfffff3a7, 0xffff80c3 }, { 0xffffed6e, 0xffff8186 }, | ||
116 | { 0xffffe741, 0xffff8297 }, { 0xffffe123, 0xffff83f5 }, { 0xffffdb18, 0xffff859f }, { 0xffffd524, 0xffff8795 }, | ||
117 | { 0xffffcf4b, 0xffff89d5 }, { 0xffffc990, 0xffff8c5d }, { 0xffffc3f7, 0xffff8f2d }, { 0xffffbe82, 0xffff9242 }, | ||
118 | { 0xffffb936, 0xffff959b }, { 0xffffb416, 0xffff9935 }, { 0xffffaf24, 0xffff9d0f }, { 0xffffaa64, 0xffffa125 }, | ||
119 | { 0xffffa5d9, 0xffffa575 }, { 0xffffa186, 0xffffa9fd }, { 0xffff9d6d, 0xffffaeba }, { 0xffff9990, 0xffffb3a9 }, | ||
120 | { 0xffff95f3, 0xffffb8c7 }, { 0xffff9297, 0xffffbe11 }, { 0xffff8f7f, 0xffffc383 }, { 0xffff8cac, 0xffffc91a }, | ||
121 | { 0xffff8a20, 0xffffced3 }, { 0xffff87dc, 0xffffd4aa }, { 0xffff85e2, 0xffffda9c }, { 0xffff8434, 0xffffe0a5 }, | ||
122 | { 0xffff82d2, 0xffffe6c1 }, { 0xffff81be, 0xffffecec }, { 0xffff80f7, 0xfffff323 }, { 0xffff807e, 0xfffff962 },}; | ||
123 | fixed_cmplx *ac3_w_fixedpoints[] = { | ||
124 | ac3_w_d1, ac3_w_d2, ac3_w_d4, ac3_w_d8, ac3_w_d16, ac3_w_d32, ac3_w_d64, }; | ||
125 | #endif | ||
126 | #ifdef USE_DATA_TABLES | ||
127 | static long mpeg3_muls_data[] = { | ||
128 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
129 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
130 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
131 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
132 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
133 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
134 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
135 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
136 | 0xffff5556, 0xffff788b, 0xffff947d, 0xffffaaab, 0xffffbc46, 0xffffca3f, 0xffffd556, 0xffffde23, | ||
137 | 0xffffe520, 0xffffeaab, 0xffffef12, 0xfffff290, 0xfffff556, 0xfffff789, 0xfffff948, 0xfffffaab, | ||
138 | 0xfffffbc5, 0xfffffca4, 0xfffffd56, 0xfffffde3, 0xfffffe52, 0xfffffeab, 0xfffffef2, 0xffffff29, | ||
139 | 0xffffff56, 0xffffff79, 0xffffff95, 0xffffffab, 0xffffffbd, 0xffffffcb, 0xffffffd6, 0xffffffdf, | ||
140 | 0xffffffe6, 0xffffffeb, 0xfffffff0, 0xfffffff3, 0xfffffff6, 0xfffffff8, 0xfffffffa, 0xfffffffb, | ||
141 | 0xfffffffc, 0xfffffffd, 0xfffffffe, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, | ||
142 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
143 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
144 | 0x0000aaaa, 0x00008775, 0x00006b83, 0x00005555, 0x000043ba, 0x000035c1, 0x00002aaa, 0x000021dd, | ||
145 | 0x00001ae0, 0x00001555, 0x000010ee, 0x00000d70, 0x00000aaa, 0x00000877, 0x000006b8, 0x00000555, | ||
146 | 0x0000043b, 0x0000035c, 0x000002aa, 0x0000021d, 0x000001ae, 0x00000155, 0x0000010e, 0x000000d7, | ||
147 | 0x000000aa, 0x00000087, 0x0000006b, 0x00000055, 0x00000043, 0x00000035, 0x0000002a, 0x00000021, | ||
148 | 0x0000001a, 0x00000015, 0x00000010, 0x0000000d, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, | ||
149 | 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, | ||
150 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
151 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
152 | 0x00004924, 0x00003a0d, 0x00002e13, 0x00002492, 0x00001d06, 0x00001709, 0x00001249, 0x00000e83, | ||
153 | 0x00000b84, 0x00000924, 0x00000741, 0x000005c2, 0x00000492, 0x000003a0, 0x000002e1, 0x00000249, | ||
154 | 0x000001d0, 0x00000170, 0x00000124, 0x000000e8, 0x000000b8, 0x00000092, 0x00000074, 0x0000005c, | ||
155 | 0x00000049, 0x0000003a, 0x0000002e, 0x00000024, 0x0000001d, 0x00000017, 0x00000012, 0x0000000e, | ||
156 | 0x0000000b, 0x00000009, 0x00000007, 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, | ||
157 | 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
158 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
159 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
160 | 0x00002222, 0x00001b17, 0x00001580, 0x00001111, 0x00000d8b, 0x00000ac0, 0x00000888, 0x000006c5, | ||
161 | 0x00000560, 0x00000444, 0x00000362, 0x000002b0, 0x00000222, 0x000001b1, 0x00000158, 0x00000111, | ||
162 | 0x000000d8, 0x000000ac, 0x00000088, 0x0000006c, 0x00000056, 0x00000044, 0x00000036, 0x0000002b, | ||
163 | 0x00000022, 0x0000001b, 0x00000015, 0x00000011, 0x0000000d, 0x0000000a, 0x00000008, 0x00000006, | ||
164 | 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, | ||
165 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
166 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
167 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
168 | 0x00001084, 0x00000d1b, 0x00000a67, 0x00000842, 0x0000068d, 0x00000533, 0x00000421, 0x00000346, | ||
169 | 0x00000299, 0x00000210, 0x000001a3, 0x0000014c, 0x00000108, 0x000000d1, 0x000000a6, 0x00000084, | ||
170 | 0x00000068, 0x00000053, 0x00000042, 0x00000034, 0x00000029, 0x00000021, 0x0000001a, 0x00000014, | ||
171 | 0x00000010, 0x0000000d, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, | ||
172 | 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, | ||
173 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
174 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
175 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
176 | 0x00000820, 0x00000673, 0x0000051e, 0x00000410, 0x00000339, 0x0000028f, 0x00000208, 0x0000019c, | ||
177 | 0x00000147, 0x00000104, 0x000000ce, 0x000000a3, 0x00000082, 0x00000067, 0x00000051, 0x00000041, | ||
178 | 0x00000033, 0x00000028, 0x00000020, 0x00000019, 0x00000014, 0x00000010, 0x0000000c, 0x0000000a, | ||
179 | 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, | ||
180 | 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
181 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
182 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
183 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
184 | 0x00000408, 0x00000333, 0x0000028a, 0x00000204, 0x00000199, 0x00000145, 0x00000102, 0x000000cc, | ||
185 | 0x000000a2, 0x00000081, 0x00000066, 0x00000051, 0x00000040, 0x00000033, 0x00000028, 0x00000020, | ||
186 | 0x00000019, 0x00000014, 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, | ||
187 | 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, | ||
188 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
189 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
190 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
191 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
192 | 0x00000202, 0x00000197, 0x00000143, 0x00000101, 0x000000cb, 0x000000a1, 0x00000080, 0x00000065, | ||
193 | 0x00000050, 0x00000040, 0x00000032, 0x00000028, 0x00000020, 0x00000019, 0x00000014, 0x00000010, | ||
194 | 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, 0x00000002, | ||
195 | 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
196 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
197 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
198 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
199 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
200 | 0x00000100, 0x000000cb, 0x000000a1, 0x00000080, 0x00000065, 0x00000050, 0x00000040, 0x00000032, | ||
201 | 0x00000028, 0x00000020, 0x00000019, 0x00000014, 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, | ||
202 | 0x00000006, 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, | ||
203 | 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
204 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
205 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
206 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
207 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
208 | 0x00000080, 0x00000065, 0x00000050, 0x00000040, 0x00000032, 0x00000028, 0x00000020, 0x00000019, | ||
209 | 0x00000014, 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, 0x00000004, | ||
210 | 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, | ||
211 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
212 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
213 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
214 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
215 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
216 | 0x00000040, 0x00000032, 0x00000028, 0x00000020, 0x00000019, 0x00000014, 0x00000010, 0x0000000c, | ||
217 | 0x0000000a, 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, | ||
218 | 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
219 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
220 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
221 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
222 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
223 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
224 | 0x00000020, 0x00000019, 0x00000014, 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, | ||
225 | 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, | ||
226 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
227 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
228 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
229 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
230 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
231 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
232 | 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, | ||
233 | 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, | ||
234 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
235 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
236 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
237 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
238 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
239 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
240 | 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, | ||
241 | 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
242 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
243 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
244 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
245 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
246 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
247 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
248 | 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, | ||
249 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
250 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
251 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
252 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
253 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
254 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
255 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
256 | 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
257 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
258 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
259 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
260 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
261 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
262 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
263 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
264 | 0xffff3334, 0xffff5d74, 0xffff7efc, 0xffff999a, 0xffffaeba, 0xffffbf7e, 0xffffcccd, 0xffffd75d, | ||
265 | 0xffffdfbf, 0xffffe667, 0xffffebaf, 0xffffefe0, 0xfffff334, 0xfffff5d8, 0xfffff7f0, 0xfffff99a, | ||
266 | 0xfffffaec, 0xfffffbf8, 0xfffffccd, 0xfffffd76, 0xfffffdfc, 0xfffffe67, 0xfffffebb, 0xfffffefe, | ||
267 | 0xffffff34, 0xffffff5e, 0xffffff7f, 0xffffff9a, 0xffffffaf, 0xffffffc0, 0xffffffcd, 0xffffffd8, | ||
268 | 0xffffffe0, 0xffffffe7, 0xffffffec, 0xfffffff0, 0xfffffff4, 0xfffffff6, 0xfffffff8, 0xfffffffa, | ||
269 | 0xfffffffb, 0xfffffffc, 0xfffffffd, 0xfffffffe, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, | ||
270 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
271 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
272 | 0xffff999a, 0xffffaeba, 0xffffbf7e, 0xffffcccd, 0xffffd75d, 0xffffdfbf, 0xffffe667, 0xffffebaf, | ||
273 | 0xffffefe0, 0xfffff334, 0xfffff5d8, 0xfffff7f0, 0xfffff99a, 0xfffffaec, 0xfffffbf8, 0xfffffccd, | ||
274 | 0xfffffd76, 0xfffffdfc, 0xfffffe67, 0xfffffebb, 0xfffffefe, 0xffffff34, 0xffffff5e, 0xffffff7f, | ||
275 | 0xffffff9a, 0xffffffaf, 0xffffffc0, 0xffffffcd, 0xffffffd8, 0xffffffe0, 0xffffffe7, 0xffffffec, | ||
276 | 0xfffffff0, 0xfffffff4, 0xfffffff6, 0xfffffff8, 0xfffffffa, 0xfffffffb, 0xfffffffc, 0xfffffffd, | ||
277 | 0xfffffffe, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, | ||
278 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
279 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
280 | 0x00006666, 0x00005146, 0x00004082, 0x00003333, 0x000028a3, 0x00002041, 0x00001999, 0x00001451, | ||
281 | 0x00001020, 0x00000ccc, 0x00000a28, 0x00000810, 0x00000666, 0x00000514, 0x00000408, 0x00000333, | ||
282 | 0x0000028a, 0x00000204, 0x00000199, 0x00000145, 0x00000102, 0x000000cc, 0x000000a2, 0x00000081, | ||
283 | 0x00000066, 0x00000051, 0x00000040, 0x00000033, 0x00000028, 0x00000020, 0x00000019, 0x00000014, | ||
284 | 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, 0x00000005, 0x00000004, 0x00000003, | ||
285 | 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, | ||
286 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
287 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
288 | 0x0000cccc, 0x0000a28c, 0x00008104, 0x00006666, 0x00005146, 0x00004082, 0x00003333, 0x000028a3, | ||
289 | 0x00002041, 0x00001999, 0x00001451, 0x00001020, 0x00000ccc, 0x00000a28, 0x00000810, 0x00000666, | ||
290 | 0x00000514, 0x00000408, 0x00000333, 0x0000028a, 0x00000204, 0x00000199, 0x00000145, 0x00000102, | ||
291 | 0x000000cc, 0x000000a2, 0x00000081, 0x00000066, 0x00000051, 0x00000040, 0x00000033, 0x00000028, | ||
292 | 0x00000020, 0x00000019, 0x00000014, 0x00000010, 0x0000000c, 0x0000000a, 0x00000008, 0x00000006, | ||
293 | 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, | ||
294 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
295 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
296 | 0xffff1c72, 0xffff4b64, 0xffff70a7, 0xffff8e39, 0xffffa5b2, 0xffffb854, 0xffffc71d, 0xffffd2d9, | ||
297 | 0xffffdc2a, 0xffffe38f, 0xffffe96d, 0xffffee15, 0xfffff1c8, 0xfffff4b7, 0xfffff70b, 0xfffff8e4, | ||
298 | 0xfffffa5c, 0xfffffb86, 0xfffffc72, 0xfffffd2e, 0xfffffdc3, 0xfffffe39, 0xfffffe97, 0xfffffee2, | ||
299 | 0xffffff1d, 0xffffff4c, 0xffffff71, 0xffffff8f, 0xffffffa6, 0xffffffb9, 0xffffffc8, 0xffffffd3, | ||
300 | 0xffffffdd, 0xffffffe4, 0xffffffea, 0xffffffef, 0xfffffff2, 0xfffffff5, 0xfffffff8, 0xfffffff9, | ||
301 | 0xfffffffb, 0xfffffffc, 0xfffffffd, 0xfffffffe, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, | ||
302 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
303 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
304 | 0xffff8e39, 0xffffa5b2, 0xffffb854, 0xffffc71d, 0xffffd2d9, 0xffffdc2a, 0xffffe38f, 0xffffe96d, | ||
305 | 0xffffee15, 0xfffff1c8, 0xfffff4b7, 0xfffff70b, 0xfffff8e4, 0xfffffa5c, 0xfffffb86, 0xfffffc72, | ||
306 | 0xfffffd2e, 0xfffffdc3, 0xfffffe39, 0xfffffe97, 0xfffffee2, 0xffffff1d, 0xffffff4c, 0xffffff71, | ||
307 | 0xffffff8f, 0xffffffa6, 0xffffffb9, 0xffffffc8, 0xffffffd3, 0xffffffdd, 0xffffffe4, 0xffffffea, | ||
308 | 0xffffffef, 0xfffffff2, 0xfffffff5, 0xfffffff8, 0xfffffff9, 0xfffffffb, 0xfffffffc, 0xfffffffd, | ||
309 | 0xfffffffe, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, | ||
310 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
311 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
312 | 0xffffc71d, 0xffffd2d9, 0xffffdc2a, 0xffffe38f, 0xffffe96d, 0xffffee15, 0xfffff1c8, 0xfffff4b7, | ||
313 | 0xfffff70b, 0xfffff8e4, 0xfffffa5c, 0xfffffb86, 0xfffffc72, 0xfffffd2e, 0xfffffdc3, 0xfffffe39, | ||
314 | 0xfffffe97, 0xfffffee2, 0xffffff1d, 0xffffff4c, 0xffffff71, 0xffffff8f, 0xffffffa6, 0xffffffb9, | ||
315 | 0xffffffc8, 0xffffffd3, 0xffffffdd, 0xffffffe4, 0xffffffea, 0xffffffef, 0xfffffff2, 0xfffffff5, | ||
316 | 0xfffffff8, 0xfffffff9, 0xfffffffb, 0xfffffffc, 0xfffffffd, 0xfffffffe, 0xfffffffe, 0xffffffff, | ||
317 | 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
318 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
319 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
320 | 0x000038e3, 0x00002d27, 0x000023d6, 0x00001c71, 0x00001693, 0x000011eb, 0x00000e38, 0x00000b49, | ||
321 | 0x000008f5, 0x0000071c, 0x000005a4, 0x0000047a, 0x0000038e, 0x000002d2, 0x0000023d, 0x000001c7, | ||
322 | 0x00000169, 0x0000011e, 0x000000e3, 0x000000b4, 0x0000008f, 0x00000071, 0x0000005a, 0x00000047, | ||
323 | 0x00000038, 0x0000002d, 0x00000023, 0x0000001c, 0x00000016, 0x00000011, 0x0000000e, 0x0000000b, | ||
324 | 0x00000008, 0x00000007, 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, | ||
325 | 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
326 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
327 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
328 | 0x000071c7, 0x00005a4e, 0x000047ac, 0x000038e3, 0x00002d27, 0x000023d6, 0x00001c71, 0x00001693, | ||
329 | 0x000011eb, 0x00000e38, 0x00000b49, 0x000008f5, 0x0000071c, 0x000005a4, 0x0000047a, 0x0000038e, | ||
330 | 0x000002d2, 0x0000023d, 0x000001c7, 0x00000169, 0x0000011e, 0x000000e3, 0x000000b4, 0x0000008f, | ||
331 | 0x00000071, 0x0000005a, 0x00000047, 0x00000038, 0x0000002d, 0x00000023, 0x0000001c, 0x00000016, | ||
332 | 0x00000011, 0x0000000e, 0x0000000b, 0x00000008, 0x00000007, 0x00000005, 0x00000004, 0x00000003, | ||
333 | 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, | ||
334 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
335 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
336 | 0x0000e38e, 0x0000b49c, 0x00008f59, 0x000071c7, 0x00005a4e, 0x000047ac, 0x000038e3, 0x00002d27, | ||
337 | 0x000023d6, 0x00001c71, 0x00001693, 0x000011eb, 0x00000e38, 0x00000b49, 0x000008f5, 0x0000071c, | ||
338 | 0x000005a4, 0x0000047a, 0x0000038e, 0x000002d2, 0x0000023d, 0x000001c7, 0x00000169, 0x0000011e, | ||
339 | 0x000000e3, 0x000000b4, 0x0000008f, 0x00000071, 0x0000005a, 0x00000047, 0x00000038, 0x0000002d, | ||
340 | 0x00000023, 0x0000001c, 0x00000016, 0x00000011, 0x0000000e, 0x0000000b, 0x00000008, 0x00000007, | ||
341 | 0x00000005, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000001, 0x00000001, 0x00000001, | ||
342 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
343 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,}; | ||
344 | #endif | ||
345 | #ifdef USE_DATA_TABLES | ||
346 | static long mpeg3_gainpow2_data[] = { | ||
347 | 0x05a82799, 0x04c1bf82, 0x04000000, 0x035d13f3, 0x02d413cc, 0x0260dfc1, 0x02000000, 0x01ae89f9, | ||
348 | 0x016a09e6, 0x01306fe0, 0x01000000, 0x00d744fc, 0x00b504f3, 0x009837f0, 0x00800000, 0x006ba27e, | ||
349 | 0x005a8279, 0x004c1bf8, 0x00400000, 0x0035d13f, 0x002d413c, 0x00260dfc, 0x00200000, 0x001ae89f, | ||
350 | 0x0016a09e, 0x001306fe, 0x00100000, 0x000d744f, 0x000b504f, 0x0009837f, 0x00080000, 0x0006ba27, | ||
351 | 0x0005a827, 0x0004c1bf, 0x00040000, 0x00035d13, 0x0002d413, 0x000260df, 0x00020000, 0x0001ae89, | ||
352 | 0x00016a09, 0x0001306f, 0x00010000, 0x0000d744, 0x0000b504, 0x00009837, 0x00008000, 0x00006ba2, | ||
353 | 0x00005a82, 0x00004c1b, 0x00004000, 0x000035d1, 0x00002d41, 0x0000260d, 0x00002000, 0x00001ae8, | ||
354 | 0x000016a0, 0x00001306, 0x00001000, 0x00000d74, 0x00000b50, 0x00000983, 0x00000800, 0x000006ba, | ||
355 | 0x000005a8, 0x000004c1, 0x00000400, 0x0000035d, 0x000002d4, 0x00000260, 0x00000200, 0x000001ae, | ||
356 | 0x0000016a, 0x00000130, 0x00000100, 0x000000d7, 0x000000b5, 0x00000098, 0x00000080, 0x0000006b, | ||
357 | 0x0000005a, 0x0000004c, 0x00000040, 0x00000035, 0x0000002d, 0x00000026, 0x00000020, 0x0000001a, | ||
358 | 0x00000016, 0x00000013, 0x00000010, 0x0000000d, 0x0000000b, 0x00000009, 0x00000008, 0x00000006, | ||
359 | 0x00000005, 0x00000004, 0x00000004, 0x00000003, 0x00000002, 0x00000002, 0x00000002, 0x00000001, | ||
360 | 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
361 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
362 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
363 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
364 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
365 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
366 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
367 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
368 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
369 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
370 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
371 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
372 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
373 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
374 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
375 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
376 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
377 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
378 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
379 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
380 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
381 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
382 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
383 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
384 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
385 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
386 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
387 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
388 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
389 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
390 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
391 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
392 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
393 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
394 | 0x00000000, 0x00000000,}; | ||
395 | #endif | ||
396 | #ifdef USE_DATA_TABLES | ||
397 | static long mpeg3_ispow_data[] = { | ||
398 | 0x00000000, 0x00008000, 0x0001428a, 0x000229d2, 0x00032cbf, 0x00044662, 0x0005738c, 0x0006b1fc, | ||
399 | 0x0007ffff, 0x00095c41, 0x000ac5ad, 0x000c3b5d, 0x000dbc8f, 0x000f489e, 0x0010def9, 0x00127f20, | ||
400 | 0x001428a2, 0x0015db1b, 0x00179630, 0x0019598d, 0x001b24e8, 0x001cf7fc, 0x001ed28a, 0x0020b458, | ||
401 | 0x00229d2e, 0x00248cdb, 0x0026832f, 0x00287fff, 0x002a8322, 0x002c8c70, 0x002e9bc5, 0x0030b0ff, | ||
402 | 0x0032cbfd, 0x0034eca0, 0x003712ca, 0x00393e60, 0x003b6f47, 0x003da567, 0x003fe0a5, 0x004220ed, | ||
403 | 0x00446627, 0x0046b03e, 0x0048ff1e, 0x004b52b3, 0x004daaeb, 0x005007b4, 0x005268fc, 0x0054ceb2, | ||
404 | 0x005738c7, 0x0059a72a, 0x005c19cd, 0x005e90a1, 0x00610b98, 0x00638aa4, 0x00660db9, 0x006894c9, | ||
405 | 0x006b1fc8, 0x006daeaa, 0x00704163, 0x0072d7e8, 0x0075722e, 0x0078102b, 0x007ab1d3, 0x007d571e, | ||
406 | 0x007fffff, 0x0082ac70, 0x00855c65, 0x00880fd6, 0x008ac6b9, 0x008d8107, 0x00903eb7, 0x0092ffc0, | ||
407 | 0x0095c41a, 0x00988bbe, 0x009b56a4, 0x009e24c4, 0x00a0f617, 0x00a3ca96, 0x00a6a239, 0x00a97cfa, | ||
408 | 0x00ac5ad2, 0x00af3bbb, 0x00b21fad, 0x00b506a3, 0x00b7f096, 0x00badd81, 0x00bdcd5d, 0x00c0c025, | ||
409 | 0x00c3b5d2, 0x00c6ae60, 0x00c9a9c8, 0x00cca805, 0x00cfa912, 0x00d2acea, 0x00d5b387, 0x00d8bce5, | ||
410 | 0x00dbc8fe, 0x00ded7ce, 0x00e1e950, 0x00e4fd7e, 0x00e81456, 0x00eb2dd1, 0x00ee49ec, 0x00f168a2, | ||
411 | 0x00f489ef, 0x00f7adce, 0x00fad43c, 0x00fdfd34, 0x010128b2, 0x010456b2, 0x01078731, 0x010aba29, | ||
412 | 0x010def99, 0x0111277b, 0x011461cc, 0x01179e89, 0x011addae, 0x011e1f37, 0x01216320, 0x0124a967, | ||
413 | 0x0127f208, 0x012b3d00, 0x012e8a4b, 0x0131d9e6, 0x01352bce, 0x01387fff, 0x013bd678, 0x013f2f33, | ||
414 | 0x01428a2f, 0x0145e768, 0x014946dc, 0x014ca888, 0x01500c68, 0x01537279, 0x0156daba, 0x015a4527, | ||
415 | 0x015db1bd, 0x0161207a, 0x0164915b, 0x0168045d, 0x016b797e, 0x016ef0bb, 0x01726a12, 0x0175e580, | ||
416 | 0x01796302, 0x017ce297, 0x0180643b, 0x0183e7ec, 0x01876da9, 0x018af56e, 0x018e7f38, 0x01920b07, | ||
417 | 0x019598d8, 0x019928a8, 0x019cba74, 0x01a04e3c, 0x01a3e3fd, 0x01a77bb4, 0x01ab155f, 0x01aeb0fd, | ||
418 | 0x01b24e8b, 0x01b5ee07, 0x01b98f70, 0x01bd32c2, 0x01c0d7fc, 0x01c47f1d, 0x01c82821, 0x01cbd308, | ||
419 | 0x01cf7fcf, 0x01d32e74, 0x01d6def6, 0x01da9153, 0x01de4588, 0x01e1fb94, 0x01e5b375, 0x01e96d29, | ||
420 | 0x01ed28af, 0x01f0e604, 0x01f4a528, 0x01f86617, 0x01fc28d2, 0x01ffed55, 0x0203b39f, 0x02077baf, | ||
421 | 0x020b4582, 0x020f1118, 0x0212de6e, 0x0216ad83, 0x021a7e56, 0x021e50e4, 0x0222252d, 0x0225fb2e, | ||
422 | 0x0229d2e6, 0x022dac54, 0x02318776, 0x0235644b, 0x023942d1, 0x023d2306, 0x024104e9, 0x0244e879, | ||
423 | 0x0248cdb5, 0x024cb49a, 0x02509d28, 0x0254875c, 0x02587337, 0x025c60b5, 0x02604fd7, 0x0264409a, | ||
424 | 0x026832fd, 0x026c26ff, 0x02701c9f, 0x027413db, 0x02780cb1, 0x027c0722, 0x0280032a, 0x028400ca, | ||
425 | 0x0287ffff, 0x028c00ca, 0x02900327, 0x02940716, 0x02980c97, 0x029c13a7, 0x02a01c45, 0x02a42670, | ||
426 | 0x02a83228, 0x02ac3f6a, 0x02b04e36, 0x02b45e8b, 0x02b87067, 0x02bc83c9, 0x02c098b1, 0x02c4af1c, | ||
427 | 0x02c8c70a, 0x02cce07a, 0x02d0fb6a, 0x02d517da, 0x02d935c9, 0x02dd5534, 0x02e1761c, 0x02e59880, | ||
428 | 0x02e9bc5d, 0x02ede1b3, 0x02f20882, 0x02f630c8, 0x02fa5a83, 0x02fe85b4, 0x0302b258, 0x0306e070, | ||
429 | 0x030b0ff9, 0x030f40f3, 0x0313735e, 0x0317a737, 0x031bdc7e, 0x03201333, 0x03244b53, 0x032884de, | ||
430 | 0x032cbfd4, 0x0330fc33, 0x033539fa, 0x03397929, 0x033db9be, 0x0341fbb8, 0x03463f17, 0x034a83da, | ||
431 | 0x034eca00, 0x03531187, 0x03575a6f, 0x035ba4b8, 0x035ff060, 0x03643d66, 0x03688bc9, 0x036cdb8a, | ||
432 | 0x03712ca6, 0x03757f1d, 0x0379d2ee, 0x037e2818, 0x03827e9a, 0x0386d674, 0x038b2fa5, 0x038f8a2c, | ||
433 | 0x0393e608, 0x03984338, 0x039ca1bc, 0x03a10192, 0x03a562ba, 0x03a9c533, 0x03ae28fd, 0x03b28e16, | ||
434 | 0x03b6f47e, 0x03bb5c33, 0x03bfc536, 0x03c42f85, 0x03c89b20, 0x03cd0806, 0x03d17636, 0x03d5e5af, | ||
435 | 0x03da5671, 0x03dec87b, 0x03e33bcc, 0x03e7b063, 0x03ec2640, 0x03f09d62, 0x03f515c9, 0x03f98f73, | ||
436 | 0x03fe0a5f, 0x0402868e, 0x040703fe, 0x040b82af, 0x041002a0, 0x041483d1, 0x04190640, 0x041d89ec, | ||
437 | 0x04220ed7, 0x042694fd, 0x042b1c60, 0x042fa4fe, 0x04342ed6, 0x0438b9e9, 0x043d4635, 0x0441d3b9, | ||
438 | 0x04466275, 0x044af269, 0x044f8393, 0x045415f3, 0x0458a988, 0x045d3e53, 0x0461d451, 0x04666b83, | ||
439 | 0x046b03e7, 0x046f9d7e, 0x04743846, 0x0478d440, 0x047d716a, 0x04820fc3, 0x0486af4c, 0x048b5003, | ||
440 | 0x048ff1e8, 0x049494fa, 0x04993939, 0x049ddea5, 0x04a2853c, 0x04a72cfd, 0x04abd5ea, 0x04b07fff, | ||
441 | 0x04b52b3f, 0x04b9d7a6, 0x04be8536, 0x04c333ee, 0x04c7e3cc, 0x04cc94d1, 0x04d146fb, 0x04d5fa4b, | ||
442 | 0x04daaebf, 0x04df6458, 0x04e41b14, 0x04e8d2f3, 0x04ed8bf5, 0x04f24618, 0x04f7015d, 0x04fbbdc3, | ||
443 | 0x05007b49, 0x050539ef, 0x0509f9b4, 0x050eba98, 0x05137c9a, 0x05183fba, 0x051d03f6, 0x0521c950, | ||
444 | 0x05268fc6, 0x052b5757, 0x05302003, 0x0534e9ca, 0x0539b4ab, 0x053e80a5, 0x05434db9, 0x05481be5, | ||
445 | 0x054ceb29, 0x0551bb85, 0x05568cf8, 0x055b5f81, 0x05603321, 0x056507d6, 0x0569dda0, 0x056eb47f, | ||
446 | 0x05738c72, 0x05786578, 0x057d3f92, 0x05821abe, 0x0586f6fd, 0x058bd44e, 0x0590b2af, 0x05959222, | ||
447 | 0x059a72a5, 0x059f5438, 0x05a436da, 0x05a91a8c, 0x05adff4b, 0x05b2e519, 0x05b7cbf5, 0x05bcb3dd, | ||
448 | 0x05c19cd3, 0x05c686d4, 0x05cb71e2, 0x05d05dfb, 0x05d54b1f, 0x05da394d, 0x05df2885, 0x05e418c7, | ||
449 | 0x05e90a12, 0x05edfc66, 0x05f2efc2, 0x05f7e426, 0x05fcd992, 0x0601d004, 0x0606c77d, 0x060bbffd, | ||
450 | 0x0610b982, 0x0615b40c, 0x061aaf9b, 0x061fac2f, 0x0624a9c7, 0x0629a863, 0x062ea802, 0x0633a8a3, | ||
451 | 0x0638aa47, 0x063dacee, 0x0642b095, 0x0647b53f, 0x064cbae8, 0x0651c193, 0x0656c93d, 0x065bd1e7, | ||
452 | 0x0660db90, 0x0665e639, 0x066af1df, 0x066ffe84, 0x06750c26, 0x067a1ac6, 0x067f2a62, 0x06843afb, | ||
453 | 0x06894c90, 0x068e5f21, 0x069372ad, 0x06988735, 0x069d9cb6, 0x06a2b332, 0x06a7caa8, 0x06ace318, | ||
454 | 0x06b1fc80, 0x06b716e2, 0x06bc323b, 0x06c14e8d, 0x06c66bd6, 0x06cb8a17, 0x06d0a94e, 0x06d5c97c, | ||
455 | 0x06daeaa0, 0x06e00cba, 0x06e52fca, 0x06ea53ce, 0x06ef78c8, 0x06f49eb5, 0x06f9c597, 0x06feed6d, | ||
456 | 0x07041635, 0x07093ff1, 0x070e6aa0, 0x07139640, 0x0718c2d3, 0x071df057, 0x07231ecd, 0x07284e33, | ||
457 | 0x072d7e8a, 0x0732afd2, 0x0737e209, 0x073d1530, 0x07424946, 0x07477e4a, 0x074cb43e, 0x0751eb20, | ||
458 | 0x075722ef, 0x075c5bac, 0x07619556, 0x0766cfee, 0x076c0b71, 0x077147e1, 0x0776853d, 0x077bc385, | ||
459 | 0x078102b8, 0x078642d6, 0x078b83de, 0x0790c5d1, 0x079608ae, 0x079b4c74, 0x07a09124, 0x07a5d6bd, | ||
460 | 0x07ab1d3e, 0x07b064a8, 0x07b5acfa, 0x07baf634, 0x07c04056, 0x07c58b5e, 0x07cad74e, 0x07d02424, | ||
461 | 0x07d571e0, 0x07dac082, 0x07e0100a, 0x07e56077, 0x07eab1ca, 0x07f00401, 0x07f5571c, 0x07faab1c, | ||
462 | 0x07ffffff, 0x080555c7, 0x080aac71, 0x081003fe, 0x08155c6e, 0x081ab5c0, 0x08200ff5, 0x08256b0b, | ||
463 | 0x082ac703, 0x083023dc, 0x08358196, 0x083ae030, 0x08403fab, 0x0845a006, 0x084b0141, 0x0850635b, | ||
464 | 0x0855c654, 0x085b2a2d, 0x08608ee4, 0x0865f479, 0x086b5aed, 0x0870c23e, 0x08762a6d, 0x087b9379, | ||
465 | 0x0880fd62, 0x08866828, 0x088bd3ca, 0x08914048, 0x0896ada3, 0x089c1bd8, 0x08a18aea, 0x08a6fad6, | ||
466 | 0x08ac6b9d, 0x08b1dd3f, 0x08b74fbb, 0x08bcc311, 0x08c23741, 0x08c7ac4a, 0x08cd222c, 0x08d298e8, | ||
467 | 0x08d8107c, 0x08dd88e8, 0x08e3022d, 0x08e87c49, 0x08edf73d, 0x08f37309, 0x08f8efac, 0x08fe6d25, | ||
468 | 0x0903eb75, 0x09096a9c, 0x090eea99, 0x09146b6b, 0x0919ed13, 0x091f6f91, 0x0924f2e3, 0x092a770b, | ||
469 | 0x092ffc06, 0x093581d7, 0x093b087b, 0x09408ff3, 0x0946183f, 0x094ba15e, 0x09512b51, 0x0956b616, | ||
470 | 0x095c41ae, 0x0961ce18, 0x09675b54, 0x096ce962, 0x09727842, 0x097807f3, 0x097d9876, 0x098329c9, | ||
471 | 0x0988bbed, 0x098e4ee1, 0x0993e2a6, 0x0999773a, 0x099f0c9f, 0x09a4a2d3, 0x09aa39d6, 0x09afd1a8, | ||
472 | 0x09b56a49, 0x09bb03b8, 0x09c09df6, 0x09c63902, 0x09cbd4dc, 0x09d17183, 0x09d70ef8, 0x09dcad3a, | ||
473 | 0x09e24c49, 0x09e7ec25, 0x09ed8ccd, 0x09f32e41, 0x09f8d082, 0x09fe738e, 0x0a041766, 0x0a09bc09, | ||
474 | 0x0a0f6178, 0x0a1507b1, 0x0a1aaeb5, 0x0a205684, 0x0a25ff1c, 0x0a2ba87f, 0x0a3152ac, 0x0a36fda2, | ||
475 | 0x0a3ca962, 0x0a4255ea, 0x0a48033c, 0x0a4db157, 0x0a536039, 0x0a590fe5, 0x0a5ec058, 0x0a647193, | ||
476 | 0x0a6a2396, 0x0a6fd660, 0x0a7589f2, 0x0a7b3e4b, 0x0a80f36a, 0x0a86a950, 0x0a8c5ffc, 0x0a92176f, | ||
477 | 0x0a97cfa7, 0x0a9d88a5, 0x0aa34269, 0x0aa8fcf2, 0x0aaeb840, 0x0ab47453, 0x0aba312b, 0x0abfeec8, | ||
478 | 0x0ac5ad28, 0x0acb6c4d, 0x0ad12c36, 0x0ad6ece2, 0x0adcae52, 0x0ae27085, 0x0ae8337b, 0x0aedf734, | ||
479 | 0x0af3bbb0, 0x0af980ee, 0x0aff46ef, 0x0b050db2, 0x0b0ad536, 0x0b109d7c, 0x0b166684, 0x0b1c304d, | ||
480 | 0x0b21fad7, 0x0b27c622, 0x0b2d922e, 0x0b335efa, 0x0b392c87, 0x0b3efad3, 0x0b44c9e0, 0x0b4a99ac, | ||
481 | 0x0b506a38, 0x0b563b83, 0x0b5c0d8e, 0x0b61e057, 0x0b67b3df, 0x0b6d8826, 0x0b735d2b, 0x0b7932ee, | ||
482 | 0x0b7f096f, 0x0b84e0ae, 0x0b8ab8ab, 0x0b909165, 0x0b966add, 0x0b9c4511, 0x0ba22003, 0x0ba7fbb1, | ||
483 | 0x0badd81b, 0x0bb3b542, 0x0bb99326, 0x0bbf71c5, 0x0bc55120, 0x0bcb3136, 0x0bd11208, 0x0bd6f395, | ||
484 | 0x0bdcd5dd, 0x0be2b8e0, 0x0be89c9e, 0x0bee8116, 0x0bf46649, 0x0bfa4c36, 0x0c0032dc, 0x0c061a3d, | ||
485 | 0x0c0c0257, 0x0c11eb2a, 0x0c17d4b7, 0x0c1dbefd, 0x0c23a9fc, 0x0c2995b3, 0x0c2f8223, 0x0c356f4c, | ||
486 | 0x0c3b5d2c, 0x0c414bc5, 0x0c473b16, 0x0c4d2b1e, 0x0c531bde, 0x0c590d55, 0x0c5eff83, 0x0c64f268, | ||
487 | 0x0c6ae604, 0x0c70da57, 0x0c76cf60, 0x0c7cc51f, 0x0c82bb95, 0x0c88b2c1, 0x0c8eaaa2, 0x0c94a339, | ||
488 | 0x0c9a9c85, 0x0ca09687, 0x0ca6913e, 0x0cac8caa, 0x0cb288ca, 0x0cb885a0, 0x0cbe8329, 0x0cc48167, | ||
489 | 0x0cca8059, 0x0cd07fff, 0x0cd68059, 0x0cdc8167, 0x0ce28328, 0x0ce8859c, 0x0cee88c4, 0x0cf48c9e, | ||
490 | 0x0cfa912b, 0x0d00966b, 0x0d069c5d, 0x0d0ca302, 0x0d12aa59, 0x0d18b262, 0x0d1ebb1d, 0x0d24c489, | ||
491 | 0x0d2acea7, 0x0d30d976, 0x0d36e4f7, 0x0d3cf128, 0x0d42fe0b, 0x0d490b9e, 0x0d4f19e2, 0x0d5528d6, | ||
492 | 0x0d5b387b, 0x0d6148cf, 0x0d6759d4, 0x0d6d6b88, 0x0d737dec, 0x0d799100, 0x0d7fa4c3, 0x0d85b935, | ||
493 | 0x0d8bce56, 0x0d91e426, 0x0d97faa4, 0x0d9e11d1, 0x0da429ad, 0x0daa4237, 0x0db05b6f, 0x0db67555, | ||
494 | 0x0dbc8fe9, 0x0dc2ab2a, 0x0dc8c719, 0x0dcee3b5, 0x0dd500ff, 0x0ddb1ef5, 0x0de13d99, 0x0de75ce9, | ||
495 | 0x0ded7ce6, 0x0df39d8f, 0x0df9bee5, 0x0dffe0e7, 0x0e060394, 0x0e0c26ee, 0x0e124af4, 0x0e186fa5, | ||
496 | 0x0e1e9501, 0x0e24bb09, 0x0e2ae1bb, 0x0e310919, 0x0e373122, 0x0e3d59d5, 0x0e438333, 0x0e49ad3c, | ||
497 | 0x0e4fd7ee, 0x0e56034b, 0x0e5c2f52, 0x0e625c02, 0x0e68895d, 0x0e6eb761, 0x0e74e60e, 0x0e7b1564, | ||
498 | 0x0e814564, 0x0e87760d, 0x0e8da75e, 0x0e93d959, 0x0e9a0bfb, 0x0ea03f47, 0x0ea6733a, 0x0eaca7d6, | ||
499 | 0x0eb2dd1a, 0x0eb91305, 0x0ebf4999, 0x0ec580d4, 0x0ecbb8b6, 0x0ed1f140, 0x0ed82a71, 0x0ede6449, | ||
500 | 0x0ee49ec8, 0x0eead9ed, 0x0ef115ba, 0x0ef7522d, 0x0efd8f46, 0x0f03cd05, 0x0f0a0b6b, 0x0f104a76, | ||
501 | 0x0f168a28, 0x0f1cca7f, 0x0f230b7b, 0x0f294d1d, 0x0f2f8f65, 0x0f35d251, 0x0f3c15e3, 0x0f425a19, | ||
502 | 0x0f489ef4, 0x0f4ee474, 0x0f552a98, 0x0f5b7161, 0x0f61b8ce, 0x0f6800df, 0x0f6e4994, 0x0f7492ed, | ||
503 | 0x0f7adce9, 0x0f81278a, 0x0f8772cd, 0x0f8dbeb4, 0x0f940b3e, 0x0f9a586b, 0x0fa0a63c, 0x0fa6f4af, | ||
504 | 0x0fad43c4, 0x0fb3937c, 0x0fb9e3d7, 0x0fc034d4, 0x0fc68673, 0x0fccd8b4, 0x0fd32b97, 0x0fd97f1c, | ||
505 | 0x0fdfd343, 0x0fe6280b, 0x0fec7d74, 0x0ff2d37f, 0x0ff92a2b, 0x0fff8178, 0x1005d966, 0x100c31f5, | ||
506 | 0x10128b24, 0x1018e4f4, 0x101f3f64, 0x10259a75, 0x102bf626, 0x10325277, 0x1038af67, 0x103f0cf8, | ||
507 | 0x10456b28, 0x104bc9f8, 0x10522967, 0x10588976, 0x105eea24, 0x10654b70, 0x106bad5c, 0x10720fe7, | ||
508 | 0x10787310, 0x107ed6d8, 0x10853b3f, 0x108ba043, 0x109205e6, 0x10986c27, 0x109ed307, 0x10a53a83, | ||
509 | 0x10aba29e, 0x10b20b57, 0x10b874ac, 0x10bedea0, 0x10c54930, 0x10cbb45e, 0x10d22029, 0x10d88c90, | ||
510 | 0x10def995, 0x10e56736, 0x10ebd574, 0x10f2444e, 0x10f8b3c5, 0x10ff23d8, 0x11059487, 0x110c05d2, | ||
511 | 0x111277b9, 0x1118ea3b, 0x111f5d59, 0x1125d113, 0x112c4568, 0x1132ba59, 0x11392fe5, 0x113fa60c, | ||
512 | 0x11461ccd, 0x114c942a, 0x11530c22, 0x115984b4, 0x115ffde0, 0x116677a7, 0x116cf209, 0x11736d04, | ||
513 | 0x1179e89a, 0x118064c9, 0x1186e192, 0x118d5ef5, 0x1193dcf2, 0x119a5b88, 0x11a0dab8, 0x11a75a81, | ||
514 | 0x11addae3, 0x11b45bde, 0x11badd72, 0x11c15f9f, 0x11c7e265, 0x11ce65c4, 0x11d4e9bb, 0x11db6e4a, | ||
515 | 0x11e1f372, 0x11e87931, 0x11eeff89, 0x11f58679, 0x11fc0e01, 0x12029621, 0x12091ed8, 0x120fa827, | ||
516 | 0x1216320d, 0x121cbc8a, 0x1223479f, 0x1229d34b, 0x12305f8e, 0x1236ec68, 0x123d79d9, 0x124407e0, | ||
517 | 0x124a967e, 0x125125b2, 0x1257b57d, 0x125e45de, 0x1264d6d6, 0x126b6863, 0x1271fa86, 0x12788d40, | ||
518 | 0x127f208f, 0x1285b473, 0x128c48ed, 0x1292ddfd, 0x129973a2, 0x12a009dc, 0x12a6a0ab, 0x12ad3810, | ||
519 | 0x12b3d009, 0x12ba6897, 0x12c101ba, 0x12c79b71, 0x12ce35bd, 0x12d4d09e, 0x12db6c13, 0x12e2081b, | ||
520 | 0x12e8a4b9, 0x12ef41ea, 0x12f5dfaf, 0x12fc7e07, 0x13031cf4, 0x1309bc74, 0x13105c88, 0x1316fd2f, | ||
521 | 0x131d9e69, 0x13244036, 0x132ae297, 0x1331858b, 0x13382911, 0x133ecd2b, 0x134571d7, 0x134c1716, | ||
522 | 0x1352bce7, 0x1359634a, 0x13600a40, 0x1366b1c9, 0x136d59e3, 0x1374028f, 0x137aabce, 0x1381559e, | ||
523 | 0x1387ffff, 0x138eaaf3, 0x13955678, 0x139c028e, 0x13a2af36, 0x13a95c6f, 0x13b00a39, 0x13b6b895, | ||
524 | 0x13bd6781, 0x13c416fe, 0x13cac70c, 0x13d177aa, 0x13d828d9, 0x13deda99, 0x13e58ce9, 0x13ec3fc9, | ||
525 | 0x13f2f33a, 0x13f9a73a, 0x14005bcb, 0x140710eb, 0x140dc69c, 0x14147cdc, 0x141b33ab, 0x1421eb0a, | ||
526 | 0x1428a2f9, 0x142f5b77, 0x14361484, 0x143cce21, 0x1443884c, 0x144a4307, 0x1450fe50, 0x1457ba28, | ||
527 | 0x145e768f, 0x14653384, 0x146bf108, 0x1472af1b, 0x14796dbb, 0x14802cea, 0x1486eca8, 0x148dacf3, | ||
528 | 0x14946dcc, 0x149b2f33, 0x14a1f128, 0x14a8b3aa, 0x14af76ba, 0x14b63a58, 0x14bcfe83, 0x14c3c33b, | ||
529 | 0x14ca8881, 0x14d14e54, 0x14d814b4, 0x14dedba0, 0x14e5a31a, 0x14ec6b21, 0x14f333b4, 0x14f9fcd4, | ||
530 | 0x1500c680, 0x150790b9, 0x150e5b7e, 0x151526cf, 0x151bf2ad, 0x1522bf17, 0x15298c0c, 0x1530598e, | ||
531 | 0x1537279b, 0x153df634, 0x1544c559, 0x154b950a, 0x15526545, 0x1559360d, 0x1560075f, 0x1566d93d, | ||
532 | 0x156daba6, 0x15747e99, 0x157b5218, 0x15822622, 0x1588fab6, 0x158fcfd6, 0x1596a57f, 0x159d7bb4, | ||
533 | 0x15a45272, 0x15ab29bc, 0x15b2018f, 0x15b8d9ed, 0x15bfb2d4, 0x15c68c46, 0x15cd6641, 0x15d440c7, | ||
534 | 0x15db1bd6, 0x15e1f76f, 0x15e8d391, 0x15efb03d, 0x15f68d73, 0x15fd6b31, 0x16044979, 0x160b284a, | ||
535 | 0x161207a5, 0x1618e788, 0x161fc7f4, 0x1626a8e9, 0x162d8a67, 0x16346c6d, 0x163b4efc, 0x16423213, | ||
536 | 0x164915b3, 0x164ff9dc, 0x1656de8c, 0x165dc3c5, 0x1664a985, 0x166b8fce, 0x1672769f, 0x16795df7, | ||
537 | 0x168045d8, 0x16872e40, 0x168e172f, 0x169500a7, 0x169beaa5, 0x16a2d52b, 0x16a9c038, 0x16b0abcd, | ||
538 | 0x16b797e8, 0x16be848b, 0x16c571b4, 0x16cc5f65, 0x16d34d9c, 0x16da3c5a, 0x16e12b9e, 0x16e81b69, | ||
539 | 0x16ef0bbb, 0x16f5fc93, 0x16fcedf1, 0x1703dfd6, 0x170ad241, 0x1711c531, 0x1718b8a8, 0x171faca5, | ||
540 | 0x1726a127, 0x172d9630, 0x17348bbe, 0x173b81d1, 0x1742786b, 0x17496f89, 0x1750672d, 0x17575f56, | ||
541 | 0x175e5805, 0x17655139, 0x176c4af1, 0x1773452f, 0x177a3ff2, 0x17813b39, 0x17883705, 0x178f3356, | ||
542 | 0x1796302c, 0x179d2d86, 0x17a42b64, 0x17ab29c7, 0x17b228ae, 0x17b92819, 0x17c02809, 0x17c7287c, | ||
543 | 0x17ce2974, 0x17d52aef, 0x17dc2cef, 0x17e32f72, 0x17ea3278, 0x17f13603, 0x17f83a11, 0x17ff3ea2, | ||
544 | 0x180643b7, 0x180d494f, 0x18144f6a, 0x181b5609, 0x18225d2a, 0x182964cf, 0x18306cf6, 0x183775a1, | ||
545 | 0x183e7ece, 0x1845887e, 0x184c92b0, 0x18539d65, 0x185aa89d, 0x1861b457, 0x1868c093, 0x186fcd52, | ||
546 | 0x1876da93, 0x187de856, 0x1884f69b, 0x188c0562, 0x189314aa, 0x189a2475, 0x18a134c2, 0x18a84590, | ||
547 | 0x18af56e0, 0x18b668b1, 0x18bd7b04, 0x18c48dd8, 0x18cba12d, 0x18d2b504, 0x18d9c95c, 0x18e0de35, | ||
548 | 0x18e7f38f, 0x18ef096b, 0x18f61fc7, 0x18fd36a3, 0x19044e01, 0x190b65df, 0x19127e3e, 0x1919971d, | ||
549 | 0x1920b07d, 0x1927ca5d, 0x192ee4be, 0x1935ff9f, 0x193d1b00, 0x194436e1, 0x194b5342, 0x19527023, | ||
550 | 0x19598d84, 0x1960ab65, 0x1967c9c6, 0x196ee8a6, 0x19760806, 0x197d27e6, 0x19844845, 0x198b6923, | ||
551 | 0x19928a81, 0x1999ac5e, 0x19a0ceba, 0x19a7f196, 0x19af14f0, 0x19b638ca, 0x19bd5d22, 0x19c481f9, | ||
552 | 0x19cba74f, 0x19d2cd24, 0x19d9f378, 0x19e11a4a, 0x19e8419a, 0x19ef6969, 0x19f691b6, 0x19fdba82, | ||
553 | 0x1a04e3cc, 0x1a0c0d94, 0x1a1337da, 0x1a1a629f, 0x1a218de1, 0x1a28b9a1, 0x1a2fe5df, 0x1a37129b, | ||
554 | 0x1a3e3fd4, 0x1a456d8b, 0x1a4c9bc0, 0x1a53ca72, 0x1a5af9a2, 0x1a62294f, 0x1a695979, 0x1a708a21, | ||
555 | 0x1a77bb45, 0x1a7eece7, 0x1a861f06, 0x1a8d51a2, 0x1a9484bb, 0x1a9bb850, 0x1aa2ec62, 0x1aaa20f1, | ||
556 | 0x1ab155fd, 0x1ab88b85, 0x1abfc18a, 0x1ac6f80b, 0x1ace2f09, 0x1ad56683, 0x1adc9e79, 0x1ae3d6eb, | ||
557 | 0x1aeb0fda, 0x1af24944, 0x1af9832b, 0x1b00bd8d, 0x1b07f86c, 0x1b0f33c6, 0x1b166f9c, 0x1b1dabed, | ||
558 | 0x1b24e8ba, 0x1b2c2603, 0x1b3363c7, 0x1b3aa206, 0x1b41e0c1, 0x1b491ff7, 0x1b505fa9, 0x1b579fd5, | ||
559 | 0x1b5ee07d, 0x1b66219f, 0x1b6d633d, 0x1b74a555, 0x1b7be7e9, 0x1b832af7, 0x1b8a6e7f, 0x1b91b283, | ||
560 | 0x1b98f701, 0x1ba03bf9, 0x1ba7816c, 0x1baec75a, 0x1bb60dc1, 0x1bbd54a3, 0x1bc49bff, 0x1bcbe3d6, | ||
561 | 0x1bd32c26, 0x1bda74f1, 0x1be1be35, 0x1be907f3, 0x1bf0522b, 0x1bf79cdd, 0x1bfee809, 0x1c0633ae, | ||
562 | 0x1c0d7fcc, 0x1c14cc65, 0x1c1c1976, 0x1c236702, 0x1c2ab506, 0x1c320384, 0x1c39527b, 0x1c40a1eb, | ||
563 | 0x1c47f1d4, 0x1c4f4236, 0x1c569311, 0x1c5de466, 0x1c653632, 0x1c6c8878, 0x1c73db37, 0x1c7b2e6e, | ||
564 | 0x1c82821d, 0x1c89d646, 0x1c912ae6, 0x1c987fff, 0x1c9fd591, 0x1ca72b9b, 0x1cae821d, 0x1cb5d917, | ||
565 | 0x1cbd3089, 0x1cc48874, 0x1ccbe0d6, 0x1cd339b1, 0x1cda9303, 0x1ce1eccd, 0x1ce9470f, 0x1cf0a1c8, | ||
566 | 0x1cf7fcf9, 0x1cff58a2, 0x1d06b4c2, 0x1d0e115a, 0x1d156e69, 0x1d1ccbf0, 0x1d2429ed, 0x1d2b8862, | ||
567 | 0x1d32e74e, 0x1d3a46b2, 0x1d41a68c, 0x1d4906dd, 0x1d5067a6, 0x1d57c8e5, 0x1d5f2a9b, 0x1d668cc7, | ||
568 | 0x1d6def6b, 0x1d755285, 0x1d7cb615, 0x1d841a1c, 0x1d8b7e9a, 0x1d92e38e, 0x1d9a48f9, 0x1da1aed9, | ||
569 | 0x1da91530, 0x1db07bfd, 0x1db7e340, 0x1dbf4afa, 0x1dc6b329, 0x1dce1bce, 0x1dd584e9, 0x1ddcee7a, | ||
570 | 0x1de45881, 0x1debc2fe, 0x1df32df0, 0x1dfa9957, 0x1e020535, 0x1e097187, 0x1e10de50, 0x1e184b8d, | ||
571 | 0x1e1fb940, 0x1e272768, 0x1e2e9606, 0x1e360518, 0x1e3d74a0, 0x1e44e49d, 0x1e4c550e, 0x1e53c5f5, | ||
572 | 0x1e5b3750, 0x1e62a921, 0x1e6a1b66, 0x1e718e20, 0x1e79014e, 0x1e8074f1, 0x1e87e909, 0x1e8f5d95, | ||
573 | 0x1e96d295, 0x1e9e480a, 0x1ea5bdf3, 0x1ead3450, 0x1eb4ab22, 0x1ebc2268, 0x1ec39a22, 0x1ecb1250, | ||
574 | 0x1ed28af1, 0x1eda0407, 0x1ee17d91, 0x1ee8f78f, 0x1ef07200, 0x1ef7ece5, 0x1eff683d, 0x1f06e40a, | ||
575 | 0x1f0e604a, 0x1f15dcfd, 0x1f1d5a24, 0x1f24d7be, 0x1f2c55cb, 0x1f33d44c, 0x1f3b5340, 0x1f42d2a7, | ||
576 | 0x1f4a5281, 0x1f51d2ce, 0x1f59538f, 0x1f60d4c2, 0x1f685668, 0x1f6fd881, 0x1f775b0d, 0x1f7ede0c, | ||
577 | 0x1f86617d, 0x1f8de561, 0x1f9569b7, 0x1f9cee80, 0x1fa473bb, 0x1fabf969, 0x1fb37f8a, 0x1fbb061c, | ||
578 | 0x1fc28d21, 0x1fca1498, 0x1fd19c81, 0x1fd924dc, 0x1fe0ada9, 0x1fe836e9, 0x1fefc09a, 0x1ff74abd, | ||
579 | 0x1ffed552, 0x20066059, 0x200debd1, 0x201577bc, 0x201d0417, 0x202490e5, 0x202c1e24, 0x2033abd4, | ||
580 | 0x203b39f6, 0x2042c889, 0x204a578d, 0x2051e703, 0x205976ea, 0x20610742, 0x2068980b, 0x20702946, | ||
581 | 0x2077baf1, 0x207f4d0d, 0x2086df9a, 0x208e7298, 0x20960607, 0x209d99e7, 0x20a52e37, 0x20acc2f8, | ||
582 | 0x20b45829, 0x20bbedcb, 0x20c383de, 0x20cb1a61, 0x20d2b154, 0x20da48b8, 0x20e1e08c, 0x20e978d0, | ||
583 | 0x20f11185, 0x20f8aaa9, 0x2100443e, 0x2107de43, 0x210f78b7, 0x2117139c, 0x211eaef0, 0x21264ab5, | ||
584 | 0x212de6e9, 0x2135838d, 0x213d20a0, 0x2144be24, 0x214c5c16, 0x2153fa79, 0x215b994b, 0x2163388c, | ||
585 | 0x216ad83d, 0x2172785d, 0x217a18ec, 0x2181b9ea, 0x21895b58, 0x2190fd35, 0x21989f81, 0x21a0423c, | ||
586 | 0x21a7e566, 0x21af88ff, 0x21b72d06, 0x21bed17d, 0x21c67663, 0x21ce1bb7, 0x21d5c17a, 0x21dd67ab, | ||
587 | 0x21e50e4b, 0x21ecb55a, 0x21f45cd7, 0x21fc04c3, 0x2203ad1d, 0x220b55e5, 0x2212ff1c, 0x221aa8c1, | ||
588 | 0x222252d4, 0x2229fd56, 0x2231a845, 0x223953a3, 0x2240ff6e, 0x2248aba8, 0x2250584f, 0x22580565, | ||
589 | 0x225fb2e8, 0x226760d9, 0x226f0f37, 0x2276be04, 0x227e6d3e, 0x22861ce5, 0x228dccfa, 0x22957d7d, | ||
590 | 0x229d2e6d, 0x22a4dfcb, 0x22ac9195, 0x22b443cd, 0x22bbf673, 0x22c3a985, 0x22cb5d05, 0x22d310f2, | ||
591 | 0x22dac54c, 0x22e27a13, 0x22ea2f47, 0x22f1e4e8, 0x22f99af5, 0x23015170, 0x23090857, 0x2310bfab, | ||
592 | 0x2318776c, 0x23202f99, 0x2327e833, 0x232fa13a, 0x23375aad, 0x233f148c, 0x2346ced8, 0x234e8991, | ||
593 | 0x235644b5, 0x235e0046, 0x2365bc43, 0x236d78ac, 0x23753582, 0x237cf2c3, 0x2384b071, 0x238c6e8a, | ||
594 | 0x23942d10, 0x239bec01, 0x23a3ab5e, 0x23ab6b28, 0x23b32b5c, 0x23baebfd, 0x23c2ad09, 0x23ca6e81, | ||
595 | 0x23d23064, 0x23d9f2b3, 0x23e1b56e, 0x23e97894, 0x23f13c25, 0x23f90022, 0x2400c48a, 0x2408895d, | ||
596 | 0x24104e9b, 0x24181445, 0x241fda5a, 0x2427a0da, 0x242f67c5, 0x24372f1a, 0x243ef6db, 0x2446bf07, | ||
597 | 0x244e879e, 0x2456509f, 0x245e1a0b, 0x2465e3e2, 0x246dae24, 0x247578d0, 0x247d43e7, 0x24850f68, | ||
598 | 0x248cdb54, 0x2494a7ab, 0x249c746b, 0x24a44197, 0x24ac0f2c, 0x24b3dd2c, 0x24bbab96, 0x24c37a6a, | ||
599 | 0x24cb49a8, 0x24d31951, 0x24dae963, 0x24e2b9e0, 0x24ea8ac6, 0x24f25c17, 0x24fa2dd1, 0x2501fff5, | ||
600 | 0x2509d283, 0x2511a57b, 0x251978dc, 0x25214ca7, 0x252920dc, 0x2530f57b, 0x2538ca82, 0x25409ff4, | ||
601 | 0x254875cf, 0x25504c13, 0x255822c0, 0x255ff9d7, 0x2567d157, 0x256fa941, 0x25778193, 0x257f5a4f, | ||
602 | 0x25873374, 0x258f0d02, 0x2596e6f9, 0x259ec159, 0x25a69c22, 0x25ae7753, 0x25b652ee, 0x25be2ef1, | ||
603 | 0x25c60b5e, 0x25cde833, 0x25d5c570, 0x25dda316, 0x25e58125, 0x25ed5f9d, 0x25f53e7c, 0x25fd1dc5, | ||
604 | 0x2604fd76, 0x260cdd8f, 0x2614be10, 0x261c9efa, 0x2624804c, 0x262c6206, 0x26344429, 0x263c26b3, | ||
605 | 0x264409a6, 0x264bed01, 0x2653d0c3, 0x265bb4ee, 0x26639980, 0x266b7e7b, 0x267363dd, 0x267b49a7, | ||
606 | 0x26832fd9, 0x268b1673, 0x2692fd74, 0x269ae4dd, 0x26a2ccad, 0x26aab4e5, 0x26b29d85, 0x26ba868c, | ||
607 | 0x26c26ffa, 0x26ca59d0, 0x26d2440d, 0x26da2eb1, 0x26e219bd, 0x26ea0530, 0x26f1f10a, 0x26f9dd4b, | ||
608 | 0x2701c9f4, 0x2709b703, 0x2711a479, 0x27199257, 0x2721809b, 0x27296f46, 0x27315e58, 0x27394dd1, | ||
609 | 0x27413db0, 0x27492df7, 0x27511ea4, 0x27590fb7, 0x27610132, 0x2768f312, 0x2770e55a, 0x2778d808, | ||
610 | 0x2780cb1c, 0x2788be96, 0x2790b277, 0x2798a6bf, 0x27a09b6c, 0x27a89080, 0x27b085fa, 0x27b87bdb, | ||
611 | 0x27c07221, 0x27c868cd, 0x27d05fe0, 0x27d85758, 0x27e04f37, 0x27e8477b, 0x27f04026, 0x27f83936, | ||
612 | 0x280032ac, 0x28082c87, 0x281026c9, 0x28182170, 0x28201c7d, 0x282817ef, 0x283013c7, 0x28381004, | ||
613 | 0x28400ca7, 0x284809b0, 0x2850071d, 0x285804f1, 0x28600329, 0x286801c7, 0x287000ca, 0x28780032, | ||
614 | 0x287fffff, 0x28880032, 0x289000ca, 0x289801c6, 0x28a00328, 0x28a804ef, 0x28b0071b, 0x28b809ab, | ||
615 | 0x28c00ca1, 0x28c80ffb, 0x28d013ba, 0x28d817de, 0x28e01c66, 0x28e82153, 0x28f026a5, 0x28f82c5b, | ||
616 | 0x29003276, 0x290838f6, 0x29103fda, 0x29184722, 0x29204ecf, 0x292856e0, 0x29305f55, 0x2938682f, | ||
617 | 0x2940716d, 0x29487b0f, 0x29508516, 0x29588f80, 0x29609a4f, 0x2968a582, 0x2970b118, 0x2978bd13, | ||
618 | 0x2980c972, 0x2988d634, 0x2990e35a, 0x2998f0e5, 0x29a0fed3, 0x29a90d24, 0x29b11bda, 0x29b92af3, | ||
619 | 0x29c13a70, 0x29c94a50, 0x29d15a94, 0x29d96b3c, 0x29e17c47, 0x29e98db5, 0x29f19f87, 0x29f9b1bc, | ||
620 | 0x2a01c455, 0x2a09d751, 0x2a11eab0, 0x2a19fe72, 0x2a221298, 0x2a2a2721, 0x2a323c0d, 0x2a3a515c, | ||
621 | 0x2a42670e, 0x2a4a7d23, 0x2a52939b, 0x2a5aaa75, 0x2a62c1b3, 0x2a6ad954, 0x2a72f157, 0x2a7b09be, | ||
622 | 0x2a832287, 0x2a8b3bb2, 0x2a935541, 0x2a9b6f32, 0x2aa38986, 0x2aaba43c, 0x2ab3bf55, 0x2abbdad0, | ||
623 | 0x2ac3f6ad, 0x2acc12ee, 0x2ad42f90, 0x2adc4c95, 0x2ae469fc, 0x2aec87c6, 0x2af4a5f1, 0x2afcc47f, | ||
624 | 0x2b04e36f, 0x2b0d02c1, 0x2b152276, 0x2b1d428c, 0x2b256304, 0x2b2d83df, 0x2b35a51b, 0x2b3dc6b9, | ||
625 | 0x2b45e8b9, 0x2b4e0b1b, 0x2b562ddf, 0x2b5e5104, 0x2b66748c, 0x2b6e9875, 0x2b76bcbf, 0x2b7ee16b, | ||
626 | 0x2b870679, 0x2b8f2be9, 0x2b9751b9, 0x2b9f77ec, 0x2ba79e80, 0x2bafc575, 0x2bb7eccb, 0x2bc01483, | ||
627 | 0x2bc83c9d, 0x2bd06517, 0x2bd88df3, 0x2be0b730, 0x2be8e0ce, 0x2bf10acd, 0x2bf9352e, 0x2c015fef, | ||
628 | 0x2c098b11, 0x2c11b695, 0x2c19e279, 0x2c220ebf, 0x2c2a3b65, 0x2c32686c, 0x2c3a95d4, 0x2c42c39c, | ||
629 | 0x2c4af1c6, 0x2c532050, 0x2c5b4f3a, 0x2c637e86, 0x2c6bae32, 0x2c73de3e, 0x2c7c0eab, 0x2c843f79, | ||
630 | 0x2c8c70a7, 0x2c94a236, 0x2c9cd424, 0x2ca50674, 0x2cad3923, 0x2cb56c33, 0x2cbd9fa3, 0x2cc5d374, | ||
631 | 0x2cce07a4, 0x2cd63c35, 0x2cde7126, 0x2ce6a677, 0x2ceedc28, 0x2cf71238, 0x2cff48a9, 0x2d077f7a, | ||
632 | 0x2d0fb6ab, 0x2d17ee3c, 0x2d20262c, 0x2d285e7d, 0x2d30972d, 0x2d38d03d, 0x2d4109ac, 0x2d49437c, | ||
633 | 0x2d517daa, 0x2d59b839, 0x2d61f327, 0x2d6a2e75, 0x2d726a22, 0x2d7aa62e, 0x2d82e29b, 0x2d8b1f66, | ||
634 | 0x2d935c91, 0x2d9b9a1b, 0x2da3d804, 0x2dac164d, 0x2db454f5, 0x2dbc93fc, 0x2dc4d363, 0x2dcd1328, | ||
635 | 0x2dd5534d, 0x2ddd93d0, 0x2de5d4b3, 0x2dee15f5, 0x2df65795, 0x2dfe9995, 0x2e06dbf4, 0x2e0f1eb1, | ||
636 | 0x2e1761cd, 0x2e1fa548, 0x2e27e922, 0x2e302d5a, 0x2e3871f2, 0x2e40b6e8, 0x2e48fc3c, 0x2e5141ef, | ||
637 | 0x2e598801, 0x2e61ce71, 0x2e6a1540, 0x2e725c6d, 0x2e7aa3f9, 0x2e82ebe3, 0x2e8b342b, 0x2e937cd2, | ||
638 | 0x2e9bc5d7, 0x2ea40f3b, 0x2eac58fc, 0x2eb4a31c, 0x2ebced9a, 0x2ec53876, 0x2ecd83b0, 0x2ed5cf49, | ||
639 | 0x2ede1b3f, 0x2ee66794, 0x2eeeb446, 0x2ef70156, 0x2eff4ec5, 0x2f079c91, 0x2f0feabb, 0x2f183942, | ||
640 | 0x2f208828, 0x2f28d76b, 0x2f31270c, 0x2f39770b, 0x2f41c768, 0x2f4a1822, 0x2f526939, 0x2f5abaaf, | ||
641 | 0x2f630c81, 0x2f6b5eb2, 0x2f73b13f, 0x2f7c042a, 0x2f845773, 0x2f8cab19, 0x2f94ff1c, 0x2f9d537d, | ||
642 | 0x2fa5a83a, 0x2fadfd56, 0x2fb652ce, 0x2fbea8a3, 0x2fc6fed6, 0x2fcf5566, 0x2fd7ac52, 0x2fe0039c, | ||
643 | 0x2fe85b43, 0x2ff0b347, 0x2ff90ba8, 0x30016466, 0x3009bd80, 0x301216f8, 0x301a70cc, 0x3022cafd, | ||
644 | 0x302b258b, 0x30338076, 0x303bdbbd, 0x30443761, 0x304c9362, 0x3054efbf, 0x305d4c79, 0x3065a98f, | ||
645 | 0x306e0702, 0x307664d2, 0x307ec2fe, 0x30872186, 0x308f806b, 0x3097dfac, 0x30a03f49, 0x30a89f43, | ||
646 | 0x30b0ff99, 0x30b9604b, 0x30c1c159, 0x30ca22c4, 0x30d2848a, 0x30dae6ad, 0x30e3492c, 0x30ebac07, | ||
647 | 0x30f40f3e, 0x30fc72d1, 0x3104d6c0, 0x310d3b0b, 0x31159fb1, 0x311e04b4, 0x31266a12, 0x312ecfcd, | ||
648 | 0x313735e3, 0x313f9c55, 0x31480322, 0x31506a4b, 0x3158d1d0, 0x316139b0, 0x3169a1ed, 0x31720a84, | ||
649 | 0x317a7377, 0x3182dcc6, 0x318b4670, 0x3193b076, 0x319c1ad6, 0x31a48593, 0x31acf0aa, 0x31b55c1d, | ||
650 | 0x31bdc7ec, 0x31c63415, 0x31cea09a, 0x31d70d7a, 0x31df7ab5, 0x31e7e84b, 0x31f0563d, 0x31f8c489, | ||
651 | 0x32013331, 0x3209a233, 0x32121191, 0x321a8149, 0x3222f15d, 0x322b61cb, 0x3233d294, 0x323c43b8, | ||
652 | 0x3244b537, 0x324d2711, 0x32559945, 0x325e0bd4, 0x32667ebe, 0x326ef202, 0x327765a1, 0x327fd99b, | ||
653 | 0x32884def, 0x3290c29e, 0x329937a7, 0x32a1ad0b, 0x32aa22c9, 0x32b298e2, 0x32bb0f55, 0x32c38622, | ||
654 | 0x32cbfd4a, 0x32d474cc, 0x32dceca8, 0x32e564df, 0x32eddd70, 0x32f6565b, 0x32fecfa0, 0x3307493f, | ||
655 | 0x330fc338, 0x33183d8c, 0x3320b839, 0x33293341, 0x3331aea2, 0x333a2a5e, 0x3342a673, 0x334b22e2, | ||
656 | 0x33539fab, 0x335c1cce, 0x33649a4b, 0x336d1821, 0x33759652, 0x337e14dc, 0x338693bf, 0x338f12fd, | ||
657 | 0x33979294, 0x33a01284, 0x33a892cf, 0x33b11372, 0x33b9946f, 0x33c215c6, 0x33ca9776, 0x33d31980, | ||
658 | 0x33db9be3, 0x33e41ea0, 0x33eca1b5, 0x33f52524, 0x33fda8ed, 0x34062d0e, 0x340eb189, 0x3417365d, | ||
659 | 0x341fbb8b, 0x34284111, 0x3430c6f1, 0x34394d29, 0x3441d3bb, 0x344a5aa6, 0x3452e1e9, 0x345b6986, | ||
660 | 0x3463f17c, 0x346c79ca, 0x34750272, 0x347d8b72, 0x348614cb, 0x348e9e7d, 0x34972888, 0x349fb2eb, | ||
661 | 0x34a83da8, 0x34b0c8bd, 0x34b9542a, 0x34c1dff0, 0x34ca6c0f, 0x34d2f887, 0x34db8557, 0x34e4127f, | ||
662 | 0x34eca000, 0x34f52dda, 0x34fdbc0c, 0x35064a96, 0x350ed979, 0x351768b4, 0x351ff847, 0x35288833, | ||
663 | 0x35311877, 0x3539a913, 0x35423a08, 0x354acb54, 0x35535cf9, 0x355beef6, 0x3564814b, 0x356d13f8, | ||
664 | 0x3575a6fe, 0x357e3a5b, 0x3586ce10, 0x358f621d, 0x3597f682, 0x35a08b40, 0x35a92055, 0x35b1b5c1, | ||
665 | 0x35ba4b86, 0x35c2e1a3, 0x35cb7817, 0x35d40ee3, 0x35dca607, 0x35e53d82, 0x35edd555, 0x35f66d80, | ||
666 | 0x35ff0602, 0x36079edc, 0x3610380e, 0x3618d197, 0x36216b77, 0x362a05af, 0x3632a03f, 0x363b3b26, | ||
667 | 0x3643d664, 0x364c71fa, 0x36550de7, 0x365daa2b, 0x366646c7, 0x366ee3ba, 0x36778104, 0x36801ea5, | ||
668 | 0x3688bc9e, 0x36915aee, 0x3699f994, 0x36a29892, 0x36ab37e7, 0x36b3d793, 0x36bc7796, 0x36c517f1, | ||
669 | 0x36cdb8a2, 0x36d659aa, 0x36defb08, 0x36e79cbe, 0x36f03ecb, 0x36f8e12e, 0x370183e9, 0x370a26fa, | ||
670 | 0x3712ca62, 0x371b6e20, 0x37241235, 0x372cb6a1, 0x37355b64, 0x373e007d, 0x3746a5ed, 0x374f4bb3, | ||
671 | 0x3757f1d0, 0x37609844, 0x37693f0e, 0x3771e62e, 0x377a8da5, 0x37833572, 0x378bdd96, 0x37948610, | ||
672 | 0x379d2ee0, 0x37a5d807, 0x37ae8183, 0x37b72b57, 0x37bfd580, 0x37c87fff, 0x37d12ad5, 0x37d9d601, | ||
673 | 0x37e28183, 0x37eb2d5b, 0x37f3d989, 0x37fc860e, 0x380532e8, 0x380de018, 0x38168d9e, 0x381f3b7b, | ||
674 | 0x3827e9ad, 0x38309835, 0x38394712, 0x3841f646, 0x384aa5d0, 0x385355af, 0x385c05e4, 0x3864b66f, | ||
675 | 0x386d674f, 0x38761885, 0x387eca11, 0x38877bf2, 0x38902e29, 0x3898e0b6, 0x38a19398, 0x38aa46d0, | ||
676 | 0x38b2fa5d, 0x38bbae40, 0x38c46278, 0x38cd1705, 0x38d5cbe8, 0x38de8120, 0x38e736ae, 0x38efec91, | ||
677 | 0x38f8a2c9, 0x39015957, 0x390a103a, 0x3912c772, 0x391b7eff, 0x392436e1, 0x392cef19, 0x3935a7a5, | ||
678 | 0x393e6087, 0x394719be, 0x394fd34a, 0x39588d2b, 0x39614760, 0x396a01eb, 0x3972bccb, 0x397b7800, | ||
679 | 0x39843389, 0x398cef68, 0x3995ab9b, 0x399e6823, 0x39a72500, 0x39afe232, 0x39b89fb8, 0x39c15d93, | ||
680 | 0x39ca1bc3, 0x39d2da47, 0x39db9921, 0x39e4584e, 0x39ed17d1, 0x39f5d7a8, 0x39fe97d3, 0x3a075853, | ||
681 | 0x3a101927, 0x3a18da50, 0x3a219bce, 0x3a2a5d9f, 0x3a331fc5, 0x3a3be240, 0x3a44a50f, 0x3a4d6832, | ||
682 | 0x3a562ba9, 0x3a5eef75, 0x3a67b395, 0x3a707809, 0x3a793cd2, 0x3a8201ee, 0x3a8ac75f, 0x3a938d24, | ||
683 | 0x3a9c533d, 0x3aa519aa, 0x3aade06b, 0x3ab6a780, 0x3abf6ee9, 0x3ac836a6, 0x3ad0feb7, 0x3ad9c71c, | ||
684 | 0x3ae28fd5, 0x3aeb58e1, 0x3af42242, 0x3afcebf6, 0x3b05b5fe, 0x3b0e805a, 0x3b174b0a, 0x3b20160d, | ||
685 | 0x3b28e164, 0x3b31ad0f, 0x3b3a790e, 0x3b434560, 0x3b4c1205, 0x3b54deff, 0x3b5dac4b, 0x3b6679ec, | ||
686 | 0x3b6f47e0, 0x3b781627, 0x3b80e4c2, 0x3b89b3b0, 0x3b9282f2, 0x3b9b5287, 0x3ba4226f, 0x3bacf2ab, | ||
687 | 0x3bb5c33a, 0x3bbe941c, 0x3bc76552, 0x3bd036db, 0x3bd908b7, 0x3be1dae6, 0x3beaad69, 0x3bf3803e, | ||
688 | 0x3bfc5367, 0x3c0526e3, 0x3c0dfab2, 0x3c16ced4, 0x3c1fa349, 0x3c287811, 0x3c314d2c, 0x3c3a229a, | ||
689 | 0x3c42f85b, 0x3c4bce6f, 0x3c54a4d5, 0x3c5d7b8f, 0x3c66529b, 0x3c6f29fa, 0x3c7801ac, 0x3c80d9b1, | ||
690 | 0x3c89b209, 0x3c928ab3, 0x3c9b63b0, 0x3ca43cff, 0x3cad16a2, 0x3cb5f097, 0x3cbecade, 0x3cc7a578, | ||
691 | 0x3cd08065, 0x3cd95ba4, 0x3ce23736, 0x3ceb131a, 0x3cf3ef50, 0x3cfccbd9, 0x3d05a8b5, 0x3d0e85e3, | ||
692 | 0x3d176363, 0x3d204136, 0x3d291f5b, 0x3d31fdd2, 0x3d3adc9b, 0x3d43bbb7, 0x3d4c9b25, 0x3d557ae5, | ||
693 | 0x3d5e5af7, 0x3d673b5c, 0x3d701c13, 0x3d78fd1b, 0x3d81de76, 0x3d8ac023, 0x3d93a222, 0x3d9c8473, | ||
694 | 0x3da56716, 0x3dae4a0b, 0x3db72d52, 0x3dc010eb, 0x3dc8f4d6, 0x3dd1d912, 0x3ddabda1, 0x3de3a281, | ||
695 | 0x3dec87b3, 0x3df56d37, 0x3dfe530d, 0x3e073934, 0x3e101fad, 0x3e190678, 0x3e21ed95, 0x3e2ad503, | ||
696 | 0x3e33bcc3, 0x3e3ca4d4, 0x3e458d37, 0x3e4e75ec, 0x3e575ef2, 0x3e60484a, 0x3e6931f3, 0x3e721bed, | ||
697 | 0x3e7b0639, 0x3e83f0d7, 0x3e8cdbc6, 0x3e95c706, 0x3e9eb298, 0x3ea79e7a, 0x3eb08aaf, 0x3eb97734, | ||
698 | 0x3ec2640b, 0x3ecb5133, 0x3ed43eac, 0x3edd2c77, 0x3ee61a93, 0x3eef08ff, 0x3ef7f7bd, 0x3f00e6cc, | ||
699 | 0x3f09d62c, 0x3f12c5de, 0x3f1bb5e0, 0x3f24a633, 0x3f2d96d7, 0x3f3687cd, 0x3f3f7913, 0x3f486aaa, | ||
700 | 0x3f515c92, 0x3f5a4ecb, 0x3f634155, 0x3f6c342f, 0x3f75275b, 0x3f7e1ad7, 0x3f870ea4, 0x3f9002c2, | ||
701 | 0x3f98f730, 0x3fa1ebef, 0x3faae0ff, 0x3fb3d660, 0x3fbccc11, 0x3fc5c213, 0x3fceb865, 0x3fd7af08, | ||
702 | 0x3fe0a5fc, 0x3fe99d40, 0x3ff294d4, 0x3ffb8cb9, 0x400484ef, 0x400d7d75, 0x4016764b, 0x401f6f72, | ||
703 | 0x402868e9, 0x403162b1, 0x403a5cc8, 0x40435730, 0x404c51e9, 0x40554cf2, 0x405e484b, 0x406743f4, | ||
704 | 0x40703fed, 0x40793c37, 0x408238d0, 0x408b35ba, 0x409432f4, 0x409d307e, 0x40a62e58, 0x40af2c82, | ||
705 | 0x40b82afd, 0x40c129c7, 0x40ca28e1, 0x40d3284b, 0x40dc2805, 0x40e5280f, 0x40ee2869, 0x40f72913, | ||
706 | 0x41002a0c, 0x41092b56, 0x41122cef, 0x411b2ed8, 0x41243111, 0x412d3399, 0x41363672, 0x413f399a, | ||
707 | 0x41483d11, 0x415140d9, 0x415a44f0, 0x41634956, 0x416c4e0c, 0x41755312, 0x417e5867, 0x41875e0c, | ||
708 | 0x41906401, 0x41996a44, 0x41a270d8, 0x41ab77ba, 0x41b47eed, 0x41bd866e, 0x41c68e3f, 0x41cf965f, | ||
709 | 0x41d89ecf, 0x41e1a78e, 0x41eab09c, 0x41f3b9fa, 0x41fcc3a6, 0x4205cda2, 0x420ed7ee, 0x4217e288, | ||
710 | 0x4220ed72, 0x4229f8aa, 0x42330432, 0x423c1009, 0x42451c2f, 0x424e28a4, 0x42573569, 0x4260427c, | ||
711 | 0x42694fde, 0x42725d8f, 0x427b6b8f, 0x428479de, 0x428d887c, 0x42969769, 0x429fa6a5, 0x42a8b62f, | ||
712 | 0x42b1c609, 0x42bad631, 0x42c3e6a8, 0x42ccf76e, 0x42d60882, 0x42df19e5, 0x42e82b97, 0x42f13d98, | ||
713 | 0x42fa4fe7, 0x43036285, 0x430c7572, 0x431588ad, 0x431e9c37, 0x4327b00f, 0x4330c436, 0x4339d8ab, | ||
714 | 0x4342ed6f, 0x434c0282, 0x435517e3, 0x435e2d92, 0x4367438f, 0x437059dc, 0x43797076, 0x4382875f, | ||
715 | 0x438b9e96, 0x4394b61b, 0x439dcdef, 0x43a6e611, 0x43affe81, 0x43b91740, 0x43c2304d, 0x43cb49a8, | ||
716 | 0x43d46351, 0x43dd7d48, 0x43e6978d, 0x43efb221, 0x43f8cd02, 0x4401e832, 0x440b03af, 0x44141f7b, | ||
717 | 0x441d3b95, 0x442657fc, 0x442f74b2, 0x443891b6, 0x4441af07, 0x444acca7, 0x4453ea94, 0x445d08cf, | ||
718 | 0x44662758, 0x446f462f, 0x44786553, 0x448184c6, 0x448aa486, 0x4493c494, 0x449ce4f0, 0x44a60599, | ||
719 | 0x44af2690, 0x44b847d5, 0x44c16967, 0x44ca8b47, 0x44d3ad74, 0x44dccfef, 0x44e5f2b8, 0x44ef15ce, | ||
720 | 0x44f83932, 0x45015ce3, 0x450a80e2, 0x4513a52e, 0x451cc9c8, 0x4525eeaf, 0x452f13e3, 0x45383965, | ||
721 | 0x45415f34, 0x454a8551, 0x4553abbb, 0x455cd272, 0x4565f976, 0x456f20c8, 0x45784867, 0x45817053, | ||
722 | 0x458a988c, 0x4593c113, 0x459ce9e7, 0x45a61307, 0x45af3c75, 0x45b86630, 0x45c19039, 0x45caba8e, | ||
723 | 0x45d3e530, 0x45dd101f, 0x45e63b5c, 0x45ef66e5, 0x45f892bb, 0x4601bede, 0x460aeb4e, 0x4614180b, | ||
724 | 0x461d4515, 0x4626726c, 0x462fa00f, 0x4638ce00, 0x4641fc3d, 0x464b2ac7, 0x4654599e, 0x465d88c1, | ||
725 | 0x4666b832, 0x466fe7ef, 0x467917f8, 0x4682484e, 0x468b78f1, 0x4694a9e1, 0x469ddb1d, 0x46a70ca6, | ||
726 | 0x46b03e7b, 0x46b9709d, 0x46c2a30c, 0x46cbd5c7, 0x46d508ce, 0x46de3c22, 0x46e76fc2, 0x46f0a3af, | ||
727 | 0x46f9d7e9, 0x47030c6e, 0x470c4140, 0x4715765f, 0x471eabc9, 0x4727e180, 0x47311784, 0x473a4dd3, | ||
728 | 0x4743846f, 0x474cbb57, 0x4755f28c, 0x475f2a0c, 0x476861d9, 0x477199f2, 0x477ad257, 0x47840b08, | ||
729 | 0x478d4405, 0x47967d4f, 0x479fb6e4, 0x47a8f0c5, 0x47b22af3, 0x47bb656c, 0x47c4a032, 0x47cddb43, | ||
730 | 0x47d716a1, 0x47e0524a, 0x47e98e40, 0x47f2ca81, 0x47fc070e, 0x480543e7, 0x480e810c, 0x4817be7c, | ||
731 | 0x4820fc39, 0x482a3a41, 0x48337895, 0x483cb735, 0x4845f620, 0x484f3557, 0x485874da, 0x4861b4a8, | ||
732 | 0x486af4c3, 0x48743528, 0x487d75da, 0x4886b6d7, 0x488ff81f, 0x489939b3, 0x48a27b93, 0x48abbdbe, | ||
733 | 0x48b50035, 0x48be42f7, 0x48c78605, 0x48d0c95e, 0x48da0d02, 0x48e350f2, 0x48ec952e, 0x48f5d9b4, | ||
734 | 0x48ff1e86, 0x490863a4, 0x4911a90c, 0x491aeec0, 0x492434bf, 0x492d7b0a, 0x4936c1a0, 0x49400881, | ||
735 | 0x49494fad, 0x49529724, 0x495bdee7, 0x496526f4, 0x496e6f4d, 0x4977b7f1, 0x498100e0, 0x498a4a1a, | ||
736 | 0x4993939f, 0x499cdd6f, 0x49a6278a, 0x49af71f0, 0x49b8bca2, 0x49c2079e, 0x49cb52e5, 0x49d49e77, | ||
737 | 0x49ddea53, 0x49e7367b, 0x49f082ee, 0x49f9cfab, 0x4a031cb4, 0x4a0c6a07, 0x4a15b7a5, 0x4a1f058d, | ||
738 | 0x4a2853c1, 0x4a31a23f, 0x4a3af108, 0x4a44401b, 0x4a4d8f7a, 0x4a56df23, 0x4a602f16, 0x4a697f55, | ||
739 | 0x4a72cfdd, 0x4a7c20b1, 0x4a8571cf, 0x4a8ec337, 0x4a9814eb, 0x4aa166e8, 0x4aaab930, 0x4ab40bc3, | ||
740 | 0x4abd5ea0, 0x4ac6b1c8, 0x4ad0053a, 0x4ad958f6, 0x4ae2acfd, 0x4aec014e, 0x4af555e9, 0x4afeaacf, | ||
741 | 0x4b07ffff, 0x4b11557a, 0x4b1aab3f, 0x4b24014e, 0x4b2d57a7, 0x4b36ae4b, 0x4b400538, 0x4b495c70, | ||
742 | 0x4b52b3f2, 0x4b5c0bbf, 0x4b6563d5, 0x4b6ebc36, 0x4b7814e0, 0x4b816dd5, 0x4b8ac714, 0x4b94209d, | ||
743 | 0x4b9d7a6f, 0x4ba6d48c, 0x4bb02ef3, 0x4bb989a4, 0x4bc2e49f, 0x4bcc3fe4, 0x4bd59b72, 0x4bdef74b, | ||
744 | 0x4be8536e, 0x4bf1afda, 0x4bfb0c90, 0x4c046990, 0x4c0dc6da, 0x4c17246e, 0x4c20824b, 0x4c29e073, | ||
745 | 0x4c333ee4, 0x4c3c9d9e, 0x4c45fca3, 0x4c4f5bf1, 0x4c58bb89, 0x4c621b6a, 0x4c6b7b95, 0x4c74dc0a, | ||
746 | 0x4c7e3cc9, 0x4c879dd0, 0x4c90ff22, 0x4c9a60bd, 0x4ca3c2a2, 0x4cad24d0, 0x4cb68747, 0x4cbfea09, | ||
747 | 0x4cc94d13, 0x4cd2b067, 0x4cdc1405, 0x4ce577ec, 0x4ceedc1c, 0x4cf84096, 0x4d01a559, 0x4d0b0a65, | ||
748 | 0x4d146fbb, 0x4d1dd55a, 0x4d273b42, 0x4d30a174, 0x4d3a07ee, 0x4d436eb2, 0x4d4cd5c0, 0x4d563d16, | ||
749 | 0x4d5fa4b6, 0x4d690c9f, 0x4d7274d1, 0x4d7bdd4c, 0x4d854610, 0x4d8eaf1e, 0x4d981874, 0x4da18214, | ||
750 | 0x4daaebfc, 0x4db4562e, 0x4dbdc0a8, 0x4dc72b6c, 0x4dd09679, 0x4dda01ce, 0x4de36d6d, 0x4decd954, | ||
751 | 0x4df64584, 0x4dffb1fe, 0x4e091ec0, 0x4e128bcb, 0x4e1bf91f, 0x4e2566bb, 0x4e2ed4a1, 0x4e3842cf, | ||
752 | 0x4e41b146, 0x4e4b2006, 0x4e548f0e, 0x4e5dfe5f, 0x4e676df9, 0x4e70dddc, 0x4e7a4e07, 0x4e83be7b, | ||
753 | 0x4e8d2f38, 0x4e96a03d, 0x4ea0118b, 0x4ea98321, 0x4eb2f500, 0x4ebc6728, 0x4ec5d998, 0x4ecf4c50, | ||
754 | 0x4ed8bf51, 0x4ee2329b, 0x4eeba62d, 0x4ef51a07, 0x4efe8e2a, 0x4f080296, 0x4f117749, 0x4f1aec45, | ||
755 | 0x4f24618a, 0x4f2dd717, 0x4f374cec, 0x4f40c309, 0x4f4a396f, 0x4f53b01d, 0x4f5d2713, 0x4f669e52, | ||
756 | 0x4f7015d9, 0x4f798da8, 0x4f8305bf, 0x4f8c7e1e, 0x4f95f6c6, 0x4f9f6fb5, 0x4fa8e8ed, 0x4fb2626d, | ||
757 | 0x4fbbdc35, 0x4fc55645, 0x4fced09d, 0x4fd84b3e, 0x4fe1c626, 0x4feb4156, 0x4ff4bcce, 0x4ffe388f, | ||
758 | 0x5007b497, 0x501130e7, 0x501aad7f, 0x50242a5f, 0x502da787, 0x503724f7, 0x5040a2ae, 0x504a20ae, | ||
759 | 0x50539ef5, 0x505d1d84, 0x50669c5b, 0x50701b7a, 0x50799ae0, 0x50831a8e, 0x508c9a84, 0x50961ac2, | ||
760 | 0x509f9b47, 0x50a91c14, 0x50b29d29, 0x50bc1e85, 0x50c5a029, 0x50cf2215, 0x50d8a448, 0x50e226c2, | ||
761 | 0x50eba985, 0x50f52c8f, 0x50feafe0, 0x51083379, 0x5111b759, 0x511b3b81, 0x5124bff1, 0x512e44a7, | ||
762 | 0x5137c9a6, 0x51414eeb, 0x514ad478, 0x51545a4d, 0x515de069, 0x516766cc, 0x5170ed76, 0x517a7468, | ||
763 | 0x5183fba1, 0x518d8322, 0x51970ae9, 0x51a092f8, 0x51aa1b4e, 0x51b3a3ec, 0x51bd2cd0, 0x51c6b5fc, | ||
764 | 0x51d03f6f, 0x51d9c929, 0x51e3532b, 0x51ecdd73, 0x51f66802, 0x51fff2d9, 0x52097df7, 0x5213095b, | ||
765 | 0x521c9507, 0x522620fa, 0x522fad34, 0x523939b5, 0x5242c67c, 0x524c538b, 0x5255e0e1, 0x525f6e7e, | ||
766 | 0x5268fc61, 0x52728a8c, 0x527c18fd, 0x5285a7b5, 0x528f36b4, 0x5298c5fa, 0x52a25587, 0x52abe55a, | ||
767 | 0x52b57575, 0x52bf05d6, 0x52c8967d, 0x52d2276c, 0x52dbb8a1, 0x52e54a1d, 0x52eedbe0, 0x52f86de9, | ||
768 | 0x53020039, 0x530b92d0, 0x531525ad, 0x531eb8d1, 0x53284c3c, 0x5331dfed, 0x533b73e4, 0x53450823, | ||
769 | 0x534e9ca7, 0x53583173, 0x5361c684, 0x536b5bdc, 0x5374f17b, 0x537e8760, 0x53881d8c, 0x5391b3fe, | ||
770 | 0x539b4ab6, 0x53a4e1b5, 0x53ae78fa, 0x53b81086, 0x53c1a858, 0x53cb4070, 0x53d4d8ce, 0x53de7173, | ||
771 | 0x53e80a5e, 0x53f1a390, 0x53fb3d07, 0x5404d6c5, 0x540e70c9, 0x54180b13, 0x5421a5a4, 0x542b407a, | ||
772 | 0x5434db97, 0x543e76fa, 0x544812a3, 0x5451ae92, 0x545b4ac8, 0x5464e743, 0x546e8404, 0x5478210c, | ||
773 | 0x5481be59, 0x548b5bed, 0x5494f9c6, 0x549e97e5, 0x54a8364b, 0x54b1d4f6, 0x54bb73e8, 0x54c5131f, | ||
774 | 0x54ceb29c, 0x54d8525f, 0x54e1f268, 0x54eb92b6, 0x54f5334b, 0x54fed425, 0x55087546, 0x551216ac, | ||
775 | 0x551bb858, 0x55255a49, 0x552efc80, 0x55389efe, 0x554241c0, 0x554be4c9, 0x55558817, 0x555f2bab, | ||
776 | 0x5568cf84, 0x557273a3, 0x557c1808, 0x5585bcb3, 0x558f61a3, 0x559906d8, 0x55a2ac53, 0x55ac5214, | ||
777 | 0x55b5f81a, 0x55bf9e66, 0x55c944f7, 0x55d2ebce, 0x55dc92ea, 0x55e63a4c, 0x55efe1f3, 0x55f989e0, | ||
778 | 0x56033212, 0x560cda89, 0x56168346, 0x56202c48, 0x5629d58f, 0x56337f1c, 0x563d28ee, 0x5646d306, | ||
779 | 0x56507d62, 0x565a2804, 0x5663d2ec, 0x566d7e18, 0x5677298a, 0x5680d541, 0x568a813d, 0x56942d7e, | ||
780 | 0x569dda05, 0x56a786d1, 0x56b133e1, 0x56bae137, 0x56c48ed2, 0x56ce3cb3, 0x56d7ead8, 0x56e19942, | ||
781 | 0x56eb47f1, 0x56f4f6e6, 0x56fea61f, 0x5708559e, 0x57120561, 0x571bb569, 0x572565b7, 0x572f1649, | ||
782 | 0x5738c720, 0x5742783c, 0x574c299e, 0x5755db43, 0x575f8d2e, 0x57693f5e, 0x5772f1d2, 0x577ca48c, | ||
783 | 0x5786578a, 0x57900acd, 0x5799be54, 0x57a37221, 0x57ad2632, 0x57b6da88, 0x57c08f23, 0x57ca4402, | ||
784 | 0x57d3f926, 0x57ddae8f, 0x57e7643c, 0x57f11a2f, 0x57fad065, 0x580486e1, 0x580e3da1, 0x5817f4a5, | ||
785 | 0x5821abee, 0x582b637c, 0x58351b4e, 0x583ed365, 0x58488bc0, 0x58524460, 0x585bfd44, 0x5865b66d, | ||
786 | 0x586f6fda, 0x5879298b, 0x5882e381, 0x588c9dbc, 0x5896583b, 0x58a012fe, 0x58a9ce05, 0x58b38951, | ||
787 | 0x58bd44e2, 0x58c700b6, 0x58d0bccf, 0x58da792c, 0x58e435ce, 0x58edf2b4, 0x58f7afde, 0x59016d4c, | ||
788 | 0x590b2afe, 0x5914e8f5, 0x591ea730, 0x592865af, 0x59322472, 0x593be379, 0x5945a2c5, 0x594f6255, | ||
789 | 0x59592228, 0x5962e240, 0x596ca29c, 0x5976633c, 0x59802420, 0x5989e548, 0x5993a6b4, 0x599d6864, | ||
790 | 0x59a72a58, 0x59b0ec90, 0x59baaf0c, 0x59c471cc, 0x59ce34d0, 0x59d7f818, 0x59e1bba3, 0x59eb7f73, | ||
791 | 0x59f54386, 0x59ff07dd, 0x5a08cc79, 0x5a129158, 0x5a1c567a, 0x5a261be1, 0x5a2fe18b, 0x5a39a779, | ||
792 | 0x5a436dab, 0x5a4d3421, 0x5a56fada, 0x5a60c1d8, 0x5a6a8918, 0x5a74509d, 0x5a7e1865, 0x5a87e071, | ||
793 | 0x5a91a8c0, 0x5a9b7153, 0x5aa53a2a, 0x5aaf0344, 0x5ab8cca2, 0x5ac29644, 0x5acc6029, 0x5ad62a51, | ||
794 | 0x5adff4bd, 0x5ae9bf6d, 0x5af38a60, 0x5afd5597, 0x5b072111, 0x5b10ecce, 0x5b1ab8cf, 0x5b248514, | ||
795 | 0x5b2e519c, 0x5b381e67, 0x5b41eb76, 0x5b4bb8c8, 0x5b55865d, 0x5b5f5436, 0x5b692252, 0x5b72f0b1, | ||
796 | 0x5b7cbf54, 0x5b868e3a, 0x5b905d63, 0x5b9a2cd0, 0x5ba3fc7f, 0x5badcc72, 0x5bb79ca9, 0x5bc16d22, | ||
797 | 0x5bcb3ddf, 0x5bd50ede, 0x5bdee021, 0x5be8b1a7, 0x5bf28371, 0x5bfc557d, 0x5c0627cc, 0x5c0ffa5f, | ||
798 | 0x5c19cd35, 0x5c23a04d, 0x5c2d73a9, 0x5c374748, 0x5c411b2a, 0x5c4aef4e, 0x5c54c3b6, 0x5c5e9861, | ||
799 | 0x5c686d4f, 0x5c724280, 0x5c7c17f3, 0x5c85edaa, 0x5c8fc3a3, 0x5c9999e0, 0x5ca3705f, 0x5cad4721, | ||
800 | 0x5cb71e26, 0x5cc0f56e, 0x5ccaccf9, 0x5cd4a4c6, 0x5cde7cd7, 0x5ce8552a, 0x5cf22dbf, 0x5cfc0698, | ||
801 | 0x5d05dfb3, 0x5d0fb912, 0x5d1992b2, 0x5d236c96, 0x5d2d46bc, 0x5d372125, 0x5d40fbd1, 0x5d4ad6bf, | ||
802 | 0x5d54b1f0, 0x5d5e8d63, 0x5d686919, 0x5d724512, 0x5d7c214d, 0x5d85fdcb, 0x5d8fda8b, 0x5d99b78e, | ||
803 | 0x5da394d4, 0x5dad725c, 0x5db75026, 0x5dc12e33, 0x5dcb0c82, 0x5dd4eb14, 0x5ddec9e9, 0x5de8a8ff, | ||
804 | 0x5df28858, 0x5dfc67f4, 0x5e0647d2, 0x5e1027f2, 0x5e1a0855, 0x5e23e8fa, 0x5e2dc9e1, 0x5e37ab0b, | ||
805 | 0x5e418c77, 0x5e4b6e25, 0x5e555016, 0x5e5f3249, 0x5e6914be, 0x5e72f775, 0x5e7cda6f, 0x5e86bdab, | ||
806 | 0x5e90a129, 0x5e9a84e9, 0x5ea468eb, 0x5eae4d30, 0x5eb831b6, 0x5ec2167f, 0x5ecbfb8a, 0x5ed5e0d7, | ||
807 | 0x5edfc666, 0x5ee9ac37, 0x5ef3924a, 0x5efd78a0, 0x5f075f37, 0x5f114610, 0x5f1b2d2c, 0x5f251489, | ||
808 | 0x5f2efc28, 0x5f38e40a, 0x5f42cc2d, 0x5f4cb492, 0x5f569d39, 0x5f608622, 0x5f6a6f4d, 0x5f7458ba, | ||
809 | 0x5f7e4269, 0x5f882c5a, 0x5f92168c, 0x5f9c0100, 0x5fa5ebb6, 0x5fafd6ae, 0x5fb9c1e8, 0x5fc3ad64, | ||
810 | 0x5fcd9921, 0x5fd78520, 0x5fe17161, 0x5feb5de3, 0x5ff54aa7, 0x5fff37ad, 0x600924f5, 0x6013127e, | ||
811 | 0x601d0049, 0x6026ee56, 0x6030dca4, 0x603acb34, 0x6044ba05, 0x604ea918, 0x6058986d, 0x60628803, | ||
812 | 0x606c77db, 0x607667f4, 0x6080584f, 0x608a48ec, 0x609439ca, 0x609e2ae9, 0x60a81c4a, 0x60b20dec, | ||
813 | 0x60bbffd0, 0x60c5f1f5, 0x60cfe45c, 0x60d9d704, 0x60e3c9ed, 0x60edbd18, 0x60f7b084, 0x6101a432, | ||
814 | 0x610b9821, 0x61158c51, 0x611f80c3, 0x61297576, 0x61336a6a, 0x613d5f9f, 0x61475516, 0x61514ace, | ||
815 | 0x615b40c7, 0x61653702, 0x616f2d7e, 0x6179243a, 0x61831b38, 0x618d1278, 0x619709f8, 0x61a101ba, | ||
816 | 0x61aaf9bd, 0x61b4f200, 0x61beea85, 0x61c8e34b, 0x61d2dc53, 0x61dcd59b, 0x61e6cf24, 0x61f0c8ee, | ||
817 | 0x61fac2fa, 0x6204bd46, 0x620eb7d4, 0x6218b2a2, 0x6222adb1, 0x622ca902, 0x6236a493, 0x6240a065, | ||
818 | 0x624a9c78, 0x625498cd, 0x625e9562, 0x62689238, 0x62728f4e, 0x627c8ca6, 0x62868a3e, 0x62908818, | ||
819 | 0x629a8632, 0x62a4848d, 0x62ae8329, 0x62b88205, 0x62c28123, 0x62cc8081, 0x62d68020, 0x62e07fff, | ||
820 | 0x62ea8020, 0x62f48081, 0x62fe8123, 0x63088205, 0x63128328, 0x631c848c, 0x63268631, 0x63308816, | ||
821 | 0x633a8a3b, 0x63448ca2, 0x634e8f49, 0x63589230, 0x63629558, 0x636c98c1, 0x63769c6a, 0x6380a054, | ||
822 | 0x638aa47e, 0x6394a8e9, 0x639ead94, 0x63a8b280, 0x63b2b7ac, 0x63bcbd19, 0x63c6c2c6, 0x63d0c8b3, | ||
823 | 0x63dacee1, 0x63e4d550, 0x63eedbff, 0x63f8e2ee, 0x6402ea1d, 0x640cf18d, 0x6416f93e, 0x6421012e, | ||
824 | 0x642b095f, 0x643511d0, 0x643f1a82, 0x64492374, 0x64532ca6, 0x645d3618, 0x64673fcb, 0x647149bd, | ||
825 | 0x647b53f0, 0x64855e64, 0x648f6917, 0x6499740b, 0x64a37f3e, 0x64ad8ab2, 0x64b79666, 0x64c1a25b, | ||
826 | 0x64cbae8f, 0x64d5bb03, 0x64dfc7b8, 0x64e9d4ad, 0x64f3e1e1, 0x64fdef56, 0x6507fd0b, 0x65120b00, | ||
827 | 0x651c1934, 0x652627a9, 0x6530365e, 0x653a4553, 0x65445488, 0x654e63fd, 0x655873b1, 0x656283a6, | ||
828 | 0x656c93db, 0x6576a44f, 0x6580b503, 0x658ac5f8, 0x6594d72c, 0x659ee8a0, 0x65a8fa54, 0x65b30c47, | ||
829 | 0x65bd1e7b, 0x65c730ee, 0x65d143a1, 0x65db5694, 0x65e569c7, 0x65ef7d39, 0x65f990eb, 0x6603a4dd, | ||
830 | 0x660db90f, 0x6617cd80, 0x6621e231, 0x662bf722, 0x66360c52, 0x664021c2, 0x664a3772, 0x66544d62, | ||
831 | 0x665e6390, 0x666879ff, 0x667290ad, 0x667ca79b, 0x6686bec8, 0x6690d635, 0x669aede2, 0x66a505ce, | ||
832 | 0x66af1df9, 0x66b93664, 0x66c34f0f, 0x66cd67f9, 0x66d78123, 0x66e19a8c, 0x66ebb434, 0x66f5ce1c, | ||
833 | 0x66ffe843, 0x670a02aa, 0x67141d50, 0x671e3836, 0x6728535b, 0x67326ebf, 0x673c8a63, 0x6746a646, | ||
834 | 0x6750c268, 0x675adeca, 0x6764fb6b, 0x676f184b, 0x6779356a, 0x678352c9, 0x678d7067, 0x67978e45, | ||
835 | 0x67a1ac61, 0x67abcabd, 0x67b5e958, 0x67c00832, 0x67ca274c, 0x67d446a4, 0x67de663c, 0x67e88613, | ||
836 | 0x67f2a629, 0x67fcc67e, 0x6806e712, 0x681107e6, 0x681b28f8, 0x68254a4a, 0x682f6bda, 0x68398daa, | ||
837 | 0x6843afb9, 0x684dd206, 0x6857f493, 0x6862175f, 0x686c3a6a, 0x68765db3, 0x6880813c, 0x688aa504, | ||
838 | 0x6894c90a, 0x689eed50, 0x68a911d5, 0x68b33698, 0x68bd5b9a, 0x68c780dc, 0x68d1a65c, 0x68dbcc1b, | ||
839 | 0x68e5f218, 0x68f01855, 0x68fa3ed0, 0x6904658b, 0x690e8c84, 0x6918b3bc, 0x6922db32, 0x692d02e8, | ||
840 | 0x69372adc, 0x6941530f, 0x694b7b81, 0x6955a431, 0x695fcd20, 0x6969f64e, 0x69741fbb, 0x697e4966, | ||
841 | 0x69887350, 0x69929d78, 0x699cc7df, 0x69a6f285, 0x69b11d69, 0x69bb488c, 0x69c573ee, 0x69cf9f8e, | ||
842 | 0x69d9cb6d, 0x69e3f78a, 0x69ee23e6, 0x69f85080, 0x6a027d59, 0x6a0caa71, 0x6a16d7c7, 0x6a21055b, | ||
843 | 0x6a2b332e, 0x6a35613f, 0x6a3f8f8f, 0x6a49be1d, 0x6a53ecea, 0x6a5e1bf5, 0x6a684b3f, 0x6a727ac7, | ||
844 | 0x6a7caa8d, 0x6a86da91, 0x6a910ad4, 0x6a9b3b56, 0x6aa56c15, 0x6aaf9d13, 0x6ab9ce50, 0x6ac3ffca, | ||
845 | 0x6ace3183, 0x6ad8637b, 0x6ae295b0, 0x6aecc824, 0x6af6fad6, 0x6b012dc6, 0x6b0b60f4, 0x6b159461, | ||
846 | 0x6b1fc80c, 0x6b29fbf5, 0x6b34301c, 0x6b3e6481, 0x6b489925, 0x6b52ce06, 0x6b5d0326, 0x6b673884, | ||
847 | 0x6b716e20, 0x6b7ba3fa, 0x6b85da12, 0x6b901068, 0x6b9a46fd, 0x6ba47dcf, 0x6baeb4df, 0x6bb8ec2e, | ||
848 | 0x6bc323ba, 0x6bcd5b85, 0x6bd7938d, 0x6be1cbd3, 0x6bec0458, 0x6bf63d1a, 0x6c00761a, 0x6c0aaf58, | ||
849 | 0x6c14e8d4, 0x6c1f228e, 0x6c295c86, 0x6c3396bc, 0x6c3dd130, 0x6c480be1, 0x6c5246d1, 0x6c5c81fe, | ||
850 | 0x6c66bd69, 0x6c70f912, 0x6c7b34f8, 0x6c85711d, 0x6c8fad7f, 0x6c99ea1f, 0x6ca426fd, 0x6cae6418, | ||
851 | 0x6cb8a172, 0x6cc2df09, 0x6ccd1cdd, 0x6cd75af0, 0x6ce19940, 0x6cebd7ce, 0x6cf61699, 0x6d0055a2, | ||
852 | 0x6d0a94e9, 0x6d14d46d, 0x6d1f142f, 0x6d29542f, 0x6d33946c, 0x6d3dd4e7, 0x6d4815a0, 0x6d525695, | ||
853 | 0x6d5c97c9, 0x6d66d93a, 0x6d711ae9, 0x6d7b5cd5, 0x6d859eff, 0x6d8fe166, 0x6d9a240a, 0x6da466ec, | ||
854 | 0x6daeaa0c, 0x6db8ed69, 0x6dc33104, 0x6dcd74db, 0x6dd7b8f1, 0x6de1fd44, 0x6dec41d4, 0x6df686a1, | ||
855 | 0x6e00cbac, 0x6e0b10f5, 0x6e15567a, 0x6e1f9c3d, 0x6e29e23d, 0x6e34287b, 0x6e3e6ef6, 0x6e48b5ae, | ||
856 | 0x6e52fca4, 0x6e5d43d7, 0x6e678b47, 0x6e71d2f4, 0x6e7c1adf, 0x6e866307, 0x6e90ab6c, 0x6e9af40e, | ||
857 | 0x6ea53ced, 0x6eaf860a, 0x6eb9cf64, 0x6ec418fb, 0x6ece62cf, 0x6ed8ace0, 0x6ee2f72e, 0x6eed41ba, | ||
858 | 0x6ef78c83, 0x6f01d788, 0x6f0c22cb, 0x6f166e4b, 0x6f20ba08, 0x6f2b0602, 0x6f355239, 0x6f3f9ead, | ||
859 | 0x6f49eb5e, 0x6f54384d, 0x6f5e8578, 0x6f68d2e0, 0x6f732085, 0x6f7d6e67, 0x6f87bc86, 0x6f920ae2, | ||
860 | 0x6f9c597b, 0x6fa6a851, 0x6fb0f763, 0x6fbb46b3, 0x6fc59640, 0x6fcfe609, 0x6fda360f, 0x6fe48652, | ||
861 | 0x6feed6d2, 0x6ff9278f, 0x70037889, 0x700dc9bf, 0x70181b32, 0x70226ce3, 0x702cbecf, 0x703710f9, | ||
862 | 0x7041635f, 0x704bb602, 0x705608e2, 0x70605bff, 0x706aaf58, 0x707502ee, 0x707f56c1, 0x7089aad0, | ||
863 | 0x7093ff1c, 0x709e53a5, 0x70a8a86a, 0x70b2fd6c, 0x70bd52ab, 0x70c7a826, 0x70d1fdde, 0x70dc53d2, | ||
864 | 0x70e6aa03, 0x70f10071, 0x70fb571b, 0x7105ae02, 0x71100525, 0x711a5c85, 0x7124b421, 0x712f0bfa, | ||
865 | 0x7139640f, 0x7143bc61, 0x714e14ef, 0x71586dba, 0x7162c6c1, 0x716d2004, 0x71777984, 0x7181d341, | ||
866 | 0x718c2d3a, 0x7196876f, 0x71a0e1e1, 0x71ab3c8f, 0x71b59779, 0x71bff2a0, 0x71ca4e03, 0x71d4a9a3, | ||
867 | 0x71df057e, 0x71e96197, 0x71f3bdeb, 0x71fe1a7c, 0x72087749, 0x7212d452, 0x721d3197, 0x72278f19, | ||
868 | 0x7231ecd7, 0x723c4ad1, 0x7246a908, 0x7251077b, 0x725b6629, 0x7265c514, 0x7270243c, 0x727a839f, | ||
869 | 0x7284e33f, 0x728f431a, 0x7299a332, 0x72a40386, 0x72ae6416, 0x72b8c4e2, 0x72c325eb, 0x72cd872f, | ||
870 | 0x72d7e8af, 0x72e24a6c, 0x72ecac64, 0x72f70e99, 0x73017109, 0x730bd3b6, 0x7316369f, 0x732099c3, | ||
871 | 0x732afd24, 0x733560c0, 0x733fc499, 0x734a28ad, 0x73548cfe, 0x735ef18a, 0x73695652, 0x7373bb57, | ||
872 | 0x737e2097, 0x73888613, 0x7392ebca, 0x739d51be, 0x73a7b7ee, 0x73b21e59, 0x73bc8500, 0x73c6ebe4, | ||
873 | 0x73d15302, 0x73dbba5d, 0x73e621f4, 0x73f089c6, 0x73faf1d4, 0x74055a1e, 0x740fc2a3, 0x741a2b65, | ||
874 | 0x74249462, 0x742efd9b, 0x7439670f, 0x7443d0bf, 0x744e3aab, 0x7458a4d3, 0x74630f36, 0x746d79d5, | ||
875 | 0x7477e4af, 0x74824fc6, 0x748cbb17, 0x749726a5, 0x74a1926e, 0x74abfe73, 0x74b66ab3, 0x74c0d72f, | ||
876 | 0x74cb43e6, 0x74d5b0d9, 0x74e01e07, 0x74ea8b71, 0x74f4f917, 0x74ff66f8, 0x7509d514, 0x7514436c, | ||
877 | 0x751eb200, 0x752920cf, 0x75338fd9, 0x753dff1f, 0x75486ea1, 0x7552de5d, 0x755d4e56, 0x7567be89, | ||
878 | 0x75722ef8, 0x757c9fa3, 0x75871089, 0x759181aa, 0x759bf306, 0x75a6649e, 0x75b0d671, 0x75bb4880, | ||
879 | 0x75c5baca, 0x75d02d4f, 0x75daa00f, 0x75e5130b, 0x75ef8642, 0x75f9f9b4, 0x76046d62, 0x760ee14b, | ||
880 | 0x7619556f, 0x7623c9ce, 0x762e3e68, 0x7638b33e, 0x7643284f, 0x764d9d9b, 0x76581322, 0x766288e4, | ||
881 | 0x766cfee2, 0x7677751b, 0x7681eb8e, 0x768c623d, 0x7696d927, 0x76a1504d, 0x76abc7ad, 0x76b63f48, | ||
882 | 0x76c0b71f, 0x76cb2f30, 0x76d5a77d, 0x76e02004, 0x76ea98c7, 0x76f511c4, 0x76ff8afd, 0x770a0471, | ||
883 | 0x77147e1f, 0x771ef809, 0x7729722d, 0x7733ec8d, 0x773e6727, 0x7748e1fd, 0x77535d0d, 0x775dd858, | ||
884 | 0x776853df, 0x7772cfa0, 0x777d4b9c, 0x7787c7d2, 0x77924444, 0x779cc0f1, 0x77a73dd8, 0x77b1bafa, | ||
885 | 0x77bc3858, 0x77c6b5ef, 0x77d133c2, 0x77dbb1d0, 0x77e63018, 0x77f0ae9b, 0x77fb2d59, 0x7805ac52, | ||
886 | 0x78102b85, 0x781aaaf3, 0x78252a9c, 0x782faa80, 0x783a2a9e, 0x7844aaf7, 0x784f2b8a, 0x7859ac59, | ||
887 | 0x78642d62, 0x786eaea5, 0x78793024, 0x7883b1dd, 0x788e33d0, 0x7898b5fe, 0x78a33867, 0x78adbb0b, | ||
888 | 0x78b83de9, 0x78c2c101, 0x78cd4454, 0x78d7c7e2, 0x78e24baa, 0x78eccfad, 0x78f753ea, 0x7901d862, | ||
889 | 0x790c5d15, 0x7916e202, 0x79216729, 0x792bec8b, 0x79367227, 0x7940f7fe, 0x794b7e0f, 0x7956045b, | ||
890 | 0x79608ae1, 0x796b11a1, 0x7975989c, 0x79801fd1, 0x798aa741, 0x79952eeb, 0x799fb6d0, 0x79aa3eee, | ||
891 | 0x79b4c748, 0x79bf4fdb, 0x79c9d8a9, 0x79d461b1, 0x79deeaf4, 0x79e97470, 0x79f3fe27, 0x79fe8819, | ||
892 | 0x7a091244, 0x7a139caa, 0x7a1e274a, 0x7a28b225, 0x7a333d39, 0x7a3dc888, 0x7a485411, 0x7a52dfd4, | ||
893 | 0x7a5d6bd2, 0x7a67f809, 0x7a72847b, 0x7a7d1127, 0x7a879e0d, 0x7a922b2e, 0x7a9cb888, 0x7aa7461d, | ||
894 | 0x7ab1d3eb, 0x7abc61f4, 0x7ac6f037, 0x7ad17eb4, 0x7adc0d6b, 0x7ae69c5c, 0x7af12b87, 0x7afbbaec, | ||
895 | 0x7b064a8b, 0x7b10da64, 0x7b1b6a78, 0x7b25fac5, 0x7b308b4c, 0x7b3b1c0e, 0x7b45ad09, 0x7b503e3e, | ||
896 | 0x7b5acfad, 0x7b656156, 0x7b6ff339, 0x7b7a8556, 0x7b8517ad, 0x7b8faa3e, 0x7b9a3d09, 0x7ba4d00d, | ||
897 | 0x7baf634c, 0x7bb9f6c4, 0x7bc48a76, 0x7bcf1e62, 0x7bd9b288, 0x7be446e8, 0x7beedb82, 0x7bf97055, | ||
898 | 0x7c040562, 0x7c0e9aa9, 0x7c19302a, 0x7c23c5e5, 0x7c2e5bd9, 0x7c38f207, 0x7c43886f, 0x7c4e1f10, | ||
899 | 0x7c58b5ec, 0x7c634d01, 0x7c6de450, 0x7c787bd8, 0x7c83139a, 0x7c8dab96, 0x7c9843cb, 0x7ca2dc3a, | ||
900 | 0x7cad74e3, 0x7cb80dc6, 0x7cc2a6e2, 0x7ccd4037, 0x7cd7d9c7, 0x7ce27390, 0x7ced0d92, 0x7cf7a7ce, | ||
901 | 0x7d024244, 0x7d0cdcf3, 0x7d1777dc, 0x7d2212fe, 0x7d2cae5a, 0x7d3749ef, 0x7d41e5be, 0x7d4c81c7, | ||
902 | 0x7d571e08, 0x7d61ba84, 0x7d6c5739, 0x7d76f427, 0x7d81914f, 0x7d8c2eb0, 0x7d96cc4b, 0x7da16a1f, | ||
903 | 0x7dac082d, 0x7db6a673, 0x7dc144f4, 0x7dcbe3ae, 0x7dd682a1, 0x7de121cd, 0x7debc133, 0x7df660d2, | ||
904 | 0x7e0100ab, 0x7e0ba0bd, 0x7e164108, 0x7e20e18d, 0x7e2b824b, 0x7e362342, 0x7e40c472, 0x7e4b65dc, | ||
905 | 0x7e56077f, 0x7e60a95b, 0x7e6b4b71, 0x7e75edc0, 0x7e809048, 0x7e8b3309, 0x7e95d603, 0x7ea07937, | ||
906 | 0x7eab1ca4, 0x7eb5c04a, 0x7ec06429, 0x7ecb0842, 0x7ed5ac93, 0x7ee0511e, 0x7eeaf5e2, 0x7ef59adf, | ||
907 | 0x7f004015, 0x7f0ae584, 0x7f158b2c, 0x7f20310e, 0x7f2ad728, 0x7f357d7c, 0x7f402409, 0x7f4acace, | ||
908 | 0x7f5571cd, 0x7f601905, 0x7f6ac076, 0x7f75681f, 0x7f801002, 0x7f8ab81e, 0x7f956073, 0x7fa00901, | ||
909 | 0x7faab1c7, 0x7fb55ac7, 0x7fc00400, 0x7fcaad71, 0x7fd5571c, 0x7fe00100, 0x7feaab1c, 0x7ff55571, | ||
910 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
911 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
912 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
913 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
914 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
915 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
916 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
917 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
918 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
919 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
920 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
921 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
922 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
923 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
924 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
925 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
926 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
927 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
928 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
929 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
930 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
931 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
932 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
933 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
934 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
935 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
936 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
937 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
938 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
939 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
940 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
941 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
942 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
943 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
944 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
945 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
946 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
947 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
948 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
949 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
950 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
951 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
952 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
953 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
954 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
955 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
956 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
957 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
958 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
959 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
960 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
961 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
962 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
963 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
964 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
965 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
966 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
967 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
968 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
969 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
970 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
971 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
972 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
973 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
974 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
975 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
976 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
977 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
978 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
979 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
980 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
981 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
982 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
983 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
984 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
985 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
986 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
987 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
988 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
989 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
990 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
991 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
992 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
993 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
994 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
995 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
996 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
997 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
998 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
999 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1000 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1001 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1002 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1003 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1004 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1005 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1006 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1007 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1008 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1009 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1010 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1011 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1012 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1013 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1014 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1015 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1016 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1017 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1018 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1019 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1020 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1021 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1022 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1023 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1024 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1025 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1026 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1027 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1028 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1029 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1030 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1031 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1032 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1033 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1034 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1035 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1036 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1037 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1038 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1039 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1040 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1041 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1042 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1043 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1044 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1045 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1046 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1047 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1048 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1049 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1050 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1051 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1052 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1053 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1054 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1055 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1056 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1057 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1058 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1059 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1060 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1061 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1062 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1063 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1064 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1065 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1066 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1067 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1068 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1069 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1070 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1071 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1072 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1073 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1074 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1075 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1076 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1077 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1078 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1079 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1080 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1081 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1082 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1083 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1084 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1085 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1086 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1087 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1088 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1089 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1090 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1091 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1092 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1093 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1094 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1095 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1096 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1097 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1098 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1099 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1100 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1101 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1102 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1103 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1104 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1105 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1106 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1107 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1108 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1109 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1110 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1111 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1112 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1113 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1114 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1115 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1116 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1117 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1118 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1119 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1120 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1121 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1122 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1123 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1124 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1125 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1126 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1127 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1128 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1129 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1130 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1131 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1132 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1133 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1134 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1135 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1136 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1137 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1138 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1139 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1140 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1141 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1142 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1143 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1144 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1145 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1146 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1147 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1148 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1149 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1150 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1151 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1152 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1153 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1154 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1155 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1156 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1157 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1158 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1159 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1160 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1161 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1162 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1163 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1164 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1165 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1166 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1167 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1168 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1169 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1170 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1171 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1172 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1173 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1174 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1175 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1176 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1177 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1178 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1179 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1180 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1181 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1182 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1183 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1184 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1185 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1186 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1187 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1188 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1189 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1190 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1191 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1192 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1193 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1194 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1195 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1196 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1197 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1198 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1199 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1200 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1201 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1202 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1203 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1204 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1205 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1206 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1207 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1208 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1209 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1210 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1211 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1212 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1213 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1214 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1215 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1216 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1217 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1218 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1219 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1220 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1221 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1222 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1223 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1224 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1225 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1226 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1227 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1228 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1229 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1230 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1231 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1232 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1233 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1234 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1235 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1236 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1237 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1238 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1239 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1240 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1241 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1242 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1243 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1244 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1245 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1246 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1247 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1248 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1249 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1250 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1251 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1252 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1253 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1254 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1255 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1256 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1257 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1258 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1259 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1260 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1261 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1262 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1263 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1264 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1265 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1266 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1267 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1268 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1269 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1270 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1271 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1272 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1273 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1274 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1275 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1276 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1277 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1278 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1279 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1280 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1281 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1282 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1283 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1284 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1285 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1286 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1287 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1288 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1289 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1290 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1291 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1292 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1293 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1294 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1295 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1296 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1297 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1298 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1299 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1300 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1301 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1302 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1303 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1304 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1305 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1306 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1307 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1308 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1309 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1310 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1311 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1312 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1313 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1314 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1315 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1316 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1317 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1318 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1319 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1320 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1321 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1322 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1323 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1324 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1325 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1326 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1327 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1328 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1329 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1330 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1331 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1332 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1333 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1334 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1335 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1336 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1337 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1338 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1339 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1340 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1341 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1342 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1343 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1344 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1345 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1346 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1347 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1348 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1349 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1350 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1351 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1352 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1353 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1354 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1355 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1356 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1357 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1358 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1359 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1360 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1361 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1362 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1363 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1364 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1365 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1366 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1367 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1368 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1369 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1370 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1371 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1372 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1373 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1374 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1375 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1376 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1377 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1378 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1379 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1380 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1381 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1382 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1383 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1384 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1385 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1386 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1387 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1388 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1389 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1390 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1391 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1392 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1393 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1394 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1395 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1396 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1397 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1398 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1399 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1400 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1401 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1402 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1403 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1404 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1405 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1406 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1407 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1408 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1409 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1410 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1411 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1412 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1413 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1414 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1415 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1416 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1417 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1418 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1419 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1420 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1421 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1422 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, | ||
1423 | 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff,}; | ||
1424 | #endif | ||
1425 | #ifdef USE_DATA_TABLES | ||
1426 | static long mpeg3_aa_cs_data[] = { | ||
1427 | 0x00006dc2, 0x000070dc, 0x0000798d, 0x00007ddd, 0x00007f6d, 0x00007fe4, 0x00007ffc, 0x00007fff,}; | ||
1428 | #endif | ||
1429 | #ifdef USE_DATA_TABLES | ||
1430 | static long mpeg3_aa_ca_data[] = { | ||
1431 | 0xffffbe26, 0xffffc39f, 0xffffd7e4, 0xffffe8b8, 0xfffff3e5, 0xfffffac2, 0xfffffe2f, 0xffffff87,}; | ||
1432 | #endif | ||
1433 | #ifdef USE_DATA_TABLES | ||
1434 | static long mpeg3_win_data[] = { | ||
1435 | 0x00000421, 0x00000db8, 0x000019c7, 0x000029ad, 0x00003fff, 0x00006246, 0x00009ee0, 0x00012a7d, | ||
1436 | 0x0003df40, 0xfffbc63e, 0xfffe7b01, 0xffff069e, 0xffff4338, 0xffff657e, 0xffff7bd0, 0xffff8bb6, | ||
1437 | 0xffff97c5, 0xffffa15c, 0xffffa947, 0xffffb006, 0xffffb5eb, 0xffffbb30, 0xffffc000, 0xffffc47a, | ||
1438 | 0xffffc8b7, 0xffffccca, 0xffffd0c5, 0xffffd4b9, 0xffffd8b4, 0xffffdcc8, 0xffffe104, 0xffffe57e, | ||
1439 | 0xffffea4e, 0xffffef94, 0xfffff579, 0xfffffc37, 0x00000421, 0x00000db8, 0x000019c7, 0x000029ad, | ||
1440 | 0x00003fff, 0x00006246, 0x00009ee0, 0x00012a7d, 0x0003df40, 0xfffbc63e, 0xfffe7b01, 0xffff069e, | ||
1441 | 0xffff4338, 0xffff657e, 0xffff7bd0, 0xffff8bb6, 0xffff97c5, 0xffffa15c, 0xffffa932, 0xffffaf55, | ||
1442 | 0xffffb41e, 0xffffb7d9, 0xffffbabb, 0xffffbce5, 0xffffbf02, 0xffffc45d, 0xffffcd2e, 0xffffd901, | ||
1443 | 0xffffe74d, 0xfffff772, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1444 | 0x00000db8, 0x00003fff, 0x00012a7d, 0xfffe7b01, 0xffff657e, 0xffff97c5, 0xffffb006, 0xffffc000, | ||
1445 | 0xffffccca, 0xffffd8b4, 0xffffe57e, 0xfffff579, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1446 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1447 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1448 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1449 | 0x00000000, 0x00000000, 0x00002698, 0x0000bba3, 0x00037d32, 0xfffb73f7, 0xfffe3b01, 0xfffedad6, | ||
1450 | 0xffff2b2b, 0xffff58c3, 0xffff7566, 0xffff88e3, 0xffff96df, 0xffffa145, 0xffffa947, 0xffffb006, | ||
1451 | 0xffffb5eb, 0xffffbb30, 0xffffc000, 0xffffc47a, 0xffffc8b7, 0xffffccca, 0xffffd0c5, 0xffffd4b9, | ||
1452 | 0xffffd8b4, 0xffffdcc8, 0xffffe104, 0xffffe57e, 0xffffea4e, 0xffffef94, 0xfffff579, 0xfffffc37,}; | ||
1453 | #endif | ||
1454 | #ifdef USE_DATA_TABLES | ||
1455 | static long mpeg3_COS9_data[] = { | ||
1456 | 0x00008000, 0x00007e0e, 0x00007847, 0x00006ed9, 0x0000620d, 0x00005246, 0x00004000, 0x00002bc7, | ||
1457 | 0x0000163a,}; | ||
1458 | #endif | ||
1459 | #ifdef USE_DATA_TABLES | ||
1460 | static long mpeg3_tfcos36_data[] = { | ||
1461 | 0x0000403e, 0x00004241, 0x0000469d, 0x00004e21, 0x00005a82, 0x00006f94, 0x0000976f, 0x0000f746, | ||
1462 | 0x0002de51,}; | ||
1463 | #endif | ||
1464 | #ifdef USE_DATA_TABLES | ||
1465 | static long mpeg3_tfcos12_data[] = { | ||
1466 | 0x00004241, 0x00005a82, 0x0000f746,}; | ||
1467 | #endif | ||
1468 | #ifdef USE_DATA_TABLES | ||
1469 | static long mpeg3_cos9_data[] = { | ||
1470 | 0x00007847, 0xffffe9c6, 0xffff9df3,}; | ||
1471 | #endif | ||
1472 | #ifdef USE_DATA_TABLES | ||
1473 | static long mpeg3_cos18_data[] = { | ||
1474 | 0x00007e0e, 0xffffd439, 0xffffadba,}; | ||
1475 | #endif | ||
1476 | #ifdef USE_DATA_TABLES | ||
1477 | static long mpeg3_COS1_data[] = { | ||
1478 | 0x00004deb, 0xffff89bf, 0xffffef4b, 0x00007ee7, 0xffffcf05, 0xffff9a74, 0x000030fb, 0xffff89bf, | ||
1479 | 0x00007641, 0xffffcf05, 0xffffcf05, 0x00007641, 0x000010b5, 0xffffcf05, 0x00004deb, 0xffff9a74, | ||
1480 | 0x00007641, 0xffff8119, 0xffffef4b, 0x000030fb, 0xffffb215, 0x0000658c, 0xffff89bf, 0x00007ee7, | ||
1481 | 0xffffcf05, 0x00007641, 0xffff89bf, 0x000030fb, 0x000030fb, 0xffff89bf, 0xffffb215, 0x00007641, | ||
1482 | 0x000010b5, 0xffff8119, 0x000030fb, 0x0000658c, 0xffff9a74, 0x000030fb, 0x00007ee7, 0x000010b5, | ||
1483 | 0xffff89bf, 0xffffb215, 0xffff89bf, 0xffffcf05, 0x000030fb, 0x00007641, 0x00007641, 0x000030fb, | ||
1484 | 0xffff8119, 0xffff89bf, 0xffff9a74, 0xffffb215, 0xffffcf05, 0xffffef4b, 0xffff8119, 0xffff89bf, | ||
1485 | 0xffff9a74, 0xffffb215, 0xffffcf05, 0xffffef4b, 0xffff89bf, 0xffffcf05, 0x000030fb, 0x00007641, | ||
1486 | 0x00007641, 0x000030fb, 0xffff9a74, 0x000030fb, 0x00007ee7, 0x000010b5, 0xffff89bf, 0xffffb215,}; | ||
1487 | #endif | ||
1488 | #ifdef USE_DATA_TABLES | ||
1489 | static long mpeg3_win1_data[] = { | ||
1490 | 0x00000421, 0xfffff248, 0x000019c7, 0xffffd653, 0x00003fff, 0xffff9dba, 0x00009ee0, 0xfffed583, | ||
1491 | 0x0003df40, 0x000439c2, 0xfffe7b01, 0x0000f962, 0xffff4338, 0x00009a82, 0xffff7bd0, 0x0000744a, | ||
1492 | 0xffff97c5, 0x00005ea4, 0xffffa947, 0x00004ffa, 0xffffb5eb, 0x000044d0, 0xffffc000, 0x00003b86, | ||
1493 | 0xffffc8b7, 0x00003336, 0xffffd0c5, 0x00002b47, 0xffffd8b4, 0x00002338, 0xffffe104, 0x00001a82, | ||
1494 | 0xffffea4e, 0x0000106c, 0xfffff579, 0x000003c9, 0x00000421, 0xfffff248, 0x000019c7, 0xffffd653, | ||
1495 | 0x00003fff, 0xffff9dba, 0x00009ee0, 0xfffed583, 0x0003df40, 0x000439c2, 0xfffe7b01, 0x0000f962, | ||
1496 | 0xffff4338, 0x00009a82, 0xffff7bd0, 0x0000744a, 0xffff97c5, 0x00005ea4, 0xffffa932, 0x000050ab, | ||
1497 | 0xffffb41e, 0x00004827, 0xffffbabb, 0x0000431b, 0xffffbf02, 0x00003ba3, 0xffffcd2e, 0x000026ff, | ||
1498 | 0xffffe74d, 0x0000088e, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1499 | 0x00000db8, 0xffffc001, 0x00012a7d, 0x000184ff, 0xffff657e, 0x0000683b, 0xffffb006, 0x00004000, | ||
1500 | 0xffffccca, 0x0000274c, 0xffffe57e, 0x00000a87, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1501 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1502 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1503 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, | ||
1504 | 0x00000000, 0x00000000, 0x00002698, 0xffff445d, 0x00037d32, 0x00048c09, 0xfffe3b01, 0x0001252a, | ||
1505 | 0xffff2b2b, 0x0000a73d, 0xffff7566, 0x0000771d, 0xffff96df, 0x00005ebb, 0xffffa947, 0x00004ffa, | ||
1506 | 0xffffb5eb, 0x000044d0, 0xffffc000, 0x00003b86, 0xffffc8b7, 0x00003336, 0xffffd0c5, 0x00002b47, | ||
1507 | 0xffffd8b4, 0x00002338, 0xffffe104, 0x00001a82, 0xffffea4e, 0x0000106c, 0xfffff579, 0x000003c9,}; | ||
1508 | #endif | ||
1509 | #ifdef USE_DATA_TABLES | ||
1510 | static long mpeg3_tan1_1_data[] = { | ||
1511 | 0x00000000, 0x00001b0c, 0x00002ed9, 0x00003fff, 0x00005126, 0x000064f3, 0x00007fff, 0x0000aed9, | ||
1512 | 0x00012ed9, 0x7fffffff, 0xffff5127, 0xffffd127, 0x00000000, 0x00001b0c, 0x00002ed9, 0x00003fff,}; | ||
1513 | #endif | ||
1514 | #ifdef USE_DATA_TABLES | ||
1515 | static long mpeg3_tan2_1_data[] = { | ||
1516 | 0x00008000, 0x000064f3, 0x00005126, 0x00004000, 0x00002ed9, 0x00001b0c, 0x00000000, 0xffffd127, | ||
1517 | 0xffff5127, 0x80000000, 0x00012ed9, 0x0000aed9, 0x00008000, 0x000064f3, 0x00005126, 0x00004000,}; | ||
1518 | #endif | ||
1519 | #ifdef USE_DATA_TABLES | ||
1520 | static long mpeg3_tan1_2_data[] = { | ||
1521 | 0x00000000, 0x00002640, 0x00004241, 0x00005a82, 0x000072c2, 0x00008ec3, 0x0000b504, 0x0000f746, | ||
1522 | 0x0001ac4b, 0x7fffffff, 0xffff08ba, 0xffffbdbf, 0x00000000, 0x00002640, 0x00004241, 0x00005a82,}; | ||
1523 | #endif | ||
1524 | #ifdef USE_DATA_TABLES | ||
1525 | static long mpeg3_tan2_2_data[] = { | ||
1526 | 0x0000b504, 0x00008ec3, 0x000072c2, 0x00005a82, 0x00004241, 0x00002640, 0x00000000, 0xffffbdbf, | ||
1527 | 0xffff08ba, 0x80000000, 0x0001ac4b, 0x0000f746, 0x0000b504, 0x00008ec3, 0x000072c2, 0x00005a82,}; | ||
1528 | #endif | ||
1529 | #ifdef USE_DATA_TABLES | ||
1530 | static long mpeg3_pow1_1_data[] = { | ||
1531 | 0x00008000, 0x00006ba2, 0x00008000, 0x00005a82, 0x00008000, 0x00004c1b, 0x00008000, 0x00004000, | ||
1532 | 0x00008000, 0x000035d1, 0x00008000, 0x00002d41, 0x00008000, 0x0000260d, 0x00008000, 0x00002000, | ||
1533 | 0x00008000, 0x00005a82, 0x00008000, 0x00003fff, 0x00008000, 0x00002d41, 0x00008000, 0x00001fff, | ||
1534 | 0x00008000, 0x000016a0, 0x00008000, 0x00000fff, 0x00008000, 0x00000b50, 0x00008000, 0x000007ff,}; | ||
1535 | #endif | ||
1536 | #ifdef USE_DATA_TABLES | ||
1537 | static long mpeg3_pow2_1_data[] = { | ||
1538 | 0x00008000, 0x00008000, 0x00006ba2, 0x00008000, 0x00005a82, 0x00008000, 0x00004c1b, 0x00008000, | ||
1539 | 0x00004000, 0x00008000, 0x000035d1, 0x00008000, 0x00002d41, 0x00008000, 0x0000260d, 0x00008000, | ||
1540 | 0x00008000, 0x00008000, 0x00005a82, 0x00008000, 0x00003fff, 0x00008000, 0x00002d41, 0x00008000, | ||
1541 | 0x00001fff, 0x00008000, 0x000016a0, 0x00008000, 0x00000fff, 0x00008000, 0x00000b50, 0x00008000,}; | ||
1542 | #endif | ||
1543 | #ifdef USE_DATA_TABLES | ||
1544 | static long mpeg3_pow1_2_data[] = { | ||
1545 | 0x0000b504, 0x00009837, 0x0000b504, 0x00008000, 0x0000b504, 0x00006ba2, 0x0000b504, 0x00005a82, | ||
1546 | 0x0000b504, 0x00004c1b, 0x0000b504, 0x00004000, 0x0000b504, 0x000035d1, 0x0000b504, 0x00002d41, | ||
1547 | 0x0000b504, 0x00008000, 0x0000b504, 0x00005a82, 0x0000b504, 0x00003fff, 0x0000b504, 0x00002d41, | ||
1548 | 0x0000b504, 0x00001fff, 0x0000b504, 0x000016a0, 0x0000b504, 0x00000fff, 0x0000b504, 0x00000b50,}; | ||
1549 | #endif | ||
1550 | #ifdef USE_DATA_TABLES | ||
1551 | static long mpeg3_pow2_2_data[] = { | ||
1552 | 0x0000b504, 0x0000b504, 0x00009837, 0x0000b504, 0x00008000, 0x0000b504, 0x00006ba2, 0x0000b504, | ||
1553 | 0x00005a82, 0x0000b504, 0x00004c1b, 0x0000b504, 0x00004000, 0x0000b504, 0x000035d1, 0x0000b504, | ||
1554 | 0x0000b504, 0x0000b504, 0x00008000, 0x0000b504, 0x00005a82, 0x0000b504, 0x00003fff, 0x0000b504, | ||
1555 | 0x00002d41, 0x0000b504, 0x00001fff, 0x0000b504, 0x000016a0, 0x0000b504, 0x00000fff, 0x0000b504,}; | ||
1556 | #endif | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/header.c b/core/multimedia/opieplayer/libmpeg3/audio/header.c new file mode 100644 index 0000000..02b5e7c --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/header.c | |||
@@ -0,0 +1,163 @@ | |||
1 | #include "mpeg3audio.h" | ||
2 | #include "tables.h" | ||
3 | #include "../libmpeg3.h" | ||
4 | #include "../mpeg3protos.h" | ||
5 | |||
6 | #include <stdio.h> | ||
7 | |||
8 | /* Return 1 if the head check doesn't find a header. */ | ||
9 | int mpeg3audio_head_check(unsigned long head) | ||
10 | { | ||
11 | if((head & 0xffe00000) != 0xffe00000) return 1; | ||
12 | if(!((head >> 17) & 3)) return 1; | ||
13 | if(((head >> 12) & 0xf) == 0xf) return 1; | ||
14 | if(!((head >> 12) & 0xf)) return 1; | ||
15 | if(((head >> 10) & 0x3) == 0x3 ) return 1; | ||
16 | if(((head >> 19) & 1) == 1 && ((head >> 17) & 3) == 3 && ((head >> 16) & 1) == 1) | ||
17 | return 1; | ||
18 | if((head & 0xffff0000) == 0xfffe0000) return 1; | ||
19 | |||
20 | return 0; | ||
21 | } | ||
22 | |||
23 | int mpeg3audio_decode_header(mpeg3audio_t *audio) | ||
24 | { | ||
25 | if(audio->newhead & (1 << 20)) | ||
26 | { | ||
27 | audio->lsf = (audio->newhead & (1 << 19)) ? 0x0 : 0x1; | ||
28 | audio->mpeg35 = 0; | ||
29 | } | ||
30 | else | ||
31 | { | ||
32 | audio->lsf = 1; | ||
33 | audio->mpeg35 = 1; | ||
34 | } | ||
35 | |||
36 | audio->layer = 4 - ((audio->newhead >> 17) & 3); | ||
37 | if(audio->mpeg35) | ||
38 | audio->sampling_frequency_code = 6 + ((audio->newhead >> 10) & 0x3); | ||
39 | else | ||
40 | audio->sampling_frequency_code = ((audio->newhead >> 10) & 0x3) + (audio->lsf * 3); | ||
41 | |||
42 | audio->error_protection = ((audio->newhead >> 16) & 0x1) ^ 0x1; | ||
43 | |||
44 | audio->bitrate_index = ((audio->newhead >> 12) & 0xf); | ||
45 | audio->padding = ((audio->newhead >> 9) & 0x1); | ||
46 | audio->extension = ((audio->newhead >> 8) & 0x1); | ||
47 | audio->mode = ((audio->newhead >> 6) & 0x3); | ||
48 | audio->mode_ext = ((audio->newhead >> 4) & 0x3); | ||
49 | audio->copyright = ((audio->newhead >> 3) & 0x1); | ||
50 | audio->original = ((audio->newhead >> 2) & 0x1); | ||
51 | audio->emphasis = audio->newhead & 0x3; | ||
52 | audio->channels = (audio->mode == MPG_MD_MONO) ? 1 : 2; | ||
53 | if(audio->channels > 1) | ||
54 | audio->single = -1; | ||
55 | else | ||
56 | audio->single = 3; | ||
57 | |||
58 | audio->prev_framesize = audio->framesize; | ||
59 | |||
60 | if(!audio->bitrate_index) return 1; | ||
61 | audio->bitrate = 1000 * mpeg3_tabsel_123[audio->lsf][audio->layer - 1][audio->bitrate_index]; | ||
62 | |||
63 | switch(audio->layer) | ||
64 | { | ||
65 | case 1: | ||
66 | audio->framesize = (long)mpeg3_tabsel_123[audio->lsf][0][audio->bitrate_index] * 12000; | ||
67 | audio->framesize /= mpeg3_freqs[audio->sampling_frequency_code]; | ||
68 | audio->framesize = ((audio->framesize + audio->padding) << 2) - 4; | ||
69 | break; | ||
70 | case 2: | ||
71 | audio->framesize = (long)mpeg3_tabsel_123[audio->lsf][1][audio->bitrate_index] * 144000; | ||
72 | audio->framesize /= mpeg3_freqs[audio->sampling_frequency_code]; | ||
73 | audio->framesize += audio->padding - 4; | ||
74 | break; | ||
75 | case 3: | ||
76 | if(audio->lsf) | ||
77 | audio->ssize = (audio->channels == 1) ? 9 : 17; | ||
78 | else | ||
79 | audio->ssize = (audio->channels == 1) ? 17 : 32; | ||
80 | if(audio->error_protection) | ||
81 | audio->ssize += 2; | ||
82 | audio->framesize = (long)mpeg3_tabsel_123[audio->lsf][2][audio->bitrate_index] * 144000; | ||
83 | audio->framesize /= mpeg3_freqs[audio->sampling_frequency_code] << (audio->lsf); | ||
84 | audio->framesize = audio->framesize + audio->padding - 4; | ||
85 | break; | ||
86 | default: | ||
87 | return 1; | ||
88 | } | ||
89 | |||
90 | if(audio->framesize > MAXFRAMESIZE) return 1; | ||
91 | |||
92 | return 0; | ||
93 | } | ||
94 | |||
95 | int mpeg3audio_read_frame_body(mpeg3audio_t *audio) | ||
96 | { | ||
97 | int i; | ||
98 | for(i = 0; i < audio->framesize; i++) | ||
99 | { | ||
100 | audio->bsbuf[i] = mpeg3bits_getbits(audio->astream, 8); | ||
101 | } | ||
102 | return 0; | ||
103 | } | ||
104 | |||
105 | /* Seek to the start of the previous header */ | ||
106 | int mpeg3audio_prev_header(mpeg3audio_t *audio) | ||
107 | { | ||
108 | int result = 0, i, len = (int)audio->avg_framesize; | ||
109 | |||
110 | for(i = 0; i < len && !result; i++) | ||
111 | { | ||
112 | mpeg3bits_getbits_reverse(audio->astream, 8); | ||
113 | } | ||
114 | /* Get reading in the forward direction again. */ | ||
115 | result |= mpeg3bits_refill(audio->astream); | ||
116 | return result; | ||
117 | } | ||
118 | |||
119 | /* Read the next header */ | ||
120 | int mpeg3audio_read_header(mpeg3audio_t *audio) | ||
121 | { | ||
122 | unsigned int code; | ||
123 | int i; | ||
124 | int attempt = 0; | ||
125 | int result = 0; | ||
126 | |||
127 | switch(audio->format) | ||
128 | { | ||
129 | case AUDIO_AC3: | ||
130 | result = mpeg3audio_read_ac3_header(audio); | ||
131 | break; | ||
132 | |||
133 | case AUDIO_MPEG: | ||
134 | /* Layer 1 not supported */ | ||
135 | if(audio->layer == 1) | ||
136 | { | ||
137 | fprintf(stderr, "mpeg3audio_new: layer 1 not supported\n"); | ||
138 | result = 1; | ||
139 | } | ||
140 | audio->newhead = mpeg3bits_showbits(audio->astream, 32); | ||
141 | if(!mpeg3bits_eof(audio->astream) && | ||
142 | (mpeg3audio_head_check(audio->newhead) || mpeg3audio_decode_header(audio))) | ||
143 | { | ||
144 | do | ||
145 | { | ||
146 | attempt++; | ||
147 | mpeg3bits_getbyte_noptr(audio->astream); | ||
148 | audio->newhead = mpeg3bits_showbits(audio->astream, 32); | ||
149 | }while(!mpeg3bits_eof(audio->astream) && | ||
150 | attempt < 65536 && | ||
151 | (mpeg3audio_head_check(audio->newhead) || mpeg3audio_decode_header(audio))); | ||
152 | } | ||
153 | |||
154 | /* Skip the 4 bytes containing the header */ | ||
155 | mpeg3bits_getbits(audio->astream, 32); | ||
156 | break; | ||
157 | |||
158 | case AUDIO_PCM: | ||
159 | mpeg3audio_read_pcm_header(audio); | ||
160 | break; | ||
161 | } | ||
162 | return mpeg3bits_eof(audio->astream); | ||
163 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/huffman.h b/core/multimedia/opieplayer/libmpeg3/audio/huffman.h new file mode 100644 index 0000000..a9c8fff --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/huffman.h | |||
@@ -0,0 +1,355 @@ | |||
1 | /********************************************************************** | ||
2 | ** Copyright (C) 2000 Trolltech AS. All rights reserved. | ||
3 | ** | ||
4 | ** This file is part of Qtopia Environment. | ||
5 | ** | ||
6 | ** This file may be distributed and/or modified under the terms of the | ||
7 | ** GNU General Public License version 2 as published by the Free Software | ||
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | ||
9 | ** packaging of this file. | ||
10 | ** | ||
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | ||
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | ||
13 | ** | ||
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | ||
15 | ** | ||
16 | ** Contact info@trolltech.com if any conditions of this licensing are | ||
17 | ** not clear to you. | ||
18 | ** | ||
19 | **********************************************************************/ | ||
20 | #ifndef HUFFMAN_H | ||
21 | #define HUFFMAN_H | ||
22 | |||
23 | /* | ||
24 | * huffman tables ... recalcualted to work with my optimzed | ||
25 | * decoder scheme (MH) | ||
26 | * | ||
27 | * probably we could save a few bytes of memory, because the | ||
28 | * smaller tables are often the part of a bigger table | ||
29 | */ | ||
30 | |||
31 | struct newhuff | ||
32 | { | ||
33 | unsigned int linbits; | ||
34 | short *table; | ||
35 | }; | ||
36 | |||
37 | static short mpeg3_tab0[] = | ||
38 | { | ||
39 | 0 | ||
40 | }; | ||
41 | |||
42 | static short mpeg3_tab1[] = | ||
43 | { | ||
44 | -5, -3, -1, 17, 1, 16, 0 | ||
45 | }; | ||
46 | |||
47 | static short mpeg3_tab2[] = | ||
48 | { | ||
49 | -15, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 17, -1, 1, | ||
50 | 16, 0 | ||
51 | }; | ||
52 | |||
53 | static short mpeg3_tab3[] = | ||
54 | { | ||
55 | -13, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 16, 17, -1, | ||
56 | 1, 0 | ||
57 | }; | ||
58 | |||
59 | static short mpeg3_tab5[] = | ||
60 | { | ||
61 | -29, -25, -23, -15, -7, -5, -3, -1, 51, 35, 50, 49, -3, -1, 19, | ||
62 | 3, -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, 17, -1, 1, 16, | ||
63 | 0 | ||
64 | }; | ||
65 | |||
66 | static short mpeg3_tab6[] = | ||
67 | { | ||
68 | -25, -19, -13, -9, -5, -3, -1, 51, 3, 35, -1, 50, 48, -1, 19, | ||
69 | 49, -3, -1, 34, 2, 18, -3, -1, 33, 32, 1, -1, 17, -1, 16, | ||
70 | 0 | ||
71 | }; | ||
72 | |||
73 | static short mpeg3_tab7[] = | ||
74 | { | ||
75 | -69, -65, -57, -39, -29, -17, -11, -7, -3, -1, 85, 69, -1, 84, 83, | ||
76 | -1, 53, 68, -3, -1, 37, 82, 21, -5, -1, 81, -1, 5, 52, -1, | ||
77 | 80, -1, 67, 51, -5, -3, -1, 36, 66, 20, -1, 65, 64, -11, -7, | ||
78 | -3, -1, 4, 35, -1, 50, 3, -1, 19, 49, -3, -1, 48, 34, 18, | ||
79 | -5, -1, 33, -1, 2, 32, 17, -1, 1, 16, 0 | ||
80 | }; | ||
81 | |||
82 | static short mpeg3_tab8[] = | ||
83 | { | ||
84 | -65, -63, -59, -45, -31, -19, -13, -7, -5, -3, -1, 85, 84, 69, 83, | ||
85 | -3, -1, 53, 68, 37, -3, -1, 82, 5, 21, -5, -1, 81, -1, 52, | ||
86 | 67, -3, -1, 80, 51, 36, -5, -3, -1, 66, 20, 65, -3, -1, 4, | ||
87 | 64, -1, 35, 50, -9, -7, -3, -1, 19, 49, -1, 3, 48, 34, -1, | ||
88 | 2, 32, -1, 18, 33, 17, -3, -1, 1, 16, 0 | ||
89 | }; | ||
90 | |||
91 | static short mpeg3_tab9[] = | ||
92 | { | ||
93 | -63, -53, -41, -29, -19, -11, -5, -3, -1, 85, 69, 53, -1, 83, -1, | ||
94 | 84, 5, -3, -1, 68, 37, -1, 82, 21, -3, -1, 81, 52, -1, 67, | ||
95 | -1, 80, 4, -7, -3, -1, 36, 66, -1, 51, 64, -1, 20, 65, -5, | ||
96 | -3, -1, 35, 50, 19, -1, 49, -1, 3, 48, -5, -3, -1, 34, 2, | ||
97 | 18, -1, 33, 32, -3, -1, 17, 1, -1, 16, 0 | ||
98 | }; | ||
99 | |||
100 | static short mpeg3_tab10[] = | ||
101 | { | ||
102 | -125,-121,-111, -83, -55, -35, -21, -13, -7, -3, -1, 119, 103, -1, 118, | ||
103 | 87, -3, -1, 117, 102, 71, -3, -1, 116, 86, -1, 101, 55, -9, -3, | ||
104 | -1, 115, 70, -3, -1, 85, 84, 99, -1, 39, 114, -11, -5, -3, -1, | ||
105 | 100, 7, 112, -1, 98, -1, 69, 53, -5, -1, 6, -1, 83, 68, 23, | ||
106 | -17, -5, -1, 113, -1, 54, 38, -5, -3, -1, 37, 82, 21, -1, 81, | ||
107 | -1, 52, 67, -3, -1, 22, 97, -1, 96, -1, 5, 80, -19, -11, -7, | ||
108 | -3, -1, 36, 66, -1, 51, 4, -1, 20, 65, -3, -1, 64, 35, -1, | ||
109 | 50, 3, -3, -1, 19, 49, -1, 48, 34, -7, -3, -1, 18, 33, -1, | ||
110 | 2, 32, 17, -1, 1, 16, 0 | ||
111 | }; | ||
112 | |||
113 | static short mpeg3_tab11[] = | ||
114 | { | ||
115 | -121,-113, -89, -59, -43, -27, -17, -7, -3, -1, 119, 103, -1, 118, 117, | ||
116 | -3, -1, 102, 71, -1, 116, -1, 87, 85, -5, -3, -1, 86, 101, 55, | ||
117 | -1, 115, 70, -9, -7, -3, -1, 69, 84, -1, 53, 83, 39, -1, 114, | ||
118 | -1, 100, 7, -5, -1, 113, -1, 23, 112, -3, -1, 54, 99, -1, 96, | ||
119 | -1, 68, 37, -13, -7, -5, -3, -1, 82, 5, 21, 98, -3, -1, 38, | ||
120 | 6, 22, -5, -1, 97, -1, 81, 52, -5, -1, 80, -1, 67, 51, -1, | ||
121 | 36, 66, -15, -11, -7, -3, -1, 20, 65, -1, 4, 64, -1, 35, 50, | ||
122 | -1, 19, 49, -5, -3, -1, 3, 48, 34, 33, -5, -1, 18, -1, 2, | ||
123 | 32, 17, -3, -1, 1, 16, 0 | ||
124 | }; | ||
125 | |||
126 | static short mpeg3_tab12[] = | ||
127 | { | ||
128 | -115, -99, -73, -45, -27, -17, -9, -5, -3, -1, 119, 103, 118, -1, 87, | ||
129 | 117, -3, -1, 102, 71, -1, 116, 101, -3, -1, 86, 55, -3, -1, 115, | ||
130 | 85, 39, -7, -3, -1, 114, 70, -1, 100, 23, -5, -1, 113, -1, 7, | ||
131 | 112, -1, 54, 99, -13, -9, -3, -1, 69, 84, -1, 68, -1, 6, 5, | ||
132 | -1, 38, 98, -5, -1, 97, -1, 22, 96, -3, -1, 53, 83, -1, 37, | ||
133 | 82, -17, -7, -3, -1, 21, 81, -1, 52, 67, -5, -3, -1, 80, 4, | ||
134 | 36, -1, 66, 20, -3, -1, 51, 65, -1, 35, 50, -11, -7, -5, -3, | ||
135 | -1, 64, 3, 48, 19, -1, 49, 34, -1, 18, 33, -7, -5, -3, -1, | ||
136 | 2, 32, 0, 17, -1, 1, 16 | ||
137 | }; | ||
138 | |||
139 | static short mpeg3_tab13[] = | ||
140 | { | ||
141 | -509,-503,-475,-405,-333,-265,-205,-153,-115, -83, -53, -35, -21, -13, -9, | ||
142 | -7, -5, -3, -1, 254, 252, 253, 237, 255, -1, 239, 223, -3, -1, 238, | ||
143 | 207, -1, 222, 191, -9, -3, -1, 251, 206, -1, 220, -1, 175, 233, -1, | ||
144 | 236, 221, -9, -5, -3, -1, 250, 205, 190, -1, 235, 159, -3, -1, 249, | ||
145 | 234, -1, 189, 219, -17, -9, -3, -1, 143, 248, -1, 204, -1, 174, 158, | ||
146 | -5, -1, 142, -1, 127, 126, 247, -5, -1, 218, -1, 173, 188, -3, -1, | ||
147 | 203, 246, 111, -15, -7, -3, -1, 232, 95, -1, 157, 217, -3, -1, 245, | ||
148 | 231, -1, 172, 187, -9, -3, -1, 79, 244, -3, -1, 202, 230, 243, -1, | ||
149 | 63, -1, 141, 216, -21, -9, -3, -1, 47, 242, -3, -1, 110, 156, 15, | ||
150 | -5, -3, -1, 201, 94, 171, -3, -1, 125, 215, 78, -11, -5, -3, -1, | ||
151 | 200, 214, 62, -1, 185, -1, 155, 170, -1, 31, 241, -23, -13, -5, -1, | ||
152 | 240, -1, 186, 229, -3, -1, 228, 140, -1, 109, 227, -5, -1, 226, -1, | ||
153 | 46, 14, -1, 30, 225, -15, -7, -3, -1, 224, 93, -1, 213, 124, -3, | ||
154 | -1, 199, 77, -1, 139, 184, -7, -3, -1, 212, 154, -1, 169, 108, -1, | ||
155 | 198, 61, -37, -21, -9, -5, -3, -1, 211, 123, 45, -1, 210, 29, -5, | ||
156 | -1, 183, -1, 92, 197, -3, -1, 153, 122, 195, -7, -5, -3, -1, 167, | ||
157 | 151, 75, 209, -3, -1, 13, 208, -1, 138, 168, -11, -7, -3, -1, 76, | ||
158 | 196, -1, 107, 182, -1, 60, 44, -3, -1, 194, 91, -3, -1, 181, 137, | ||
159 | 28, -43, -23, -11, -5, -1, 193, -1, 152, 12, -1, 192, -1, 180, 106, | ||
160 | -5, -3, -1, 166, 121, 59, -1, 179, -1, 136, 90, -11, -5, -1, 43, | ||
161 | -1, 165, 105, -1, 164, -1, 120, 135, -5, -1, 148, -1, 119, 118, 178, | ||
162 | -11, -3, -1, 27, 177, -3, -1, 11, 176, -1, 150, 74, -7, -3, -1, | ||
163 | 58, 163, -1, 89, 149, -1, 42, 162, -47, -23, -9, -3, -1, 26, 161, | ||
164 | -3, -1, 10, 104, 160, -5, -3, -1, 134, 73, 147, -3, -1, 57, 88, | ||
165 | -1, 133, 103, -9, -3, -1, 41, 146, -3, -1, 87, 117, 56, -5, -1, | ||
166 | 131, -1, 102, 71, -3, -1, 116, 86, -1, 101, 115, -11, -3, -1, 25, | ||
167 | 145, -3, -1, 9, 144, -1, 72, 132, -7, -5, -1, 114, -1, 70, 100, | ||
168 | 40, -1, 130, 24, -41, -27, -11, -5, -3, -1, 55, 39, 23, -1, 113, | ||
169 | -1, 85, 7, -7, -3, -1, 112, 54, -1, 99, 69, -3, -1, 84, 38, | ||
170 | -1, 98, 53, -5, -1, 129, -1, 8, 128, -3, -1, 22, 97, -1, 6, | ||
171 | 96, -13, -9, -5, -3, -1, 83, 68, 37, -1, 82, 5, -1, 21, 81, | ||
172 | -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, -19, -11, | ||
173 | -5, -1, 65, -1, 4, 64, -3, -1, 35, 50, 19, -3, -1, 49, 3, | ||
174 | -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16, | ||
175 | 0 | ||
176 | }; | ||
177 | |||
178 | static short mpeg3_tab15[] = | ||
179 | { | ||
180 | -495,-445,-355,-263,-183,-115, -77, -43, -27, -13, -7, -3, -1, 255, 239, | ||
181 | -1, 254, 223, -1, 238, -1, 253, 207, -7, -3, -1, 252, 222, -1, 237, | ||
182 | 191, -1, 251, -1, 206, 236, -7, -3, -1, 221, 175, -1, 250, 190, -3, | ||
183 | -1, 235, 205, -1, 220, 159, -15, -7, -3, -1, 249, 234, -1, 189, 219, | ||
184 | -3, -1, 143, 248, -1, 204, 158, -7, -3, -1, 233, 127, -1, 247, 173, | ||
185 | -3, -1, 218, 188, -1, 111, -1, 174, 15, -19, -11, -3, -1, 203, 246, | ||
186 | -3, -1, 142, 232, -1, 95, 157, -3, -1, 245, 126, -1, 231, 172, -9, | ||
187 | -3, -1, 202, 187, -3, -1, 217, 141, 79, -3, -1, 244, 63, -1, 243, | ||
188 | 216, -33, -17, -9, -3, -1, 230, 47, -1, 242, -1, 110, 240, -3, -1, | ||
189 | 31, 241, -1, 156, 201, -7, -3, -1, 94, 171, -1, 186, 229, -3, -1, | ||
190 | 125, 215, -1, 78, 228, -15, -7, -3, -1, 140, 200, -1, 62, 109, -3, | ||
191 | -1, 214, 227, -1, 155, 185, -7, -3, -1, 46, 170, -1, 226, 30, -5, | ||
192 | -1, 225, -1, 14, 224, -1, 93, 213, -45, -25, -13, -7, -3, -1, 124, | ||
193 | 199, -1, 77, 139, -1, 212, -1, 184, 154, -7, -3, -1, 169, 108, -1, | ||
194 | 198, 61, -1, 211, 210, -9, -5, -3, -1, 45, 13, 29, -1, 123, 183, | ||
195 | -5, -1, 209, -1, 92, 208, -1, 197, 138, -17, -7, -3, -1, 168, 76, | ||
196 | -1, 196, 107, -5, -1, 182, -1, 153, 12, -1, 60, 195, -9, -3, -1, | ||
197 | 122, 167, -1, 166, -1, 192, 11, -1, 194, -1, 44, 91, -55, -29, -15, | ||
198 | -7, -3, -1, 181, 28, -1, 137, 152, -3, -1, 193, 75, -1, 180, 106, | ||
199 | -5, -3, -1, 59, 121, 179, -3, -1, 151, 136, -1, 43, 90, -11, -5, | ||
200 | -1, 178, -1, 165, 27, -1, 177, -1, 176, 105, -7, -3, -1, 150, 74, | ||
201 | -1, 164, 120, -3, -1, 135, 58, 163, -17, -7, -3, -1, 89, 149, -1, | ||
202 | 42, 162, -3, -1, 26, 161, -3, -1, 10, 160, 104, -7, -3, -1, 134, | ||
203 | 73, -1, 148, 57, -5, -1, 147, -1, 119, 9, -1, 88, 133, -53, -29, | ||
204 | -13, -7, -3, -1, 41, 103, -1, 118, 146, -1, 145, -1, 25, 144, -7, | ||
205 | -3, -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 71, -7, | ||
206 | -3, -1, 40, 130, -1, 24, 129, -7, -3, -1, 116, 8, -1, 128, 86, | ||
207 | -3, -1, 101, 55, -1, 115, 70, -17, -7, -3, -1, 39, 114, -1, 100, | ||
208 | 23, -3, -1, 85, 113, -3, -1, 7, 112, 54, -7, -3, -1, 99, 69, | ||
209 | -1, 84, 38, -3, -1, 98, 22, -3, -1, 6, 96, 53, -33, -19, -9, | ||
210 | -5, -1, 97, -1, 83, 68, -1, 37, 82, -3, -1, 21, 81, -3, -1, | ||
211 | 5, 80, 52, -7, -3, -1, 67, 36, -1, 66, 51, -1, 65, -1, 20, | ||
212 | 4, -9, -3, -1, 35, 50, -3, -1, 64, 3, 19, -3, -1, 49, 48, | ||
213 | 34, -9, -7, -3, -1, 18, 33, -1, 2, 32, 17, -3, -1, 1, 16, | ||
214 | 0 | ||
215 | }; | ||
216 | |||
217 | static short mpeg3_tab16[] = | ||
218 | { | ||
219 | -509,-503,-461,-323,-103, -37, -27, -15, -7, -3, -1, 239, 254, -1, 223, | ||
220 | 253, -3, -1, 207, 252, -1, 191, 251, -5, -1, 175, -1, 250, 159, -3, | ||
221 | -1, 249, 248, 143, -7, -3, -1, 127, 247, -1, 111, 246, 255, -9, -5, | ||
222 | -3, -1, 95, 245, 79, -1, 244, 243, -53, -1, 240, -1, 63, -29, -19, | ||
223 | -13, -7, -5, -1, 206, -1, 236, 221, 222, -1, 233, -1, 234, 217, -1, | ||
224 | 238, -1, 237, 235, -3, -1, 190, 205, -3, -1, 220, 219, 174, -11, -5, | ||
225 | -1, 204, -1, 173, 218, -3, -1, 126, 172, 202, -5, -3, -1, 201, 125, | ||
226 | 94, 189, 242, -93, -5, -3, -1, 47, 15, 31, -1, 241, -49, -25, -13, | ||
227 | -5, -1, 158, -1, 188, 203, -3, -1, 142, 232, -1, 157, 231, -7, -3, | ||
228 | -1, 187, 141, -1, 216, 110, -1, 230, 156, -13, -7, -3, -1, 171, 186, | ||
229 | -1, 229, 215, -1, 78, -1, 228, 140, -3, -1, 200, 62, -1, 109, -1, | ||
230 | 214, 155, -19, -11, -5, -3, -1, 185, 170, 225, -1, 212, -1, 184, 169, | ||
231 | -5, -1, 123, -1, 183, 208, 227, -7, -3, -1, 14, 224, -1, 93, 213, | ||
232 | -3, -1, 124, 199, -1, 77, 139, -75, -45, -27, -13, -7, -3, -1, 154, | ||
233 | 108, -1, 198, 61, -3, -1, 92, 197, 13, -7, -3, -1, 138, 168, -1, | ||
234 | 153, 76, -3, -1, 182, 122, 60, -11, -5, -3, -1, 91, 137, 28, -1, | ||
235 | 192, -1, 152, 121, -1, 226, -1, 46, 30, -15, -7, -3, -1, 211, 45, | ||
236 | -1, 210, 209, -5, -1, 59, -1, 151, 136, 29, -7, -3, -1, 196, 107, | ||
237 | -1, 195, 167, -1, 44, -1, 194, 181, -23, -13, -7, -3, -1, 193, 12, | ||
238 | -1, 75, 180, -3, -1, 106, 166, 179, -5, -3, -1, 90, 165, 43, -1, | ||
239 | 178, 27, -13, -5, -1, 177, -1, 11, 176, -3, -1, 105, 150, -1, 74, | ||
240 | 164, -5, -3, -1, 120, 135, 163, -3, -1, 58, 89, 42, -97, -57, -33, | ||
241 | -19, -11, -5, -3, -1, 149, 104, 161, -3, -1, 134, 119, 148, -5, -3, | ||
242 | -1, 73, 87, 103, 162, -5, -1, 26, -1, 10, 160, -3, -1, 57, 147, | ||
243 | -1, 88, 133, -9, -3, -1, 41, 146, -3, -1, 118, 9, 25, -5, -1, | ||
244 | 145, -1, 144, 72, -3, -1, 132, 117, -1, 56, 131, -21, -11, -5, -3, | ||
245 | -1, 102, 40, 130, -3, -1, 71, 116, 24, -3, -1, 129, 128, -3, -1, | ||
246 | 8, 86, 55, -9, -5, -1, 115, -1, 101, 70, -1, 39, 114, -5, -3, | ||
247 | -1, 100, 85, 7, 23, -23, -13, -5, -1, 113, -1, 112, 54, -3, -1, | ||
248 | 99, 69, -1, 84, 38, -3, -1, 98, 22, -1, 97, -1, 6, 96, -9, | ||
249 | -5, -1, 83, -1, 53, 68, -1, 37, 82, -1, 81, -1, 21, 5, -33, | ||
250 | -23, -13, -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, | ||
251 | -5, -1, 65, -1, 4, 64, -1, 35, 50, -3, -1, 19, 49, -3, -1, | ||
252 | 3, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16, | ||
253 | 0 | ||
254 | }; | ||
255 | |||
256 | static short mpeg3_tab24[] = | ||
257 | { | ||
258 | -451,-117, -43, -25, -15, -7, -3, -1, 239, 254, -1, 223, 253, -3, -1, | ||
259 | 207, 252, -1, 191, 251, -5, -1, 250, -1, 175, 159, -1, 249, 248, -9, | ||
260 | -5, -3, -1, 143, 127, 247, -1, 111, 246, -3, -1, 95, 245, -1, 79, | ||
261 | 244, -71, -7, -3, -1, 63, 243, -1, 47, 242, -5, -1, 241, -1, 31, | ||
262 | 240, -25, -9, -1, 15, -3, -1, 238, 222, -1, 237, 206, -7, -3, -1, | ||
263 | 236, 221, -1, 190, 235, -3, -1, 205, 220, -1, 174, 234, -15, -7, -3, | ||
264 | -1, 189, 219, -1, 204, 158, -3, -1, 233, 173, -1, 218, 188, -7, -3, | ||
265 | -1, 203, 142, -1, 232, 157, -3, -1, 217, 126, -1, 231, 172, 255,-235, | ||
266 | -143, -77, -45, -25, -15, -7, -3, -1, 202, 187, -1, 141, 216, -5, -3, | ||
267 | -1, 14, 224, 13, 230, -5, -3, -1, 110, 156, 201, -1, 94, 186, -9, | ||
268 | -5, -1, 229, -1, 171, 125, -1, 215, 228, -3, -1, 140, 200, -3, -1, | ||
269 | 78, 46, 62, -15, -7, -3, -1, 109, 214, -1, 227, 155, -3, -1, 185, | ||
270 | 170, -1, 226, 30, -7, -3, -1, 225, 93, -1, 213, 124, -3, -1, 199, | ||
271 | 77, -1, 139, 184, -31, -15, -7, -3, -1, 212, 154, -1, 169, 108, -3, | ||
272 | -1, 198, 61, -1, 211, 45, -7, -3, -1, 210, 29, -1, 123, 183, -3, | ||
273 | -1, 209, 92, -1, 197, 138, -17, -7, -3, -1, 168, 153, -1, 76, 196, | ||
274 | -3, -1, 107, 182, -3, -1, 208, 12, 60, -7, -3, -1, 195, 122, -1, | ||
275 | 167, 44, -3, -1, 194, 91, -1, 181, 28, -57, -35, -19, -7, -3, -1, | ||
276 | 137, 152, -1, 193, 75, -5, -3, -1, 192, 11, 59, -3, -1, 176, 10, | ||
277 | 26, -5, -1, 180, -1, 106, 166, -3, -1, 121, 151, -3, -1, 160, 9, | ||
278 | 144, -9, -3, -1, 179, 136, -3, -1, 43, 90, 178, -7, -3, -1, 165, | ||
279 | 27, -1, 177, 105, -1, 150, 164, -17, -9, -5, -3, -1, 74, 120, 135, | ||
280 | -1, 58, 163, -3, -1, 89, 149, -1, 42, 162, -7, -3, -1, 161, 104, | ||
281 | -1, 134, 119, -3, -1, 73, 148, -1, 57, 147, -63, -31, -15, -7, -3, | ||
282 | -1, 88, 133, -1, 41, 103, -3, -1, 118, 146, -1, 25, 145, -7, -3, | ||
283 | -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 40, -17, -7, | ||
284 | -3, -1, 130, 24, -1, 71, 116, -5, -1, 129, -1, 8, 128, -1, 86, | ||
285 | 101, -7, -5, -1, 23, -1, 7, 112, 115, -3, -1, 55, 39, 114, -15, | ||
286 | -7, -3, -1, 70, 100, -1, 85, 113, -3, -1, 54, 99, -1, 69, 84, | ||
287 | -7, -3, -1, 38, 98, -1, 22, 97, -5, -3, -1, 6, 96, 53, -1, | ||
288 | 83, 68, -51, -37, -23, -15, -9, -3, -1, 37, 82, -1, 21, -1, 5, | ||
289 | 80, -1, 81, -1, 52, 67, -3, -1, 36, 66, -1, 51, 20, -9, -5, | ||
290 | -1, 65, -1, 4, 64, -1, 35, 50, -1, 19, 49, -7, -5, -3, -1, | ||
291 | 3, 48, 34, 18, -1, 33, -1, 2, 32, -3, -1, 17, 1, -1, 16, | ||
292 | 0 | ||
293 | }; | ||
294 | |||
295 | static short mpeg3_tab_c0[] = | ||
296 | { | ||
297 | -29, -21, -13, -7, -3, -1, 11, 15, -1, 13, 14, -3, -1, 7, 5, | ||
298 | 9, -3, -1, 6, 3, -1, 10, 12, -3, -1, 2, 1, -1, 4, 8, | ||
299 | 0 | ||
300 | }; | ||
301 | |||
302 | static short mpeg3_tab_c1[] = | ||
303 | { | ||
304 | -15, -7, -3, -1, 15, 14, -1, 13, 12, -3, -1, 11, 10, -1, 9, | ||
305 | 8, -7, -3, -1, 7, 6, -1, 5, 4, -3, -1, 3, 2, -1, 1, | ||
306 | 0 | ||
307 | }; | ||
308 | |||
309 | |||
310 | |||
311 | static struct newhuff mpeg3_ht[] = | ||
312 | { | ||
313 | { /* 0 */ 0 , mpeg3_tab0 } , | ||
314 | { /* 2 */ 0 , mpeg3_tab1 } , | ||
315 | { /* 3 */ 0 , mpeg3_tab2 } , | ||
316 | { /* 3 */ 0 , mpeg3_tab3 } , | ||
317 | { /* 0 */ 0 , mpeg3_tab0 } , | ||
318 | { /* 4 */ 0 , mpeg3_tab5 } , | ||
319 | { /* 4 */ 0 , mpeg3_tab6 } , | ||
320 | { /* 6 */ 0 , mpeg3_tab7 } , | ||
321 | { /* 6 */ 0 , mpeg3_tab8 } , | ||
322 | { /* 6 */ 0 , mpeg3_tab9 } , | ||
323 | { /* 8 */ 0 , mpeg3_tab10 } , | ||
324 | { /* 8 */ 0 , mpeg3_tab11 } , | ||
325 | { /* 8 */ 0 , mpeg3_tab12 } , | ||
326 | { /* 16 */ 0 , mpeg3_tab13 } , | ||
327 | { /* 0 */ 0 , mpeg3_tab0 } , | ||
328 | { /* 16 */ 0 , mpeg3_tab15 } , | ||
329 | |||
330 | { /* 16 */ 1 , mpeg3_tab16 } , | ||
331 | { /* 16 */ 2 , mpeg3_tab16 } , | ||
332 | { /* 16 */ 3 , mpeg3_tab16 } , | ||
333 | { /* 16 */ 4 , mpeg3_tab16 } , | ||
334 | { /* 16 */ 6 , mpeg3_tab16 } , | ||
335 | { /* 16 */ 8 , mpeg3_tab16 } , | ||
336 | { /* 16 */ 10, mpeg3_tab16 } , | ||
337 | { /* 16 */ 13, mpeg3_tab16 } , | ||
338 | { /* 16 */ 4 , mpeg3_tab24 } , | ||
339 | { /* 16 */ 5 , mpeg3_tab24 } , | ||
340 | { /* 16 */ 6 , mpeg3_tab24 } , | ||
341 | { /* 16 */ 7 , mpeg3_tab24 } , | ||
342 | { /* 16 */ 8 , mpeg3_tab24 } , | ||
343 | { /* 16 */ 9 , mpeg3_tab24 } , | ||
344 | { /* 16 */ 11, mpeg3_tab24 } , | ||
345 | { /* 16 */ 13, mpeg3_tab24 } | ||
346 | }; | ||
347 | |||
348 | static struct newhuff mpeg3_htc[] = | ||
349 | { | ||
350 | { /* 1 , 1 , */ 0 , mpeg3_tab_c0 } , | ||
351 | { /* 1 , 1 , */ 0 , mpeg3_tab_c1 } | ||
352 | }; | ||
353 | |||
354 | |||
355 | #endif | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/layer1.c b/core/multimedia/opieplayer/libmpeg3/audio/layer1.c new file mode 100644 index 0000000..0c355f3 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/layer1.c | |||
@@ -0,0 +1,6 @@ | |||
1 | #include "mpeg3audio.h" | ||
2 | |||
3 | int mpeg3audio_dolayer1(mpeg3audio_t *audio) | ||
4 | { | ||
5 | ; | ||
6 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/layer2.c b/core/multimedia/opieplayer/libmpeg3/audio/layer2.c new file mode 100644 index 0000000..01582fe --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/layer2.c | |||
@@ -0,0 +1,418 @@ | |||
1 | /* | ||
2 | * most other tables are calculated on program start (which is (of course) | ||
3 | * not ISO-conform) .. | ||
4 | * Layer-3 huffman table is in huffman.h | ||
5 | */ | ||
6 | |||
7 | #include "mpeg3audio.h" | ||
8 | #include "../libmpeg3.h" | ||
9 | #include "../mpeg3protos.h" | ||
10 | #include "tables.h" | ||
11 | |||
12 | struct al_table alloc_0[] = { | ||
13 | {4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, | ||
14 | {11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, | ||
15 | {4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, | ||
16 | {11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, | ||
17 | {4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, | ||
18 | {11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, | ||
19 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
20 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
21 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
22 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
23 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
24 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
25 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
26 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
27 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
28 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
29 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
30 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
31 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
32 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
33 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
34 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
35 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
36 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
37 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
38 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
39 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
40 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
41 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
42 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
43 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
44 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
45 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
46 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
47 | {2,0},{5,3},{7,5},{16,-32767}, | ||
48 | {2,0},{5,3},{7,5},{16,-32767}, | ||
49 | {2,0},{5,3},{7,5},{16,-32767}, | ||
50 | {2,0},{5,3},{7,5},{16,-32767} }; | ||
51 | |||
52 | struct al_table alloc_1[] = { | ||
53 | {4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, | ||
54 | {11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, | ||
55 | {4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, | ||
56 | {11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, | ||
57 | {4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, | ||
58 | {11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, | ||
59 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
60 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
61 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
62 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
63 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
64 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
65 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
66 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
67 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
68 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
69 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
70 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
71 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
72 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
73 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
74 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, | ||
75 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
76 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
77 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
78 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
79 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
80 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
81 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
82 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
83 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
84 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
85 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
86 | {3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, | ||
87 | {2,0},{5,3},{7,5},{16,-32767}, | ||
88 | {2,0},{5,3},{7,5},{16,-32767}, | ||
89 | {2,0},{5,3},{7,5},{16,-32767}, | ||
90 | {2,0},{5,3},{7,5},{16,-32767}, | ||
91 | {2,0},{5,3},{7,5},{16,-32767}, | ||
92 | {2,0},{5,3},{7,5},{16,-32767}, | ||
93 | {2,0},{5,3},{7,5},{16,-32767} }; | ||
94 | |||
95 | struct al_table alloc_2[] = { | ||
96 | {4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, | ||
97 | {10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, | ||
98 | {4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, | ||
99 | {10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, | ||
100 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
101 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
102 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
103 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
104 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
105 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} }; | ||
106 | |||
107 | struct al_table alloc_3[] = { | ||
108 | {4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, | ||
109 | {10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, | ||
110 | {4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, | ||
111 | {10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, | ||
112 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
113 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
114 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
115 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
116 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
117 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
118 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
119 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
120 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
121 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} }; | ||
122 | |||
123 | struct al_table alloc_4[] = { | ||
124 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
125 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, | ||
126 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
127 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, | ||
128 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
129 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, | ||
130 | {4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, | ||
131 | {9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, | ||
132 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
133 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
134 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
135 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
136 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
137 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
138 | {3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, | ||
139 | {2,0},{5,3},{7,5},{10,9}, | ||
140 | {2,0},{5,3},{7,5},{10,9}, | ||
141 | {2,0},{5,3},{7,5},{10,9}, | ||
142 | {2,0},{5,3},{7,5},{10,9}, | ||
143 | {2,0},{5,3},{7,5},{10,9}, | ||
144 | {2,0},{5,3},{7,5},{10,9}, | ||
145 | {2,0},{5,3},{7,5},{10,9}, | ||
146 | {2,0},{5,3},{7,5},{10,9}, | ||
147 | {2,0},{5,3},{7,5},{10,9}, | ||
148 | {2,0},{5,3},{7,5},{10,9}, | ||
149 | {2,0},{5,3},{7,5},{10,9}, | ||
150 | {2,0},{5,3},{7,5},{10,9}, | ||
151 | {2,0},{5,3},{7,5},{10,9}, | ||
152 | {2,0},{5,3},{7,5},{10,9}, | ||
153 | {2,0},{5,3},{7,5},{10,9}, | ||
154 | {2,0},{5,3},{7,5},{10,9}, | ||
155 | {2,0},{5,3},{7,5},{10,9}, | ||
156 | {2,0},{5,3},{7,5},{10,9}, | ||
157 | {2,0},{5,3},{7,5},{10,9} }; | ||
158 | |||
159 | |||
160 | int mpeg3audio_II_select_table(mpeg3audio_t *audio) | ||
161 | { | ||
162 | static int translate[3][2][16] = | ||
163 | {{{ 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0}, | ||
164 | { 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0}}, | ||
165 | {{ 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0}, | ||
166 | { 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0}}, | ||
167 | {{ 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0}, | ||
168 | { 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0}}}; | ||
169 | int table, sblim; | ||
170 | static struct al_table *tables[5] = | ||
171 | {alloc_0, alloc_1, alloc_2, alloc_3, alloc_4}; | ||
172 | static int sblims[5] = {27, 30, 8, 12, 30}; | ||
173 | |||
174 | if(audio->lsf) | ||
175 | table = 4; | ||
176 | else | ||
177 | table = translate[audio->sampling_frequency_code][2 - audio->channels][audio->bitrate_index]; | ||
178 | sblim = sblims[table]; | ||
179 | |||
180 | audio->alloc = tables[table]; | ||
181 | audio->II_sblimit = sblim; | ||
182 | return 0; | ||
183 | } | ||
184 | |||
185 | int mpeg3audio_II_step_one(mpeg3audio_t *audio, unsigned int *bit_alloc, int *scale) | ||
186 | { | ||
187 | int stereo = audio->channels - 1; | ||
188 | int sblimit = audio->II_sblimit; | ||
189 | int jsbound = audio->jsbound; | ||
190 | int sblimit2 = audio->II_sblimit << stereo; | ||
191 | struct al_table *alloc1 = audio->alloc; | ||
192 | int i, result = 0; | ||
193 | unsigned int *scfsi_buf = audio->layer2_scfsi_buf; | ||
194 | unsigned int *scfsi, *bita; | ||
195 | int sc, step; | ||
196 | |||
197 | bita = bit_alloc; | ||
198 | if(stereo) | ||
199 | { | ||
200 | /* Stereo */ | ||
201 | for(i = jsbound;i ; i--, alloc1 += (1 << step)) | ||
202 | { | ||
203 | *bita++ = (char)mpeg3bits_getbits(audio->astream, step = alloc1->bits); | ||
204 | *bita++ = (char)mpeg3bits_getbits(audio->astream, step); | ||
205 | } | ||
206 | for(i = sblimit-jsbound; i; i--, alloc1 += (1 << step)) | ||
207 | { | ||
208 | bita[0] = (char)mpeg3bits_getbits(audio->astream, step = alloc1->bits); | ||
209 | bita[1] = bita[0]; | ||
210 | bita += 2; | ||
211 | } | ||
212 | bita = bit_alloc; | ||
213 | scfsi = scfsi_buf; | ||
214 | for(i = sblimit2; i; i--) | ||
215 | if(*bita++) *scfsi++ = (char)mpeg3bits_getbits(audio->astream, 2); | ||
216 | } | ||
217 | else | ||
218 | { | ||
219 | /* mono */ | ||
220 | for(i = sblimit; i; i--, alloc1 += (1 << step)) | ||
221 | *bita++ = (char)mpeg3bits_getbits(audio->astream, step = alloc1->bits); | ||
222 | bita = bit_alloc; | ||
223 | scfsi = scfsi_buf; | ||
224 | for(i = sblimit; i; i--) if (*bita++) *scfsi++ = (char)mpeg3bits_getbits(audio->astream, 2); | ||
225 | } | ||
226 | |||
227 | bita = bit_alloc; | ||
228 | scfsi = scfsi_buf; | ||
229 | for(i = sblimit2; i; i--) | ||
230 | { | ||
231 | if(*bita++) | ||
232 | switch(*scfsi++) | ||
233 | { | ||
234 | case 0: | ||
235 | *scale++ = mpeg3bits_getbits(audio->astream, 6); | ||
236 | *scale++ = mpeg3bits_getbits(audio->astream, 6); | ||
237 | *scale++ = mpeg3bits_getbits(audio->astream, 6); | ||
238 | break; | ||
239 | case 1 : | ||
240 | *scale++ = sc = mpeg3bits_getbits(audio->astream, 6); | ||
241 | *scale++ = sc; | ||
242 | *scale++ = mpeg3bits_getbits(audio->astream, 6); | ||
243 | break; | ||
244 | case 2: | ||
245 | *scale++ = sc = mpeg3bits_getbits(audio->astream, 6); | ||
246 | *scale++ = sc; | ||
247 | *scale++ = sc; | ||
248 | break; | ||
249 | default: /* case 3 */ | ||
250 | *scale++ = mpeg3bits_getbits(audio->astream, 6); | ||
251 | *scale++ = sc = mpeg3bits_getbits(audio->astream, 6); | ||
252 | *scale++ = sc; | ||
253 | break; | ||
254 | } | ||
255 | } | ||
256 | return result | mpeg3bits_error(audio->astream); | ||
257 | } | ||
258 | |||
259 | int mpeg3audio_II_step_two(mpeg3audio_t *audio, unsigned int *bit_alloc, mpeg3_real_t fraction[2][4][SBLIMIT], int *scale, int x1) | ||
260 | { | ||
261 | int i, j, k, ba, result = 0; | ||
262 | int channels = audio->channels; | ||
263 | int sblimit = audio->II_sblimit; | ||
264 | int jsbound = audio->jsbound; | ||
265 | struct al_table *alloc2, *alloc1 = audio->alloc; | ||
266 | unsigned int *bita = bit_alloc; | ||
267 | int d1, step, test; | ||
268 | |||
269 | for(i = 0; i < jsbound; i++, alloc1 += (1 << step)) | ||
270 | { | ||
271 | step = alloc1->bits; | ||
272 | for(j = 0; j < channels; j++) | ||
273 | { | ||
274 | if(ba = *bita++) | ||
275 | { | ||
276 | k = (alloc2 = alloc1 + ba)->bits; | ||
277 | if((d1 = alloc2->d) < 0) | ||
278 | { | ||
279 | mpeg3_real_t cm = mpeg3_muls[k][scale[x1]]; | ||
280 | |||
281 | fraction[j][0][i] = ((mpeg3_real_t)((int)mpeg3bits_getbits(audio->astream, k) + d1)) * cm; | ||
282 | fraction[j][1][i] = ((mpeg3_real_t)((int)mpeg3bits_getbits(audio->astream, k) + d1)) * cm; | ||
283 | fraction[j][2][i] = ((mpeg3_real_t)((int)mpeg3bits_getbits(audio->astream, k) + d1)) * cm; | ||
284 | } | ||
285 | else | ||
286 | { | ||
287 | static int *table[] = | ||
288 | {0, 0, 0, mpeg3_grp_3tab, 0, mpeg3_grp_5tab, 0, 0, 0, mpeg3_grp_9tab}; | ||
289 | unsigned int idx, *tab, m = scale[x1]; | ||
290 | |||
291 | idx = (unsigned int)mpeg3bits_getbits(audio->astream, k); | ||
292 | tab = (unsigned int*)(table[d1] + idx + idx + idx); | ||
293 | fraction[j][0][i] = mpeg3_muls[*tab++][m]; | ||
294 | fraction[j][1][i] = mpeg3_muls[*tab++][m]; | ||
295 | fraction[j][2][i] = mpeg3_muls[*tab][m]; | ||
296 | } | ||
297 | scale += 3; | ||
298 | } | ||
299 | else | ||
300 | fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0; | ||
301 | } | ||
302 | } | ||
303 | |||
304 | for(i = jsbound; i < sblimit; i++, alloc1 += (1 << step)) | ||
305 | { | ||
306 | step = alloc1->bits; | ||
307 | /* channel 1 and channel 2 bitalloc are the same */ | ||
308 | bita++; | ||
309 | if((ba = *bita++)) | ||
310 | { | ||
311 | k=(alloc2 = alloc1+ba)->bits; | ||
312 | if((d1 = alloc2->d) < 0) | ||
313 | { | ||
314 | mpeg3_real_t cm; | ||
315 | |||
316 | cm = mpeg3_muls[k][scale[x1 + 3]]; | ||
317 | fraction[1][0][i] = (fraction[0][0][i] = (mpeg3_real_t)((int)mpeg3bits_getbits(audio->astream, k) + d1)) * cm; | ||
318 | fraction[1][1][i] = (fraction[0][1][i] = (mpeg3_real_t)((int)mpeg3bits_getbits(audio->astream, k) + d1)) * cm; | ||
319 | fraction[1][2][i] = (fraction[0][2][i] = (mpeg3_real_t)((int)mpeg3bits_getbits(audio->astream, k) + d1)) * cm; | ||
320 | cm = mpeg3_muls[k][scale[x1]]; | ||
321 | fraction[0][0][i] *= cm; | ||
322 | fraction[0][1][i] *= cm; | ||
323 | fraction[0][2][i] *= cm; | ||
324 | } | ||
325 | else | ||
326 | { | ||
327 | static int *table[] = {0, 0, 0, mpeg3_grp_3tab, 0, mpeg3_grp_5tab, 0, 0, 0, mpeg3_grp_9tab}; | ||
328 | unsigned int idx, *tab, m1, m2; | ||
329 | |||
330 | m1 = scale[x1]; | ||
331 | m2 = scale[x1+3]; | ||
332 | idx = (unsigned int)mpeg3bits_getbits(audio->astream, k); | ||
333 | tab = (unsigned int*)(table[d1] + idx + idx + idx); | ||
334 | fraction[0][0][i] = mpeg3_muls[*tab][m1]; | ||
335 | fraction[1][0][i] = mpeg3_muls[*tab++][m2]; | ||
336 | fraction[0][1][i] = mpeg3_muls[*tab][m1]; | ||
337 | fraction[1][1][i] = mpeg3_muls[*tab++][m2]; | ||
338 | fraction[0][2][i] = mpeg3_muls[*tab][m1]; | ||
339 | fraction[1][2][i] = mpeg3_muls[*tab][m2]; | ||
340 | } | ||
341 | scale += 6; | ||
342 | } | ||
343 | else | ||
344 | { | ||
345 | fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = | ||
346 | fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0; | ||
347 | } | ||
348 | /* | ||
349 | should we use individual scalefac for channel 2 or | ||
350 | is the current way the right one , where we just copy channel 1 to | ||
351 | channel 2 ?? | ||
352 | The current 'strange' thing is, that we throw away the scalefac | ||
353 | values for the second channel ...!! | ||
354 | -> changed .. now we use the scalefac values of channel one !! | ||
355 | */ | ||
356 | } | ||
357 | |||
358 | if(sblimit > SBLIMIT) sblimit = SBLIMIT; | ||
359 | |||
360 | for(i = sblimit; i < SBLIMIT; i++) | ||
361 | for(j = 0; j < channels; j++) | ||
362 | fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0; | ||
363 | |||
364 | return result | mpeg3bits_error(audio->astream); | ||
365 | } | ||
366 | |||
367 | int mpeg3audio_dolayer2(mpeg3audio_t *audio) | ||
368 | { | ||
369 | int i, j, result = 0; | ||
370 | int channels = audio->channels; | ||
371 | mpeg3_real_t fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */ | ||
372 | unsigned int bit_alloc[64]; | ||
373 | int scale[192]; | ||
374 | int single = audio->single; | ||
375 | |||
376 | if(audio->error_protection) | ||
377 | mpeg3bits_getbits(audio->astream, 16); | ||
378 | |||
379 | mpeg3audio_II_select_table(audio); | ||
380 | |||
381 | audio->jsbound = (audio->mode == MPG_MD_JOINT_STEREO) ? | ||
382 | (audio->mode_ext << 2) + 4 : audio->II_sblimit; | ||
383 | |||
384 | if(channels == 1 || single == 3) | ||
385 | single = 0; | ||
386 | |||
387 | result |= mpeg3audio_II_step_one(audio, bit_alloc, scale); | ||
388 | |||
389 | for(i = 0; i < SCALE_BLOCK && !result; i++) | ||
390 | { | ||
391 | result |= mpeg3audio_II_step_two(audio, bit_alloc, fraction, scale, i >> 2); | ||
392 | |||
393 | for(j = 0; j < 3; j++) | ||
394 | { | ||
395 | if(single >= 0) | ||
396 | { | ||
397 | /* Monaural */ | ||
398 | mpeg3audio_synth_mono(audio, fraction[single][j], audio->pcm_sample, &(audio->pcm_point)); | ||
399 | } | ||
400 | else | ||
401 | { | ||
402 | /* Stereo */ | ||
403 | int p1 = audio->pcm_point; | ||
404 | mpeg3audio_synth_stereo(audio, fraction[0][j], 0, audio->pcm_sample, &p1); | ||
405 | mpeg3audio_synth_stereo(audio, fraction[1][j], 1, audio->pcm_sample, &(audio->pcm_point)); | ||
406 | } | ||
407 | |||
408 | if(audio->pcm_point / audio->channels >= audio->pcm_allocated - MPEG3AUDIO_PADDING * audio->channels) | ||
409 | { | ||
410 | /* Need more room */ | ||
411 | mpeg3audio_replace_buffer(audio, audio->pcm_allocated + MPEG3AUDIO_PADDING * audio->channels); | ||
412 | } | ||
413 | } | ||
414 | } | ||
415 | |||
416 | |||
417 | return result; | ||
418 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/layer3.c b/core/multimedia/opieplayer/libmpeg3/audio/layer3.c new file mode 100644 index 0000000..b8a5f06 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/layer3.c | |||
@@ -0,0 +1,1254 @@ | |||
1 | #include "huffman.h" | ||
2 | #include "mpeg3audio.h" | ||
3 | #include "../libmpeg3.h" | ||
4 | #include "../mpeg3protos.h" | ||
5 | #include "tables.h" | ||
6 | |||
7 | #include <stdio.h> | ||
8 | #include <string.h> | ||
9 | |||
10 | struct gr_info_s { | ||
11 | int scfsi; | ||
12 | unsigned part2_3_length; | ||
13 | unsigned big_values; | ||
14 | unsigned scalefac_compress; | ||
15 | unsigned block_type; | ||
16 | unsigned mixed_block_flag; | ||
17 | unsigned table_select[3]; | ||
18 | unsigned subblock_gain[3]; | ||
19 | unsigned maxband[3]; | ||
20 | unsigned maxbandl; | ||
21 | unsigned maxb; | ||
22 | unsigned region1start; | ||
23 | unsigned region2start; | ||
24 | unsigned preflag; | ||
25 | unsigned scalefac_scale; | ||
26 | unsigned count1table_select; | ||
27 | mpeg3_real_t *full_gain[3]; | ||
28 | mpeg3_real_t *pow2gain; | ||
29 | }; | ||
30 | |||
31 | struct mpeg3_III_sideinfo | ||
32 | { | ||
33 | unsigned main_data_begin; | ||
34 | unsigned private_bits; | ||
35 | struct | ||
36 | { | ||
37 | struct gr_info_s gr[2]; | ||
38 | } ch[2]; | ||
39 | }; | ||
40 | |||
41 | int mpeg3audio_III_get_scale_factors_1(mpeg3audio_t *audio, | ||
42 | int *scf, | ||
43 | struct gr_info_s *gr_info, | ||
44 | int ch, | ||
45 | int gr) | ||
46 | { | ||
47 | static unsigned char slen[2][16] = | ||
48 | {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4}, | ||
49 | {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}}; | ||
50 | int numbits; | ||
51 | int num0 = slen[0][gr_info->scalefac_compress]; | ||
52 | int num1 = slen[1][gr_info->scalefac_compress]; | ||
53 | |||
54 | if (gr_info->block_type == 2) | ||
55 | { | ||
56 | int i = 18; | ||
57 | numbits = (num0 + num1) * 18; | ||
58 | |||
59 | if (gr_info->mixed_block_flag) | ||
60 | { | ||
61 | for(i = 8; i; i--) | ||
62 | *scf++ = mpeg3bits_getbits(audio->astream, num0); | ||
63 | i = 9; | ||
64 | /* num0 * 17 + num1 * 18 */ | ||
65 | numbits -= num0; | ||
66 | } | ||
67 | |||
68 | for( ; i; i--) | ||
69 | *scf++ = mpeg3bits_getbits(audio->astream, num0); | ||
70 | for(i = 18; i; i--) | ||
71 | *scf++ = mpeg3bits_getbits(audio->astream, num1); | ||
72 | /* short[13][0..2] = 0 */ | ||
73 | *scf++ = 0; | ||
74 | *scf++ = 0; | ||
75 | *scf++ = 0; | ||
76 | } | ||
77 | else | ||
78 | { | ||
79 | int i; | ||
80 | int scfsi = gr_info->scfsi; | ||
81 | |||
82 | if(scfsi < 0) | ||
83 | { | ||
84 | /* scfsi < 0 => granule == 0 */ | ||
85 | for(i = 11; i; i--) | ||
86 | { | ||
87 | *scf++ = mpeg3bits_getbits(audio->astream, num0); | ||
88 | } | ||
89 | for(i = 10; i; i--) | ||
90 | *scf++ = mpeg3bits_getbits(audio->astream, num1); | ||
91 | numbits = (num0 + num1) * 10 + num0; | ||
92 | *scf++ = 0; | ||
93 | } | ||
94 | else | ||
95 | { | ||
96 | numbits = 0; | ||
97 | if(!(scfsi & 0x8)) | ||
98 | { | ||
99 | for(i = 0; i < 6; i++) | ||
100 | { | ||
101 | *scf++ = mpeg3bits_getbits(audio->astream, num0); | ||
102 | } | ||
103 | numbits += num0 * 6; | ||
104 | } | ||
105 | else | ||
106 | { | ||
107 | scf += 6; | ||
108 | } | ||
109 | |||
110 | if(!(scfsi & 0x4)) | ||
111 | { | ||
112 | for(i = 0; i < 5; i++) | ||
113 | *scf++ = mpeg3bits_getbits(audio->astream, num0); | ||
114 | numbits += num0 * 5; | ||
115 | } | ||
116 | else | ||
117 | { | ||
118 | scf += 5; | ||
119 | } | ||
120 | |||
121 | if(!(scfsi & 0x2)) | ||
122 | { | ||
123 | for(i = 0; i < 5; i++) | ||
124 | *scf++ = mpeg3bits_getbits(audio->astream, num1); | ||
125 | numbits += num1 * 5; | ||
126 | } | ||
127 | else | ||
128 | { | ||
129 | scf += 5; | ||
130 | } | ||
131 | |||
132 | if(!(scfsi & 0x1)) | ||
133 | { | ||
134 | for(i = 0; i < 5; i++) | ||
135 | *scf++ = mpeg3bits_getbits(audio->astream, num1); | ||
136 | numbits += num1 * 5; | ||
137 | } | ||
138 | else | ||
139 | { | ||
140 | scf += 5; | ||
141 | } | ||
142 | *scf++ = 0; /* no l[21] in original sources */ | ||
143 | } | ||
144 | } | ||
145 | return numbits; | ||
146 | } | ||
147 | |||
148 | int mpeg3audio_III_get_scale_factors_2(mpeg3audio_t *audio, | ||
149 | int *scf, | ||
150 | struct gr_info_s *gr_info, | ||
151 | int i_stereo) | ||
152 | { | ||
153 | unsigned char *pnt; | ||
154 | int i, j, n = 0, numbits = 0; | ||
155 | unsigned int slen; | ||
156 | static unsigned char stab[3][6][4] = | ||
157 | {{{ 6, 5, 5,5 }, { 6, 5, 7,3 }, { 11,10,0,0}, | ||
158 | { 7, 7, 7,0 }, { 6, 6, 6,3 }, { 8, 8,5,0}}, | ||
159 | {{ 9, 9, 9,9 }, { 9, 9,12,6 }, { 18,18,0,0}, | ||
160 | {12,12,12,0 }, {12, 9, 9,6 }, { 15,12,9,0}}, | ||
161 | {{ 6, 9, 9,9 }, { 6, 9,12,6 }, { 15,18,0,0}, | ||
162 | { 6,15,12,0 }, { 6,12, 9,6 }, { 6,18,9,0}}}; | ||
163 | |||
164 | /* i_stereo AND second channel -> do_layer3() checks this */ | ||
165 | if(i_stereo) | ||
166 | slen = mpeg3_i_slen2[gr_info->scalefac_compress >> 1]; | ||
167 | else | ||
168 | slen = mpeg3_n_slen2[gr_info->scalefac_compress]; | ||
169 | |||
170 | gr_info->preflag = (slen >> 15) & 0x1; | ||
171 | |||
172 | n = 0; | ||
173 | if(gr_info->block_type == 2 ) | ||
174 | { | ||
175 | n++; | ||
176 | if(gr_info->mixed_block_flag) | ||
177 | n++; | ||
178 | } | ||
179 | |||
180 | pnt = stab[n][(slen >> 12) & 0x7]; | ||
181 | |||
182 | for(i = 0; i < 4; i++) | ||
183 | { | ||
184 | int num = slen & 0x7; | ||
185 | slen >>= 3; | ||
186 | if(num) | ||
187 | { | ||
188 | for(j = 0; j < (int)(pnt[i]); j++) | ||
189 | *scf++ = mpeg3bits_getbits(audio->astream, num); | ||
190 | numbits += pnt[i] * num; | ||
191 | } | ||
192 | else | ||
193 | { | ||
194 | for(j = 0; j < (int)(pnt[i]); j++) | ||
195 | *scf++ = 0; | ||
196 | } | ||
197 | } | ||
198 | |||
199 | n = (n << 1) + 1; | ||
200 | for(i = 0; i < n; i++) | ||
201 | *scf++ = 0; | ||
202 | |||
203 | return numbits; | ||
204 | } | ||
205 | |||
206 | static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0}; | ||
207 | static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; | ||
208 | |||
209 | /* | ||
210 | * Dequantize samples (includes huffman decoding) | ||
211 | * | ||
212 | * 24 is enough because tab13 has max. a 19 bit huffvector | ||
213 | */ | ||
214 | |||
215 | #define BITSHIFT ((sizeof(long) - 1) * 8) | ||
216 | #define REFRESH_MASK \ | ||
217 | while(num < BITSHIFT) \ | ||
218 | { \ | ||
219 | mask |= mpeg3bits_getbits(audio->astream, 8) << (BITSHIFT - num); \ | ||
220 | num += 8; \ | ||
221 | part2remain -= 8; \ | ||
222 | } | ||
223 | |||
224 | int mpeg3audio_III_dequantize_sample(mpeg3audio_t *audio, | ||
225 | mpeg3_real_t xr[SBLIMIT][SSLIMIT], | ||
226 | int *scf, | ||
227 | struct gr_info_s *gr_info, | ||
228 | int sfreq, | ||
229 | int part2bits) | ||
230 | { | ||
231 | int shift = 1 + gr_info->scalefac_scale; | ||
232 | mpeg3_real_t *xrpnt = (mpeg3_real_t*)xr; | ||
233 | int l[3],l3; | ||
234 | int part2remain = gr_info->part2_3_length - part2bits; | ||
235 | int *me; | ||
236 | int num = mpeg3bits_getbitoffset(audio->astream); | ||
237 | long mask = mpeg3bits_getbits(audio->astream, num); | ||
238 | //printf("III_dequantize_sample 1 %08x %d\n", mask, num); | ||
239 | mask = mask << (BITSHIFT + 8 - num); | ||
240 | part2remain -= num; | ||
241 | |||
242 | { | ||
243 | int bv = gr_info->big_values; | ||
244 | int region1 = gr_info->region1start; | ||
245 | int region2 = gr_info->region2start; | ||
246 | |||
247 | l3 = ((576 >> 1) - bv) >> 1; | ||
248 | |||
249 | /* | ||
250 | * we may lose the 'odd' bit here !! | ||
251 | * check this later again | ||
252 | */ | ||
253 | |||
254 | if(bv <= region1) | ||
255 | { | ||
256 | l[0] = bv; | ||
257 | l[1] = 0; | ||
258 | l[2] = 0; | ||
259 | } | ||
260 | else | ||
261 | { | ||
262 | l[0] = region1; | ||
263 | if(bv <= region2) | ||
264 | { | ||
265 | l[1] = bv - l[0]; l[2] = 0; | ||
266 | } | ||
267 | else | ||
268 | { | ||
269 | l[1] = region2 - l[0]; | ||
270 | l[2] = bv - region2; | ||
271 | } | ||
272 | } | ||
273 | } | ||
274 | |||
275 | if(gr_info->block_type == 2) | ||
276 | { | ||
277 | /* | ||
278 | * decoding with short or mixed mode BandIndex table | ||
279 | */ | ||
280 | int i, max[4]; | ||
281 | int step = 0, lwin = 3, cb = 0; | ||
282 | register mpeg3_real_t v = 0.0; | ||
283 | register int *m, mc; | ||
284 | |||
285 | if(gr_info->mixed_block_flag) | ||
286 | { | ||
287 | max[3] = -1; | ||
288 | max[0] = max[1] = max[2] = 2; | ||
289 | m = mpeg3_map[sfreq][0]; | ||
290 | me = mpeg3_mapend[sfreq][0]; | ||
291 | } | ||
292 | else | ||
293 | { | ||
294 | max[0] = max[1] = max[2] = max[3] = -1; | ||
295 | /* max[3] not floatly needed in this case */ | ||
296 | m = mpeg3_map[sfreq][1]; | ||
297 | me = mpeg3_mapend[sfreq][1]; | ||
298 | } | ||
299 | |||
300 | mc = 0; | ||
301 | for(i = 0; i < 2; i++) | ||
302 | { | ||
303 | int lp = l[i]; | ||
304 | struct newhuff *h = mpeg3_ht + gr_info->table_select[i]; | ||
305 | for( ; lp; lp--, mc--) | ||
306 | { | ||
307 | register int x,y; | ||
308 | if(!mc) | ||
309 | { | ||
310 | mc = *m++; | ||
311 | xrpnt = ((mpeg3_real_t*)xr) + (*m++); | ||
312 | lwin = *m++; | ||
313 | cb = *m++; | ||
314 | if(lwin == 3) | ||
315 | { | ||
316 | v = gr_info->pow2gain[(*scf++) << shift]; | ||
317 | step = 1; | ||
318 | } | ||
319 | else | ||
320 | { | ||
321 | v = gr_info->full_gain[lwin][(*scf++) << shift]; | ||
322 | step = 3; | ||
323 | } | ||
324 | } | ||
325 | |||
326 | { | ||
327 | register short *val = h->table; | ||
328 | REFRESH_MASK; | ||
329 | while((y = *val++) < 0) | ||
330 | { | ||
331 | if (mask < 0) | ||
332 | val -= y; | ||
333 | num--; | ||
334 | mask <<= 1; | ||
335 | } | ||
336 | x = y >> 4; | ||
337 | y &= 0xf; | ||
338 | } | ||
339 | |||
340 | if(x == 15 && h->linbits) | ||
341 | { | ||
342 | max[lwin] = cb; | ||
343 | REFRESH_MASK; | ||
344 | x += ((unsigned long)mask) >> (BITSHIFT + 8 - h->linbits); | ||
345 | num -= h->linbits + 1; | ||
346 | mask <<= h->linbits; | ||
347 | if(mask < 0) | ||
348 | *xrpnt = -mpeg3_ispow[x] * v; | ||
349 | else | ||
350 | *xrpnt = mpeg3_ispow[x] * v; | ||
351 | mask <<= 1; | ||
352 | } | ||
353 | else | ||
354 | if(x) | ||
355 | { | ||
356 | max[lwin] = cb; | ||
357 | if(mask < 0) | ||
358 | *xrpnt = -mpeg3_ispow[x] * v; | ||
359 | else | ||
360 | *xrpnt = mpeg3_ispow[x] * v; | ||
361 | num--; | ||
362 | mask <<= 1; | ||
363 | } | ||
364 | else | ||
365 | *xrpnt = 0.0; | ||
366 | |||
367 | xrpnt += step; | ||
368 | if(y == 15 && h->linbits) | ||
369 | { | ||
370 | max[lwin] = cb; | ||
371 | REFRESH_MASK; | ||
372 | y += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits); | ||
373 | num -= h->linbits + 1; | ||
374 | mask <<= h->linbits; | ||
375 | if(mask < 0) | ||
376 | *xrpnt = -mpeg3_ispow[y] * v; | ||
377 | else | ||
378 | *xrpnt = mpeg3_ispow[y] * v; | ||
379 | mask <<= 1; | ||
380 | } | ||
381 | else | ||
382 | if(y) | ||
383 | { | ||
384 | max[lwin] = cb; | ||
385 | if(mask < 0) | ||
386 | *xrpnt = -mpeg3_ispow[y] * v; | ||
387 | else | ||
388 | *xrpnt = mpeg3_ispow[y] * v; | ||
389 | num--; | ||
390 | mask <<= 1; | ||
391 | } | ||
392 | else | ||
393 | *xrpnt = 0.0; | ||
394 | xrpnt += step; | ||
395 | } | ||
396 | } | ||
397 | |||
398 | for( ;l3 && (part2remain + num > 0); l3--) | ||
399 | { | ||
400 | struct newhuff *h = mpeg3_htc + gr_info->count1table_select; | ||
401 | register short *val = h->table, a; | ||
402 | |||
403 | REFRESH_MASK; | ||
404 | while((a = *val++) < 0) | ||
405 | { | ||
406 | if (mask < 0) | ||
407 | val -= a; | ||
408 | num--; | ||
409 | mask <<= 1; | ||
410 | } | ||
411 | if(part2remain + num <= 0) | ||
412 | { | ||
413 | num -= part2remain + num; | ||
414 | break; | ||
415 | } | ||
416 | |||
417 | for(i = 0; i < 4; i++) | ||
418 | { | ||
419 | if(!(i & 1)) | ||
420 | { | ||
421 | if(!mc) | ||
422 | { | ||
423 | mc = *m++; | ||
424 | xrpnt = ((mpeg3_real_t*)xr) + (*m++); | ||
425 | lwin = *m++; | ||
426 | cb = *m++; | ||
427 | if(lwin == 3) | ||
428 | { | ||
429 | v = gr_info->pow2gain[(*scf++) << shift]; | ||
430 | step = 1; | ||
431 | } | ||
432 | else | ||
433 | { | ||
434 | v = gr_info->full_gain[lwin][(*scf++) << shift]; | ||
435 | step = 3; | ||
436 | } | ||
437 | } | ||
438 | mc--; | ||
439 | } | ||
440 | if((a & (0x8 >> i))) | ||
441 | { | ||
442 | max[lwin] = cb; | ||
443 | if(part2remain + num <= 0) | ||
444 | { | ||
445 | break; | ||
446 | } | ||
447 | if(mask < 0) | ||
448 | *xrpnt = -v; | ||
449 | else | ||
450 | *xrpnt = v; | ||
451 | num--; | ||
452 | mask <<= 1; | ||
453 | } | ||
454 | else | ||
455 | *xrpnt = 0.0; | ||
456 | xrpnt += step; | ||
457 | } | ||
458 | } | ||
459 | |||
460 | if(lwin < 3) | ||
461 | { | ||
462 | /* short band? */ | ||
463 | while(1) | ||
464 | { | ||
465 | for( ;mc > 0; mc--) | ||
466 | { | ||
467 | /* short band -> step=3 */ | ||
468 | *xrpnt = 0.0; | ||
469 | xrpnt += 3; | ||
470 | *xrpnt = 0.0; | ||
471 | xrpnt += 3; | ||
472 | } | ||
473 | if(m >= me) | ||
474 | break; | ||
475 | mc = *m++; | ||
476 | xrpnt = ((mpeg3_real_t*)xr) + *m++; | ||
477 | /* optimize: field will be set to zero at the end of the function */ | ||
478 | if(*m++ == 0) | ||
479 | break; | ||
480 | /* cb */ | ||
481 | m++; | ||
482 | } | ||
483 | } | ||
484 | |||
485 | gr_info->maxband[0] = max[0] + 1; | ||
486 | gr_info->maxband[1] = max[1] + 1; | ||
487 | gr_info->maxband[2] = max[2] + 1; | ||
488 | gr_info->maxbandl = max[3] + 1; | ||
489 | |||
490 | { | ||
491 | int rmax = max[0] > max[1] ? max[0] : max[1]; | ||
492 | rmax = (rmax > max[2] ? rmax : max[2]) + 1; | ||
493 | gr_info->maxb = rmax ? mpeg3_shortLimit[sfreq][rmax] : mpeg3_longLimit[sfreq][max[3] + 1]; | ||
494 | } | ||
495 | |||
496 | } | ||
497 | else | ||
498 | { | ||
499 | /* | ||
500 | * decoding with 'long' BandIndex table (block_type != 2) | ||
501 | */ | ||
502 | int *pretab = gr_info->preflag ? pretab1 : pretab2; | ||
503 | int i, max = -1; | ||
504 | int cb = 0; | ||
505 | int *m = mpeg3_map[sfreq][2]; | ||
506 | register mpeg3_real_t v = 0.0; | ||
507 | int mc = 0; | ||
508 | |||
509 | /* | ||
510 | * long hash table values | ||
511 | */ | ||
512 | for(i = 0; i < 3; i++) | ||
513 | { | ||
514 | int lp = l[i]; | ||
515 | struct newhuff *h = mpeg3_ht + gr_info->table_select[i]; | ||
516 | |||
517 | for(; lp; lp--, mc--) | ||
518 | { | ||
519 | int x, y; | ||
520 | |||
521 | if(!mc) | ||
522 | { | ||
523 | mc = *m++; | ||
524 | cb = *m++; | ||
525 | if(cb == 21) | ||
526 | v = 0.0; | ||
527 | else | ||
528 | v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; | ||
529 | } | ||
530 | { | ||
531 | register short *val = h->table; | ||
532 | REFRESH_MASK; | ||
533 | while((y = *val++) < 0) | ||
534 | { | ||
535 | if(mask < 0) | ||
536 | val -= y; | ||
537 | num--; | ||
538 | mask <<= 1; | ||
539 | } | ||
540 | x = y >> 4; | ||
541 | y &= 0xf; | ||
542 | } | ||
543 | |||
544 | if(x == 15 && h->linbits) | ||
545 | { | ||
546 | max = cb; | ||
547 | REFRESH_MASK; | ||
548 | x += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits); | ||
549 | num -= h->linbits + 1; | ||
550 | mask <<= h->linbits; | ||
551 | if(mask < 0) | ||
552 | *xrpnt++ = -mpeg3_ispow[x] * v; | ||
553 | else | ||
554 | *xrpnt++ = mpeg3_ispow[x] * v; | ||
555 | mask <<= 1; | ||
556 | } | ||
557 | else | ||
558 | if(x) | ||
559 | { | ||
560 | max = cb; | ||
561 | if(mask < 0) | ||
562 | *xrpnt++ = -mpeg3_ispow[x] * v; | ||
563 | else | ||
564 | *xrpnt++ = mpeg3_ispow[x] * v; | ||
565 | num--; | ||
566 | mask <<= 1; | ||
567 | } | ||
568 | else | ||
569 | *xrpnt++ = 0.0; | ||
570 | |||
571 | if(y == 15 && h->linbits) | ||
572 | { | ||
573 | max = cb; | ||
574 | REFRESH_MASK; | ||
575 | y += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits); | ||
576 | num -= h->linbits + 1; | ||
577 | mask <<= h->linbits; | ||
578 | if(mask < 0) | ||
579 | *xrpnt++ = -mpeg3_ispow[y] * v; | ||
580 | else | ||
581 | *xrpnt++ = mpeg3_ispow[y] * v; | ||
582 | mask <<= 1; | ||
583 | } | ||
584 | else | ||
585 | if(y) | ||
586 | { | ||
587 | max = cb; | ||
588 | if(mask < 0) | ||
589 | *xrpnt++ = -mpeg3_ispow[y] * v; | ||
590 | else | ||
591 | *xrpnt++ = mpeg3_ispow[y] * v; | ||
592 | num--; | ||
593 | mask <<= 1; | ||
594 | } | ||
595 | else | ||
596 | *xrpnt++ = 0.0; | ||
597 | } | ||
598 | } | ||
599 | |||
600 | /* | ||
601 | * short (count1table) values | ||
602 | */ | ||
603 | for( ; l3 && (part2remain + num > 0); l3--) | ||
604 | { | ||
605 | struct newhuff *h = mpeg3_htc + gr_info->count1table_select; | ||
606 | register short *val = h->table, a; | ||
607 | |||
608 | REFRESH_MASK; | ||
609 | while((a = *val++) < 0) | ||
610 | { | ||
611 | if(mask < 0) | ||
612 | val -= a; | ||
613 | num--; | ||
614 | mask <<= 1; | ||
615 | } | ||
616 | if(part2remain + num <= 0) | ||
617 | { | ||
618 | num -= part2remain + num; | ||
619 | break; | ||
620 | } | ||
621 | |||
622 | for(i = 0; i < 4; i++) | ||
623 | { | ||
624 | if(!(i & 1)) | ||
625 | { | ||
626 | if(!mc) | ||
627 | { | ||
628 | mc = *m++; | ||
629 | cb = *m++; | ||
630 | if(cb == 21) | ||
631 | v = 0.0; | ||
632 | else | ||
633 | v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; | ||
634 | } | ||
635 | mc--; | ||
636 | } | ||
637 | if((a & (0x8 >> i))) | ||
638 | { | ||
639 | max = cb; | ||
640 | if(part2remain + num <= 0) | ||
641 | { | ||
642 | break; | ||
643 | } | ||
644 | if(mask < 0) | ||
645 | *xrpnt++ = -v; | ||
646 | else | ||
647 | *xrpnt++ = v; | ||
648 | num--; | ||
649 | mask <<= 1; | ||
650 | } | ||
651 | else | ||
652 | *xrpnt++ = 0.0; | ||
653 | } | ||
654 | } | ||
655 | |||
656 | gr_info->maxbandl = max + 1; | ||
657 | gr_info->maxb = mpeg3_longLimit[sfreq][gr_info->maxbandl]; | ||
658 | } | ||
659 | |||
660 | part2remain += num; | ||
661 | |||
662 | //printf("III_dequantize_sample 2 %d %04x\n", num, mpeg3bits_showbits(audio->astream, 16)); | ||
663 | mpeg3bits_start_reverse(audio->astream); | ||
664 | mpeg3bits_getbits_reverse(audio->astream, num); | ||
665 | mpeg3bits_start_forward(audio->astream); | ||
666 | //printf("III_dequantize_sample 3 %d %04x\n", audio->astream->bit_number, mpeg3bits_showbits(audio->astream, 16)); | ||
667 | num = 0; | ||
668 | |||
669 | while(xrpnt < &xr[SBLIMIT][0]) | ||
670 | *xrpnt++ = 0.0; | ||
671 | |||
672 | while(part2remain > 16) | ||
673 | { | ||
674 | mpeg3bits_getbits(audio->astream, 16); /* Dismiss stuffing Bits */ | ||
675 | part2remain -= 16; | ||
676 | } | ||
677 | if(part2remain > 0) | ||
678 | { | ||
679 | mpeg3bits_getbits(audio->astream, part2remain); | ||
680 | } | ||
681 | else | ||
682 | if(part2remain < 0) | ||
683 | { | ||
684 | fprintf(stderr,"mpeg3audio_III_dequantize_sample: Can't rewind stream %d bits!\n", -part2remain); | ||
685 | return 1; /* -> error */ | ||
686 | } | ||
687 | return 0; | ||
688 | } | ||
689 | |||
690 | int mpeg3audio_III_get_side_info(mpeg3audio_t *audio, | ||
691 | struct mpeg3_III_sideinfo *si, | ||
692 | int channels, | ||
693 | int ms_stereo, | ||
694 | long sfreq, | ||
695 | int single, | ||
696 | int lsf) | ||
697 | { | ||
698 | int ch, gr; | ||
699 | int powdiff = (single == 3) ? 4 : 0; | ||
700 | static const int tabs[2][5] = { { 2,9,5,3,4 } , { 1,8,1,2,9 } }; | ||
701 | const int *tab = tabs[lsf]; | ||
702 | |||
703 | si->main_data_begin = mpeg3bits_getbits(audio->astream, tab[1]); | ||
704 | if(channels == 1) | ||
705 | si->private_bits = mpeg3bits_getbits(audio->astream, tab[2]); | ||
706 | else | ||
707 | si->private_bits = mpeg3bits_getbits(audio->astream, tab[3]); | ||
708 | if(!lsf) | ||
709 | { | ||
710 | for(ch = 0; ch < channels; ch++) | ||
711 | { | ||
712 | si->ch[ch].gr[0].scfsi = -1; | ||
713 | si->ch[ch].gr[1].scfsi = mpeg3bits_getbits(audio->astream, 4); | ||
714 | } | ||
715 | } | ||
716 | |||
717 | for(gr = 0; gr < tab[0]; gr++) | ||
718 | { | ||
719 | for(ch = 0; ch < channels; ch++) | ||
720 | { | ||
721 | register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]); | ||
722 | |||
723 | gr_info->part2_3_length = mpeg3bits_getbits(audio->astream, 12); | ||
724 | gr_info->big_values = mpeg3bits_getbits(audio->astream, 9); | ||
725 | if(gr_info->big_values > 288) | ||
726 | { | ||
727 | fprintf(stderr,"mpeg3_III_get_side_info: big_values too large!\n"); | ||
728 | gr_info->big_values = 288; | ||
729 | } | ||
730 | gr_info->pow2gain = mpeg3_gainpow2 + 256 - mpeg3bits_getbits(audio->astream, 8) + powdiff; | ||
731 | if(ms_stereo) | ||
732 | gr_info->pow2gain += 2; | ||
733 | gr_info->scalefac_compress = mpeg3bits_getbits(audio->astream, tab[4]); | ||
734 | |||
735 | if(mpeg3bits_getbits(audio->astream, 1)) | ||
736 | { | ||
737 | /* window switch flag */ | ||
738 | int i; | ||
739 | gr_info->block_type = mpeg3bits_getbits(audio->astream, 2); | ||
740 | gr_info->mixed_block_flag = mpeg3bits_getbits(audio->astream, 1); | ||
741 | gr_info->table_select[0] = mpeg3bits_getbits(audio->astream, 5); | ||
742 | gr_info->table_select[1] = mpeg3bits_getbits(audio->astream, 5); | ||
743 | /* | ||
744 | * table_select[2] not needed, because there is no region2, | ||
745 | * but to satisfy some verifications tools we set it either. | ||
746 | */ | ||
747 | gr_info->table_select[2] = 0; | ||
748 | for(i = 0; i < 3; i++) | ||
749 | gr_info->full_gain[i] = gr_info->pow2gain + (mpeg3bits_getbits(audio->astream, 3) << 3); | ||
750 | |||
751 | if(gr_info->block_type == 0) | ||
752 | { | ||
753 | fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n"); | ||
754 | return 1; | ||
755 | } | ||
756 | |||
757 | /* region_count/start parameters are implicit in this case. */ | ||
758 | if(!lsf || gr_info->block_type == 2) | ||
759 | gr_info->region1start = 36 >> 1; | ||
760 | else | ||
761 | { | ||
762 | /* check this again for 2.5 and sfreq=8 */ | ||
763 | if(sfreq == 8) | ||
764 | gr_info->region1start = 108 >> 1; | ||
765 | else | ||
766 | gr_info->region1start = 54 >> 1; | ||
767 | } | ||
768 | gr_info->region2start = 576 >> 1; | ||
769 | } | ||
770 | else | ||
771 | { | ||
772 | int i, r0c, r1c; | ||
773 | for(i = 0; i < 3; i++) | ||
774 | gr_info->table_select[i] = mpeg3bits_getbits(audio->astream, 5); | ||
775 | |||
776 | r0c = mpeg3bits_getbits(audio->astream, 4); | ||
777 | r1c = mpeg3bits_getbits(audio->astream, 3); | ||
778 | gr_info->region1start = mpeg3_bandInfo[sfreq].longIdx[r0c + 1] >> 1 ; | ||
779 | gr_info->region2start = mpeg3_bandInfo[sfreq].longIdx[r0c + 1 + r1c + 1] >> 1; | ||
780 | gr_info->block_type = 0; | ||
781 | gr_info->mixed_block_flag = 0; | ||
782 | } | ||
783 | if(!lsf) gr_info->preflag = mpeg3bits_getbits(audio->astream, 1); | ||
784 | gr_info->scalefac_scale = mpeg3bits_getbits(audio->astream, 1); | ||
785 | gr_info->count1table_select = mpeg3bits_getbits(audio->astream, 1); | ||
786 | } | ||
787 | } | ||
788 | return 0; | ||
789 | } | ||
790 | |||
791 | int mpeg3audio_III_hybrid(mpeg3audio_t *audio, | ||
792 | mpeg3_real_t fsIn[SBLIMIT][SSLIMIT], | ||
793 | mpeg3_real_t tsOut[SSLIMIT][SBLIMIT], | ||
794 | int ch, | ||
795 | struct gr_info_s *gr_info) | ||
796 | { | ||
797 | mpeg3_real_t *tspnt = (mpeg3_real_t *) tsOut; | ||
798 | mpeg3_real_t *rawout1,*rawout2; | ||
799 | int bt, sb = 0; | ||
800 | |||
801 | |||
802 | { | ||
803 | int b = audio->mp3_blc[ch]; | ||
804 | rawout1 = audio->mp3_block[b][ch]; | ||
805 | b = -b + 1; | ||
806 | rawout2 = audio->mp3_block[b][ch]; | ||
807 | audio->mp3_blc[ch] = b; | ||
808 | } | ||
809 | |||
810 | if(gr_info->mixed_block_flag) | ||
811 | { | ||
812 | sb = 2; | ||
813 | mpeg3audio_dct36(fsIn[0], rawout1, rawout2, mpeg3_win[0], tspnt); | ||
814 | mpeg3audio_dct36(fsIn[1], rawout1 + 18, rawout2 + 18, mpeg3_win1[0], tspnt + 1); | ||
815 | rawout1 += 36; | ||
816 | rawout2 += 36; | ||
817 | tspnt += 2; | ||
818 | } | ||
819 | |||
820 | bt = gr_info->block_type; | ||
821 | if(bt == 2) | ||
822 | { | ||
823 | for( ; sb < gr_info->maxb; sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36) | ||
824 | { | ||
825 | mpeg3audio_dct12(fsIn[sb] ,rawout1 ,rawout2 ,mpeg3_win[2] ,tspnt); | ||
826 | mpeg3audio_dct12(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, mpeg3_win1[2], tspnt + 1); | ||
827 | } | ||
828 | } | ||
829 | else | ||
830 | { | ||
831 | for( ; sb < gr_info->maxb; sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36) | ||
832 | { | ||
833 | mpeg3audio_dct36(fsIn[sb], rawout1, rawout2, mpeg3_win[bt], tspnt); | ||
834 | mpeg3audio_dct36(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, mpeg3_win1[bt], tspnt + 1); | ||
835 | } | ||
836 | } | ||
837 | |||
838 | for( ; sb < SBLIMIT; sb++, tspnt++) | ||
839 | { | ||
840 | int i; | ||
841 | for(i = 0; i < SSLIMIT; i++) | ||
842 | { | ||
843 | tspnt[i * SBLIMIT] = *rawout1++; | ||
844 | *rawout2++ = 0.0; | ||
845 | } | ||
846 | } | ||
847 | return 0; | ||
848 | } | ||
849 | |||
850 | int mpeg3audio_III_antialias(mpeg3audio_t *audio, | ||
851 | mpeg3_real_t xr[SBLIMIT][SSLIMIT], | ||
852 | struct gr_info_s *gr_info) | ||
853 | { | ||
854 | int sblim; | ||
855 | |||
856 | if(gr_info->block_type == 2) | ||
857 | { | ||
858 | if(!gr_info->mixed_block_flag) | ||
859 | return 0; | ||
860 | sblim = 1; | ||
861 | } | ||
862 | else | ||
863 | { | ||
864 | sblim = gr_info->maxb-1; | ||
865 | } | ||
866 | |||
867 | /* 31 alias-reduction operations between each pair of sub-bands */ | ||
868 | /* with 8 butterflies between each pair */ | ||
869 | |||
870 | { | ||
871 | int sb; | ||
872 | mpeg3_real_t *xr1 = (mpeg3_real_t*)xr[1]; | ||
873 | |||
874 | for(sb = sblim; sb; sb--, xr1 += 10) | ||
875 | { | ||
876 | int ss; | ||
877 | mpeg3_real_t *cs, *ca; | ||
878 | mpeg3_real_t *xr2; | ||
879 | cs = mpeg3_aa_cs; | ||
880 | ca = mpeg3_aa_ca; | ||
881 | xr2 = xr1; | ||
882 | |||
883 | for(ss = 7; ss >= 0; ss--) | ||
884 | { | ||
885 | /* upper and lower butterfly inputs */ | ||
886 | register mpeg3_real_t bu, bd; | ||
887 | bu = *--xr2; | ||
888 | bd = *xr1; | ||
889 | *xr2 = (bu * (*cs) ) - (bd * (*ca) ); | ||
890 | *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) ); | ||
891 | } | ||
892 | } | ||
893 | } | ||
894 | return 0; | ||
895 | } | ||
896 | |||
897 | /* | ||
898 | * III_stereo: calculate mpeg3_real_t channel values for Joint-I-Stereo-mode | ||
899 | */ | ||
900 | int mpeg3audio_III_i_stereo(mpeg3audio_t *audio, | ||
901 | mpeg3_real_t xr_buf[2][SBLIMIT][SSLIMIT], | ||
902 | int *scalefac, | ||
903 | struct gr_info_s *gr_info, | ||
904 | int sfreq, | ||
905 | int ms_stereo, | ||
906 | int lsf) | ||
907 | { | ||
908 | mpeg3_real_t (*xr)[SBLIMIT*SSLIMIT] = (mpeg3_real_t (*)[SBLIMIT*SSLIMIT] ) xr_buf; | ||
909 | struct mpeg3_bandInfoStruct *bi = &mpeg3_bandInfo[sfreq]; | ||
910 | const mpeg3_real_t *tab1, *tab2; | ||
911 | |||
912 | int tab; | ||
913 | /* TODO: optimize as static */ | ||
914 | static const mpeg3_real_t *tabs[3][2][2] = | ||
915 | { | ||
916 | { { mpeg3_tan1_1, mpeg3_tan2_1 } , { mpeg3_tan1_2, mpeg3_tan2_2 } }, | ||
917 | { { mpeg3_pow1_1[0], mpeg3_pow2_1[0] } , { mpeg3_pow1_2[0], mpeg3_pow2_2[0] } } , | ||
918 | { { mpeg3_pow1_1[1], mpeg3_pow2_1[1] } , { mpeg3_pow1_2[1], mpeg3_pow2_2[1] } } | ||
919 | }; | ||
920 | |||
921 | tab = lsf + (gr_info->scalefac_compress & lsf); | ||
922 | tab1 = tabs[tab][ms_stereo][0]; | ||
923 | tab2 = tabs[tab][ms_stereo][1]; | ||
924 | |||
925 | if(gr_info->block_type == 2) | ||
926 | { | ||
927 | int lwin,do_l = 0; | ||
928 | if(gr_info->mixed_block_flag) | ||
929 | do_l = 1; | ||
930 | |||
931 | for(lwin = 0; lwin < 3; lwin++) | ||
932 | { | ||
933 | /* process each window */ | ||
934 | /* get first band with zero values */ | ||
935 | /* sfb is minimal 3 for mixed mode */ | ||
936 | int is_p, sb, idx, sfb = gr_info->maxband[lwin]; | ||
937 | if(sfb > 3) do_l = 0; | ||
938 | |||
939 | for( ; sfb < 12 ; sfb++) | ||
940 | { | ||
941 | /* scale: 0-15 */ | ||
942 | is_p = scalefac[sfb * 3 + lwin - gr_info->mixed_block_flag]; | ||
943 | if(is_p != 7) | ||
944 | { | ||
945 | mpeg3_real_t t1, t2; | ||
946 | sb = bi->shortDiff[sfb]; | ||
947 | idx = bi->shortIdx[sfb] + lwin; | ||
948 | t1 = tab1[is_p]; | ||
949 | t2 = tab2[is_p]; | ||
950 | for( ; sb > 0; sb--, idx += 3) | ||
951 | { | ||
952 | mpeg3_real_t v = xr[0][idx]; | ||
953 | xr[0][idx] = v * t1; | ||
954 | xr[1][idx] = v * t2; | ||
955 | } | ||
956 | } | ||
957 | } | ||
958 | |||
959 | /* in the original: copy 10 to 11 , here: copy 11 to 12 | ||
960 | maybe still wrong??? (copy 12 to 13?) */ | ||
961 | /* scale: 0-15 */ | ||
962 | is_p = scalefac[11 * 3 + lwin - gr_info->mixed_block_flag]; | ||
963 | sb = bi->shortDiff[12]; | ||
964 | idx = bi->shortIdx[12] + lwin; | ||
965 | if(is_p != 7) | ||
966 | { | ||
967 | mpeg3_real_t t1, t2; | ||
968 | t1 = tab1[is_p]; | ||
969 | t2 = tab2[is_p]; | ||
970 | for( ; sb > 0; sb--, idx += 3) | ||
971 | { | ||
972 | mpeg3_real_t v = xr[0][idx]; | ||
973 | xr[0][idx] = v * t1; | ||
974 | xr[1][idx] = v * t2; | ||
975 | } | ||
976 | } | ||
977 | } /* end for(lwin; .. ; . ) */ | ||
978 | |||
979 | /* also check l-part, if ALL bands in the three windows are 'empty' | ||
980 | * and mode = mixed_mode | ||
981 | */ | ||
982 | if(do_l) | ||
983 | { | ||
984 | int sfb = gr_info->maxbandl; | ||
985 | int idx = bi->longIdx[sfb]; | ||
986 | |||
987 | for ( ; sfb < 8; sfb++) | ||
988 | { | ||
989 | int sb = bi->longDiff[sfb]; | ||
990 | /* scale: 0-15 */ | ||
991 | int is_p = scalefac[sfb]; | ||
992 | if(is_p != 7) | ||
993 | { | ||
994 | mpeg3_real_t t1, t2; | ||
995 | t1 = tab1[is_p]; | ||
996 | t2 = tab2[is_p]; | ||
997 | for( ; sb > 0; sb--, idx++) | ||
998 | { | ||
999 | mpeg3_real_t v = xr[0][idx]; | ||
1000 | xr[0][idx] = v * t1; | ||
1001 | xr[1][idx] = v * t2; | ||
1002 | } | ||
1003 | } | ||
1004 | else | ||
1005 | idx += sb; | ||
1006 | } | ||
1007 | } | ||
1008 | } | ||
1009 | else | ||
1010 | { | ||
1011 | /* ((gr_info->block_type != 2)) */ | ||
1012 | int sfb = gr_info->maxbandl; | ||
1013 | int is_p, idx = bi->longIdx[sfb]; | ||
1014 | for( ; sfb < 21; sfb++) | ||
1015 | { | ||
1016 | int sb = bi->longDiff[sfb]; | ||
1017 | /* scale: 0-15 */ | ||
1018 | is_p = scalefac[sfb]; | ||
1019 | if(is_p != 7) | ||
1020 | { | ||
1021 | mpeg3_real_t t1, t2; | ||
1022 | t1 = tab1[is_p]; | ||
1023 | t2 = tab2[is_p]; | ||
1024 | for( ; sb > 0; sb--, idx++) | ||
1025 | { | ||
1026 | mpeg3_real_t v = xr[0][idx]; | ||
1027 | xr[0][idx] = v * t1; | ||
1028 | xr[1][idx] = v * t2; | ||
1029 | } | ||
1030 | } | ||
1031 | else | ||
1032 | idx += sb; | ||
1033 | } | ||
1034 | |||
1035 | is_p = scalefac[20]; | ||
1036 | if(is_p != 7) | ||
1037 | { | ||
1038 | /* copy l-band 20 to l-band 21 */ | ||
1039 | int sb; | ||
1040 | mpeg3_real_t t1 = tab1[is_p], t2 = tab2[is_p]; | ||
1041 | |||
1042 | for(sb = bi->longDiff[21]; sb > 0; sb--, idx++) | ||
1043 | { | ||
1044 | mpeg3_real_t v = xr[0][idx]; | ||
1045 | xr[0][idx] = v * t1; | ||
1046 | xr[1][idx] = v * t2; | ||
1047 | } | ||
1048 | } | ||
1049 | } /* ... */ | ||
1050 | } | ||
1051 | |||
1052 | /* Read just the frame after a seek. */ | ||
1053 | int mpeg3audio_read_layer3_frame(mpeg3audio_t *audio) | ||
1054 | { | ||
1055 | int result = 0; | ||
1056 | |||
1057 | result = mpeg3audio_read_header(audio); | ||
1058 | if(!result) | ||
1059 | { | ||
1060 | audio->bsbufold = audio->bsbuf; | ||
1061 | audio->bsbuf = audio->bsspace[audio->bsnum] + 512; | ||
1062 | audio->bsnum ^= 1; | ||
1063 | result = mpeg3bits_read_buffer(audio->astream, audio->bsbuf, audio->framesize); | ||
1064 | } | ||
1065 | |||
1066 | return result; | ||
1067 | } | ||
1068 | |||
1069 | int mpeg3audio_dolayer3(mpeg3audio_t *audio) | ||
1070 | { | ||
1071 | int gr, ch, ss; | ||
1072 | int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */ | ||
1073 | struct mpeg3_III_sideinfo sideinfo; | ||
1074 | int channels = audio->channels; | ||
1075 | int single = audio->single; | ||
1076 | int ms_stereo, i_stereo; | ||
1077 | int sfreq = audio->sampling_frequency_code; | ||
1078 | int stereo1, granules; | ||
1079 | int i; | ||
1080 | |||
1081 | /* flip/init buffer */ | ||
1082 | audio->bsbufold = audio->bsbuf; | ||
1083 | audio->bsbuf = audio->bsspace[audio->bsnum] + 512; | ||
1084 | audio->bsnum ^= 1; | ||
1085 | |||
1086 | /* read main data into memory */ | ||
1087 | if(mpeg3bits_read_buffer(audio->astream, audio->bsbuf, audio->framesize)) | ||
1088 | return 1; | ||
1089 | mpeg3bits_use_ptr(audio->astream, audio->bsbuf); | ||
1090 | |||
1091 | /* CRC must be skipped here for proper alignment with the backstep */ | ||
1092 | if(audio->error_protection) | ||
1093 | mpeg3bits_getbits(audio->astream, 16); | ||
1094 | |||
1095 | if(channels == 1) | ||
1096 | { | ||
1097 | /* stream is mono */ | ||
1098 | stereo1 = 1; | ||
1099 | single = 0; | ||
1100 | } | ||
1101 | else | ||
1102 | { | ||
1103 | /* Stereo */ | ||
1104 | stereo1 = 2; | ||
1105 | } | ||
1106 | |||
1107 | if(audio->mode == MPG_MD_JOINT_STEREO) | ||
1108 | { | ||
1109 | ms_stereo = (audio->mode_ext & 0x2) >> 1; | ||
1110 | i_stereo = audio->mode_ext & 0x1; | ||
1111 | } | ||
1112 | else | ||
1113 | ms_stereo = i_stereo = 0; | ||
1114 | |||
1115 | if(audio->lsf) | ||
1116 | { | ||
1117 | granules = 1; | ||
1118 | } | ||
1119 | else | ||
1120 | { | ||
1121 | granules = 2; | ||
1122 | } | ||
1123 | |||
1124 | if(mpeg3audio_III_get_side_info(audio, &sideinfo, channels, ms_stereo, sfreq, single, audio->lsf)) | ||
1125 | return 1; | ||
1126 | |||
1127 | /* Step back */ | ||
1128 | if(sideinfo.main_data_begin >= 512) | ||
1129 | return 1; | ||
1130 | |||
1131 | if(sideinfo.main_data_begin) | ||
1132 | { | ||
1133 | memcpy(audio->bsbuf + audio->ssize - sideinfo.main_data_begin, | ||
1134 | audio->bsbufold + audio->prev_framesize - sideinfo.main_data_begin, | ||
1135 | sideinfo.main_data_begin); | ||
1136 | mpeg3bits_use_ptr(audio->astream, audio->bsbuf + audio->ssize - sideinfo.main_data_begin); | ||
1137 | } | ||
1138 | |||
1139 | for(gr = 0; gr < granules; gr++) | ||
1140 | { | ||
1141 | mpeg3_real_t hybridIn [2][SBLIMIT][SSLIMIT]; | ||
1142 | mpeg3_real_t hybridOut[2][SSLIMIT][SBLIMIT]; | ||
1143 | |||
1144 | { | ||
1145 | struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]); | ||
1146 | long part2bits; | ||
1147 | if(audio->lsf) | ||
1148 | part2bits = mpeg3audio_III_get_scale_factors_2(audio, scalefacs[0], gr_info, 0); | ||
1149 | else | ||
1150 | part2bits = mpeg3audio_III_get_scale_factors_1(audio, scalefacs[0], gr_info, 0, gr); | ||
1151 | //printf("dolayer3 4 %04x\n", mpeg3bits_showbits(audio->astream, 16)); | ||
1152 | |||
1153 | if(mpeg3audio_III_dequantize_sample(audio, hybridIn[0], scalefacs[0], gr_info, sfreq, part2bits)) | ||
1154 | { | ||
1155 | mpeg3bits_use_demuxer(audio->astream); | ||
1156 | return 1; | ||
1157 | } | ||
1158 | //printf("dolayer3 5 %04x\n", mpeg3bits_showbits(audio->astream, 16)); | ||
1159 | } | ||
1160 | |||
1161 | if(channels == 2) | ||
1162 | { | ||
1163 | struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]); | ||
1164 | long part2bits; | ||
1165 | if(audio->lsf) | ||
1166 | part2bits = mpeg3audio_III_get_scale_factors_2(audio, scalefacs[1], gr_info, i_stereo); | ||
1167 | else | ||
1168 | part2bits = mpeg3audio_III_get_scale_factors_1(audio, scalefacs[1], gr_info, 1, gr); | ||
1169 | |||
1170 | if(mpeg3audio_III_dequantize_sample(audio, hybridIn[1], scalefacs[1], gr_info, sfreq, part2bits)) | ||
1171 | { | ||
1172 | mpeg3bits_use_demuxer(audio->astream); | ||
1173 | return 1; | ||
1174 | } | ||
1175 | |||
1176 | if(ms_stereo) | ||
1177 | { | ||
1178 | int i; | ||
1179 | int maxb = sideinfo.ch[0].gr[gr].maxb; | ||
1180 | if(sideinfo.ch[1].gr[gr].maxb > maxb) | ||
1181 | maxb = sideinfo.ch[1].gr[gr].maxb; | ||
1182 | for(i = 0; i < SSLIMIT * maxb; i++) | ||
1183 | { | ||
1184 | mpeg3_real_t tmp0 = ((mpeg3_real_t*)hybridIn[0])[i]; | ||
1185 | mpeg3_real_t tmp1 = ((mpeg3_real_t*)hybridIn[1])[i]; | ||
1186 | ((mpeg3_real_t*)hybridIn[0])[i] = tmp0 + tmp1; | ||
1187 | ((mpeg3_real_t*)hybridIn[1])[i] = tmp0 - tmp1; | ||
1188 | } | ||
1189 | } | ||
1190 | |||
1191 | if(i_stereo) | ||
1192 | mpeg3audio_III_i_stereo(audio, hybridIn, scalefacs[1], gr_info, sfreq, ms_stereo, audio->lsf); | ||
1193 | |||
1194 | if(ms_stereo || i_stereo || (single == 3)) | ||
1195 | { | ||
1196 | if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb) | ||
1197 | sideinfo.ch[0].gr[gr].maxb = gr_info->maxb; | ||
1198 | else | ||
1199 | gr_info->maxb = sideinfo.ch[0].gr[gr].maxb; | ||
1200 | } | ||
1201 | |||
1202 | switch(single) | ||
1203 | { | ||
1204 | case 3: | ||
1205 | { | ||
1206 | register int i; | ||
1207 | register mpeg3_real_t *in0 = (mpeg3_real_t*)hybridIn[0], *in1 = (mpeg3_real_t*)hybridIn[1]; | ||
1208 | /* *0.5 done by pow-scale */ | ||
1209 | for(i = 0; i < SSLIMIT * gr_info->maxb; i++, in0++) | ||
1210 | *in0 = (*in0 + *in1++); | ||
1211 | } | ||
1212 | break; | ||
1213 | case 1: | ||
1214 | { | ||
1215 | register int i; | ||
1216 | register mpeg3_real_t *in0 = (mpeg3_real_t*)hybridIn[0], *in1 = (mpeg3_real_t*)hybridIn[1]; | ||
1217 | for(i = 0; i < SSLIMIT * gr_info->maxb; i++) | ||
1218 | *in0++ = *in1++; | ||
1219 | } | ||
1220 | break; | ||
1221 | } | ||
1222 | } | ||
1223 | |||
1224 | for(ch = 0; ch < stereo1; ch++) | ||
1225 | { | ||
1226 | struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]); | ||
1227 | mpeg3audio_III_antialias(audio, hybridIn[ch], gr_info); | ||
1228 | mpeg3audio_III_hybrid(audio, hybridIn[ch], hybridOut[ch], ch, gr_info); | ||
1229 | } | ||
1230 | |||
1231 | for(ss = 0; ss < SSLIMIT; ss++) | ||
1232 | { | ||
1233 | if(single >= 0) | ||
1234 | { | ||
1235 | mpeg3audio_synth_mono(audio, hybridOut[0][ss], audio->pcm_sample, &(audio->pcm_point)); | ||
1236 | } | ||
1237 | else | ||
1238 | { | ||
1239 | int p1 = audio->pcm_point; | ||
1240 | mpeg3audio_synth_stereo(audio, hybridOut[0][ss], 0, audio->pcm_sample, &p1); | ||
1241 | mpeg3audio_synth_stereo(audio, hybridOut[1][ss], 1, audio->pcm_sample, &(audio->pcm_point)); | ||
1242 | } | ||
1243 | |||
1244 | if(audio->pcm_point / audio->channels >= audio->pcm_allocated - MPEG3AUDIO_PADDING * audio->channels) | ||
1245 | { | ||
1246 | /* Need more room */ | ||
1247 | mpeg3audio_replace_buffer(audio, audio->pcm_allocated + MPEG3AUDIO_PADDING * audio->channels); | ||
1248 | } | ||
1249 | } | ||
1250 | } | ||
1251 | |||
1252 | mpeg3bits_use_demuxer(audio->astream); | ||
1253 | return 0; | ||
1254 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/mantissa.c b/core/multimedia/opieplayer/libmpeg3/audio/mantissa.c new file mode 100644 index 0000000..05fe251 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/mantissa.c | |||
@@ -0,0 +1,387 @@ | |||
1 | /* | ||
2 | * | ||
3 | *mantissa.c Copyright (C) Aaron Holtzman - May 1999 | ||
4 | * | ||
5 | * | ||
6 | * This file is part of libmpeg3 | ||
7 | * | ||
8 | * libmpeg3 is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2, or (at your option) | ||
11 | * any later version. | ||
12 | * | ||
13 | * libmpeg3 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 | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with GNU Make; see the file COPYING. If not, write to | ||
20 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | * | ||
22 | */ | ||
23 | |||
24 | #include "mpeg3audio.h" | ||
25 | #include "../libmpeg3.h" | ||
26 | #include "../mpeg3protos.h" | ||
27 | |||
28 | |||
29 | /* Lookup tables of 0.16 two's complement quantization values */ | ||
30 | static short mpeg3_q_1[3] = | ||
31 | { | ||
32 | (-2 << 15) / 3, | ||
33 | 0, | ||
34 | (2 << 15) / 3 | ||
35 | }; | ||
36 | |||
37 | static short mpeg3_q_2[5] = | ||
38 | { | ||
39 | (-4 << 15) / 5, | ||
40 | ((-2 << 15) / 5) << 1, | ||
41 | 0, | ||
42 | (2 << 15) / 5, | ||
43 | ((4 << 15) / 5) << 1 | ||
44 | }; | ||
45 | |||
46 | static short mpeg3_q_3[7] = | ||
47 | { | ||
48 | (-6 << 15) / 7, | ||
49 | (-4 << 15) / 7, | ||
50 | (-2 << 15) / 7, | ||
51 | 0, | ||
52 | (2 << 15) / 7, | ||
53 | (4 << 15) / 7, | ||
54 | (6 << 15) / 7 | ||
55 | }; | ||
56 | |||
57 | static short mpeg3_q_4[11] = | ||
58 | { | ||
59 | (-10 << 15) / 11, | ||
60 | (-8 << 15) / 11, | ||
61 | (-6 << 15) / 11, | ||
62 | (-4 << 15) / 11, | ||
63 | (-2 << 15) / 11, | ||
64 | 0, | ||
65 | ( 2 << 15) / 11, | ||
66 | ( 4 << 15) / 11, | ||
67 | ( 6 << 15) / 11, | ||
68 | ( 8 << 15) / 11, | ||
69 | (10 << 15) / 11 | ||
70 | }; | ||
71 | |||
72 | static short mpeg3_q_5[15] = | ||
73 | { | ||
74 | (-14 << 15) / 15, | ||
75 | (-12 << 15) / 15, | ||
76 | (-10 << 15) / 15, | ||
77 | (-8 << 15) / 15, | ||
78 | (-6 << 15) / 15, | ||
79 | (-4 << 15) / 15, | ||
80 | (-2 << 15) / 15, | ||
81 | 0, | ||
82 | ( 2 << 15) / 15, | ||
83 | ( 4 << 15) / 15, | ||
84 | ( 6 << 15) / 15, | ||
85 | ( 8 << 15) / 15, | ||
86 | (10 << 15) / 15, | ||
87 | (12 << 15) / 15, | ||
88 | (14 << 15) / 15 | ||
89 | }; | ||
90 | |||
91 | static short mpeg3_qnttztab[16] = {0, 0, 0, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16}; | ||
92 | |||
93 | |||
94 | /* */ | ||
95 | /* Scale factors for tofloat */ | ||
96 | /* */ | ||
97 | |||
98 | static const unsigned MPEG3_INT32 mpeg3_scale_factors[25] = | ||
99 | { | ||
100 | 0x38000000, /*2 ^ -(0 + 15) */ | ||
101 | 0x37800000, /*2 ^ -(1 + 15) */ | ||
102 | 0x37000000, /*2 ^ -(2 + 15) */ | ||
103 | 0x36800000, /*2 ^ -(3 + 15) */ | ||
104 | 0x36000000, /*2 ^ -(4 + 15) */ | ||
105 | 0x35800000, /*2 ^ -(5 + 15) */ | ||
106 | 0x35000000, /*2 ^ -(6 + 15) */ | ||
107 | 0x34800000, /*2 ^ -(7 + 15) */ | ||
108 | 0x34000000, /*2 ^ -(8 + 15) */ | ||
109 | 0x33800000, /*2 ^ -(9 + 15) */ | ||
110 | 0x33000000, /*2 ^ -(10 + 15) */ | ||
111 | 0x32800000, /*2 ^ -(11 + 15) */ | ||
112 | 0x32000000, /*2 ^ -(12 + 15) */ | ||
113 | 0x31800000, /*2 ^ -(13 + 15) */ | ||
114 | 0x31000000, /*2 ^ -(14 + 15) */ | ||
115 | 0x30800000, /*2 ^ -(15 + 15) */ | ||
116 | 0x30000000, /*2 ^ -(16 + 15) */ | ||
117 | 0x2f800000, /*2 ^ -(17 + 15) */ | ||
118 | 0x2f000000, /*2 ^ -(18 + 15) */ | ||
119 | 0x2e800000, /*2 ^ -(19 + 15) */ | ||
120 | 0x2e000000, /*2 ^ -(20 + 15) */ | ||
121 | 0x2d800000, /*2 ^ -(21 + 15) */ | ||
122 | 0x2d000000, /*2 ^ -(22 + 15) */ | ||
123 | 0x2c800000, /*2 ^ -(23 + 15) */ | ||
124 | 0x2c000000 /*2 ^ -(24 + 15) */ | ||
125 | }; | ||
126 | |||
127 | static MPEG3_FLOAT32 *mpeg3_scale_factor = (MPEG3_FLOAT32*)mpeg3_scale_factors; | ||
128 | |||
129 | static inline mpeg3_real_t mpeg3audio_ac3_tofloat(unsigned short exponent, int mantissa) | ||
130 | { | ||
131 | mpeg3_real_t x; | ||
132 | x = mantissa * mpeg3_scale_factor[exponent]; | ||
133 | return x; | ||
134 | } | ||
135 | |||
136 | static inline void mpeg3audio_ac3_mantissa_reset(mpeg3_ac3_mantissa_t *mantissa) | ||
137 | { | ||
138 | mantissa->m_1[2] = mantissa->m_1[1] = mantissa->m_1[0] = 0; | ||
139 | mantissa->m_2[2] = mantissa->m_2[1] = mantissa->m_2[0] = 0; | ||
140 | mantissa->m_4[1] = mantissa->m_4[0] = 0; | ||
141 | /* Force new groups to be loaded */ | ||
142 | mantissa->m_1_pointer = mantissa->m_2_pointer = mantissa->m_4_pointer = 3; | ||
143 | } | ||
144 | |||
145 | /* | ||
146 | * Generate eight bits of pseudo-entropy using a 16 bit linear | ||
147 | * feedback shift register (LFSR). The primitive polynomial used | ||
148 | * is 1 + x^4 + x^14 + x^16. | ||
149 | * | ||
150 | * The distribution is uniform, over the range [-0.707,0.707] | ||
151 | * | ||
152 | */ | ||
153 | inline unsigned int mpeg3audio_ac3_dither_gen(mpeg3audio_t *audio) | ||
154 | { | ||
155 | int i; | ||
156 | unsigned int state; | ||
157 | |||
158 | /* explicitly bring the state into a local var as gcc > 3.0? */ | ||
159 | /* doesn't know how to optimize out the stores */ | ||
160 | state = audio->ac3_lfsr_state; | ||
161 | |||
162 | /* Generate eight pseudo random bits */ | ||
163 | for(i = 0; i < 8; i++) | ||
164 | { | ||
165 | state <<= 1; | ||
166 | |||
167 | if(state & 0x10000) | ||
168 | state ^= 0xa011; | ||
169 | } | ||
170 | |||
171 | audio->ac3_lfsr_state = state; | ||
172 | return (((((int)state << 8) >> 8) * (int)(0.707106f * 256.0f)) >> 16); | ||
173 | } | ||
174 | |||
175 | |||
176 | /* Fetch an unpacked, left justified, and properly biased/dithered mantissa value */ | ||
177 | static inline unsigned short mpeg3audio_ac3_mantissa_get(mpeg3audio_t *audio, | ||
178 | unsigned short bap, | ||
179 | unsigned short dithflag) | ||
180 | { | ||
181 | unsigned short mantissa; | ||
182 | unsigned int group_code; | ||
183 | mpeg3_ac3_mantissa_t *mantissa_struct = &(audio->ac3_mantissa); | ||
184 | |||
185 | /* If the bap is 0-5 then we have special cases to take care of */ | ||
186 | switch(bap) | ||
187 | { | ||
188 | case 0: | ||
189 | if(dithflag) | ||
190 | mantissa = mpeg3audio_ac3_dither_gen(audio); | ||
191 | else | ||
192 | mantissa = 0; | ||
193 | break; | ||
194 | |||
195 | case 1: | ||
196 | if(mantissa_struct->m_1_pointer > 2) | ||
197 | { | ||
198 | group_code = mpeg3bits_getbits(audio->astream, 5); | ||
199 | |||
200 | if(group_code > 26) | ||
201 | { | ||
202 | /* FIXME do proper block error handling */ | ||
203 | fprintf(stderr, "mpeg3audio_ac3_mantissa_get: Invalid mantissa 1 %d\n", group_code); | ||
204 | return 0; | ||
205 | } | ||
206 | |||
207 | mantissa_struct->m_1[0] = group_code / 9; | ||
208 | mantissa_struct->m_1[1] = (group_code % 9) / 3; | ||
209 | mantissa_struct->m_1[2] = (group_code % 9) % 3; | ||
210 | mantissa_struct->m_1_pointer = 0; | ||
211 | } | ||
212 | mantissa = mantissa_struct->m_1[mantissa_struct->m_1_pointer++]; | ||
213 | mantissa = mpeg3_q_1[mantissa]; | ||
214 | break; | ||
215 | |||
216 | case 2: | ||
217 | if(mantissa_struct->m_2_pointer > 2) | ||
218 | { | ||
219 | group_code = mpeg3bits_getbits(audio->astream, 7); | ||
220 | |||
221 | if(group_code > 124) | ||
222 | { | ||
223 | fprintf(stderr, "mpeg3audio_ac3_mantissa_get: Invalid mantissa 2 %d\n", group_code); | ||
224 | return 0; | ||
225 | } | ||
226 | |||
227 | mantissa_struct->m_2[0] = group_code / 25; | ||
228 | mantissa_struct->m_2[1] = (group_code % 25) / 5; | ||
229 | mantissa_struct->m_2[2] = (group_code % 25) % 5; | ||
230 | mantissa_struct->m_2_pointer = 0; | ||
231 | } | ||
232 | mantissa = mantissa_struct->m_2[mantissa_struct->m_2_pointer++]; | ||
233 | mantissa = mpeg3_q_2[mantissa]; | ||
234 | break; | ||
235 | |||
236 | case 3: | ||
237 | mantissa = mpeg3bits_getbits(audio->astream, 3); | ||
238 | |||
239 | if(mantissa > 6) | ||
240 | { | ||
241 | fprintf(stderr, "mpeg3audio_ac3_mantissa_get: Invalid mantissa 3 %d\n", mantissa); | ||
242 | return 0; | ||
243 | } | ||
244 | |||
245 | mantissa = mpeg3_q_3[mantissa]; | ||
246 | break; | ||
247 | |||
248 | case 4: | ||
249 | if(mantissa_struct->m_4_pointer > 1) | ||
250 | { | ||
251 | group_code = mpeg3bits_getbits(audio->astream, 7); | ||
252 | |||
253 | if(group_code > 120) | ||
254 | { | ||
255 | fprintf(stderr, "mpeg3audio_ac3_mantissa_get: Invalid mantissa 4 %d\n", group_code); | ||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | mantissa_struct->m_4[0] = group_code / 11; | ||
260 | mantissa_struct->m_4[1] = group_code % 11; | ||
261 | mantissa_struct->m_4_pointer = 0; | ||
262 | } | ||
263 | mantissa = mantissa_struct->m_4[mantissa_struct->m_4_pointer++]; | ||
264 | mantissa = mpeg3_q_4[mantissa]; | ||
265 | break; | ||
266 | |||
267 | case 5: | ||
268 | mantissa = mpeg3bits_getbits(audio->astream, 4); | ||
269 | |||
270 | if(mantissa > 14) | ||
271 | { | ||
272 | /* FIXME do proper block error handling */ | ||
273 | fprintf(stderr, "mpeg3audio_ac3_mantissa_get: Invalid mantissa 5 %d\n", mantissa); | ||
274 | return 0; | ||
275 | } | ||
276 | |||
277 | mantissa = mpeg3_q_5[mantissa]; | ||
278 | break; | ||
279 | |||
280 | default: | ||
281 | mantissa = mpeg3bits_getbits(audio->astream, mpeg3_qnttztab[bap]); | ||
282 | mantissa <<= 16 - mpeg3_qnttztab[bap]; | ||
283 | } | ||
284 | return mantissa; | ||
285 | } | ||
286 | |||
287 | void mpeg3audio_ac3_uncouple_channel(mpeg3audio_t *audio, | ||
288 | mpeg3_real_t samples[], | ||
289 | mpeg3_ac3bsi_t *bsi, | ||
290 | mpeg3_ac3audblk_t *audblk, | ||
291 | unsigned int ch) | ||
292 | { | ||
293 | unsigned int bnd = 0; | ||
294 | unsigned int sub_bnd = 0; | ||
295 | unsigned int i, j; | ||
296 | MPEG3_FLOAT32 cpl_coord = 1.0; | ||
297 | unsigned int cpl_exp_tmp; | ||
298 | unsigned int cpl_mant_tmp; | ||
299 | short mantissa; | ||
300 | |||
301 | for(i = audblk->cplstrtmant; i < audblk->cplendmant; ) | ||
302 | { | ||
303 | if(!audblk->cplbndstrc[sub_bnd++]) | ||
304 | { | ||
305 | cpl_exp_tmp = audblk->cplcoexp[ch][bnd] + 3 * audblk->mstrcplco[ch]; | ||
306 | if(audblk->cplcoexp[ch][bnd] == 15) | ||
307 | cpl_mant_tmp = (audblk->cplcomant[ch][bnd]) << 11; | ||
308 | else | ||
309 | cpl_mant_tmp = ((0x10) | audblk->cplcomant[ch][bnd]) << 10; | ||
310 | |||
311 | cpl_coord = mpeg3audio_ac3_tofloat(cpl_exp_tmp, cpl_mant_tmp) * 8.0f; | ||
312 | |||
313 | /*Invert the phase for the right channel if necessary */ | ||
314 | if(bsi->acmod == 0x2 && audblk->phsflginu && ch == 1 && audblk->phsflg[bnd]) | ||
315 | cpl_coord *= -1; | ||
316 | |||
317 | bnd++; | ||
318 | } | ||
319 | |||
320 | for(j = 0; j < 12; j++) | ||
321 | { | ||
322 | /* Get new dither values for each channel if necessary, so */ | ||
323 | /* the channels are uncorrelated */ | ||
324 | if(audblk->dithflag[ch] && audblk->cpl_bap[i] == 0) | ||
325 | mantissa = mpeg3audio_ac3_dither_gen(audio); | ||
326 | else | ||
327 | mantissa = audblk->cplmant[i]; | ||
328 | |||
329 | samples[i] = cpl_coord * mpeg3audio_ac3_tofloat(audblk->cpl_exp[i], mantissa);; | ||
330 | |||
331 | i++; | ||
332 | } | ||
333 | } | ||
334 | return; | ||
335 | } | ||
336 | |||
337 | int mpeg3audio_ac3_coeff_unpack(mpeg3audio_t *audio, | ||
338 | mpeg3_ac3bsi_t *bsi, | ||
339 | mpeg3_ac3audblk_t *audblk, | ||
340 | mpeg3ac3_stream_samples_t samples) | ||
341 | { | ||
342 | int i, j; | ||
343 | int done_cpl = 0; | ||
344 | short mantissa; | ||
345 | |||
346 | mpeg3audio_ac3_mantissa_reset(&(audio->ac3_mantissa)); | ||
347 | |||
348 | for(i = 0; i < bsi->nfchans && !mpeg3bits_error(audio->astream); i++) | ||
349 | { | ||
350 | for(j = 0; j < audblk->endmant[i] && !mpeg3bits_error(audio->astream); j++) | ||
351 | { | ||
352 | mantissa = mpeg3audio_ac3_mantissa_get(audio, audblk->fbw_bap[i][j], audblk->dithflag[i]); | ||
353 | samples[i][j] = mpeg3audio_ac3_tofloat(audblk->fbw_exp[i][j], mantissa); | ||
354 | } | ||
355 | |||
356 | if(audblk->cplinu && audblk->chincpl[i] && !(done_cpl) && !mpeg3bits_error(audio->astream)) | ||
357 | { | ||
358 | /* ncplmant is equal to 12 * ncplsubnd */ | ||
359 | /* Don't dither coupling channel until channel separation so that | ||
360 | * interchannel noise is uncorrelated */ | ||
361 | for(j = audblk->cplstrtmant; | ||
362 | j < audblk->cplendmant && !mpeg3bits_error(audio->astream); | ||
363 | j++) | ||
364 | { | ||
365 | audblk->cplmant[j] = mpeg3audio_ac3_mantissa_get(audio, audblk->cpl_bap[j], 0); | ||
366 | } | ||
367 | done_cpl = 1; | ||
368 | } | ||
369 | } | ||
370 | |||
371 | /* Uncouple the channel */ | ||
372 | if(audblk->cplinu) | ||
373 | { | ||
374 | if(audblk->chincpl[i]) | ||
375 | mpeg3audio_ac3_uncouple_channel(audio, samples[i], bsi, audblk, i); | ||
376 | } | ||
377 | |||
378 | if(bsi->lfeon && !mpeg3bits_error(audio->astream)) | ||
379 | { | ||
380 | /* There are always 7 mantissas for lfe, no dither for lfe */ | ||
381 | for(j = 0; j < 7 && !mpeg3bits_error(audio->astream); j++) | ||
382 | mantissa = mpeg3audio_ac3_mantissa_get(audio, audblk->lfe_bap[j], 0); | ||
383 | samples[5][j] = mpeg3audio_ac3_tofloat(audblk->lfe_exp[j], mantissa); | ||
384 | } | ||
385 | |||
386 | return mpeg3bits_error(audio->astream); | ||
387 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/mpeg3audio.c b/core/multimedia/opieplayer/libmpeg3/audio/mpeg3audio.c new file mode 100644 index 0000000..e2d3912 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/mpeg3audio.c | |||
@@ -0,0 +1,536 @@ | |||
1 | #include "../libmpeg3.h" | ||
2 | #include "../mpeg3protos.h" | ||
3 | #include "mpeg3audio.h" | ||
4 | #include "tables.h" | ||
5 | |||
6 | #include <math.h> | ||
7 | #include <stdlib.h> | ||
8 | |||
9 | mpeg3audio_t* mpeg3audio_allocate_struct(mpeg3_t *file, mpeg3_atrack_t *track) | ||
10 | { | ||
11 | mpeg3audio_t *audio = (mpeg3audio_t*)calloc(1, sizeof(mpeg3audio_t)); | ||
12 | audio->file = file; | ||
13 | audio->track = track; | ||
14 | audio->astream = mpeg3bits_new_stream(file, track->demuxer); | ||
15 | audio->outscale = 1; | ||
16 | audio->bsbuf = audio->bsspace[1]; | ||
17 | audio->init = 1; | ||
18 | audio->bo = 1; | ||
19 | audio->channels = 1; | ||
20 | return audio; | ||
21 | } | ||
22 | |||
23 | |||
24 | int mpeg3audio_delete_struct(mpeg3audio_t *audio) | ||
25 | { | ||
26 | mpeg3bits_delete_stream(audio->astream); | ||
27 | if(audio->pcm_sample) free(audio->pcm_sample); | ||
28 | free(audio); | ||
29 | return 0; | ||
30 | } | ||
31 | |||
32 | int mpeg3audio_replace_buffer(mpeg3audio_t *audio, long new_allocation) | ||
33 | { | ||
34 | long i; | ||
35 | |||
36 | audio->pcm_sample = (mpeg3_real_t*)realloc( audio->pcm_sample, sizeof(mpeg3_real_t) * new_allocation * audio->channels ); | ||
37 | audio->pcm_allocated = new_allocation; | ||
38 | /* | ||
39 | // Isn't this exactly the same as what the ANSI C function call realloc does, | ||
40 | // or did I miss C Programming 101 ? | ||
41 | |||
42 | if(!audio->pcm_sample) | ||
43 | { | ||
44 | audio->pcm_sample = (mpeg3_real_t*)malloc(sizeof(mpeg3_real_t) * new_allocation * audio->channels); | ||
45 | audio->pcm_allocated = new_allocation; | ||
46 | } | ||
47 | else | ||
48 | { | ||
49 | mpeg3_real_t *new_samples = (mpeg3_real_t*)malloc(sizeof(mpeg3_real_t) * new_allocation * audio->channels); | ||
50 | for(i = 0; i < audio->pcm_allocated * audio->channels; i++) | ||
51 | { | ||
52 | new_samples[i] = audio->pcm_sample[i]; | ||
53 | } | ||
54 | free(audio->pcm_sample); | ||
55 | audio->pcm_sample = new_samples; | ||
56 | audio->pcm_allocated = new_allocation; | ||
57 | } | ||
58 | */ | ||
59 | return 0; | ||
60 | } | ||
61 | |||
62 | int mpeg3audio_read_frame(mpeg3audio_t *audio) | ||
63 | { | ||
64 | int result = 0; | ||
65 | result = mpeg3audio_read_header(audio); | ||
66 | |||
67 | if(!result) | ||
68 | { | ||
69 | switch(audio->format) | ||
70 | { | ||
71 | case AUDIO_AC3: | ||
72 | result = mpeg3audio_do_ac3(audio); | ||
73 | break; | ||
74 | |||
75 | case AUDIO_MPEG: | ||
76 | switch(audio->layer) | ||
77 | { | ||
78 | case 1: | ||
79 | break; | ||
80 | |||
81 | case 2: | ||
82 | result = mpeg3audio_dolayer2(audio); | ||
83 | break; | ||
84 | |||
85 | case 3: | ||
86 | result = mpeg3audio_dolayer3(audio); | ||
87 | break; | ||
88 | |||
89 | default: | ||
90 | result = 1; | ||
91 | break; | ||
92 | } | ||
93 | break; | ||
94 | |||
95 | case AUDIO_PCM: | ||
96 | result = mpeg3audio_do_pcm(audio); | ||
97 | break; | ||
98 | } | ||
99 | } | ||
100 | |||
101 | if(!result) | ||
102 | { | ||
103 | /* Byte align the stream */ | ||
104 | mpeg3bits_byte_align(audio->astream); | ||
105 | } | ||
106 | return result; | ||
107 | } | ||
108 | |||
109 | /* Get the length but also initialize the frame sizes. */ | ||
110 | int mpeg3audio_get_length(mpeg3audio_t *audio, mpeg3_atrack_t *track) | ||
111 | { | ||
112 | long result = 0; | ||
113 | long framesize1 = 0, total1 = 0; | ||
114 | long framesize2 = 0, total2 = 0; | ||
115 | long total_framesize = 0, total_frames = 0; | ||
116 | long byte_limit = 131072; /* Total bytes to gather information from */ | ||
117 | long total_bytes = 0; | ||
118 | long major_framesize; /* Bigger framesize + header */ | ||
119 | long minor_framesize; /* Smaller framesize + header */ | ||
120 | long major_total; | ||
121 | long minor_total; | ||
122 | mpeg3_t *file = audio->file; | ||
123 | |||
124 | /* Get the frame sizes */ | ||
125 | mpeg3bits_seek_start(audio->astream); | ||
126 | audio->pcm_point = 0; | ||
127 | result = mpeg3audio_read_frame(audio); /* Stores the framesize */ | ||
128 | audio->samples_per_frame = audio->pcm_point / audio->channels; | ||
129 | |||
130 | switch(audio->format) | ||
131 | { | ||
132 | case AUDIO_AC3: | ||
133 | audio->avg_framesize = audio->framesize; | ||
134 | break; | ||
135 | |||
136 | case AUDIO_MPEG: | ||
137 | framesize1 = audio->framesize; | ||
138 | total_bytes += audio->framesize; | ||
139 | total1 = 1; | ||
140 | |||
141 | while(!result && total_bytes < byte_limit) | ||
142 | { | ||
143 | audio->pcm_point = 0; | ||
144 | result = mpeg3audio_read_frame(audio); | ||
145 | total_bytes += audio->framesize; | ||
146 | if(audio->framesize != framesize1) | ||
147 | { | ||
148 | framesize2 = audio->framesize; | ||
149 | total2 = 1; | ||
150 | break; | ||
151 | } | ||
152 | else | ||
153 | { | ||
154 | total1++; | ||
155 | } | ||
156 | } | ||
157 | |||
158 | while(!result && total_bytes < byte_limit) | ||
159 | { | ||
160 | audio->pcm_point = 0; | ||
161 | result = mpeg3audio_read_frame(audio); | ||
162 | total_bytes += audio->framesize; | ||
163 | if(audio->framesize != framesize2) | ||
164 | { | ||
165 | break; | ||
166 | } | ||
167 | else | ||
168 | { | ||
169 | total2++; | ||
170 | } | ||
171 | } | ||
172 | |||
173 | audio->pcm_point = 0; | ||
174 | result = mpeg3audio_read_frame(audio); | ||
175 | if(audio->framesize != framesize1 && audio->framesize != framesize2) | ||
176 | { | ||
177 | /* Variable bit rate. Get the average frame size. */ | ||
178 | while(!result && total_bytes < byte_limit) | ||
179 | { | ||
180 | audio->pcm_point = 0; | ||
181 | result = mpeg3audio_read_frame(audio); | ||
182 | total_bytes += audio->framesize; | ||
183 | if(!result) | ||
184 | { | ||
185 | total_framesize += audio->framesize; | ||
186 | total_frames++; | ||
187 | } | ||
188 | } | ||
189 | audio->avg_framesize = 4 + (total_framesize + framesize1 + framesize2) / (total_frames + total1 + total2); | ||
190 | } | ||
191 | else | ||
192 | { | ||
193 | major_framesize = framesize2 > framesize1 ? framesize2 : framesize1; | ||
194 | major_total = framesize2 > framesize1 ? total2 : total1; | ||
195 | minor_framesize = framesize2 > framesize1 ? framesize1 : framesize2; | ||
196 | minor_total = framesize2 > framesize1 ? total1 : total2; | ||
197 | /* Add the headers to the framesizes */ | ||
198 | audio->avg_framesize = 4 + (major_framesize * major_total + minor_framesize * minor_total) / (major_total + minor_total); | ||
199 | } | ||
200 | break; | ||
201 | |||
202 | case AUDIO_PCM: | ||
203 | break; | ||
204 | } | ||
205 | |||
206 | /* Estimate the total samples */ | ||
207 | if(file->is_audio_stream) | ||
208 | { | ||
209 | /* From the raw file */ | ||
210 | result = (long)((float)mpeg3demuxer_total_bytes(audio->astream->demuxer) / audio->avg_framesize * audio->samples_per_frame); | ||
211 | } | ||
212 | else | ||
213 | { | ||
214 | /* Gross approximation from a multiplexed file. */ | ||
215 | result = (long)(mpeg3demux_length(audio->astream->demuxer) * track->sample_rate); | ||
216 | /* result = (long)((mpeg3_real_t)mpeg3_video_frames(file, 0) / mpeg3_frame_rate(file, 0) * track->sample_rate); */ | ||
217 | /* We would scan the multiplexed packets here for the right timecode if only */ | ||
218 | /* they had meaningful timecode. */ | ||
219 | } | ||
220 | |||
221 | audio->pcm_point = 0; | ||
222 | mpeg3bits_seek_start(audio->astream); | ||
223 | mpeg3audio_reset_synths(audio); | ||
224 | return result; | ||
225 | } | ||
226 | |||
227 | int mpeg3audio_seek(mpeg3audio_t *audio, long position) | ||
228 | { | ||
229 | int result = 0; | ||
230 | mpeg3_t *file = audio->file; | ||
231 | mpeg3_atrack_t *track = audio->track; | ||
232 | long frame_number; | ||
233 | long byte_position; | ||
234 | double time_position; | ||
235 | |||
236 | /* Sample seek wasn't requested */ | ||
237 | if(audio->sample_seek < 0) | ||
238 | { | ||
239 | audio->pcm_position = position; | ||
240 | audio->pcm_size = 0; | ||
241 | return 0; | ||
242 | } | ||
243 | |||
244 | /* Can't slide buffer. Seek instead. */ | ||
245 | if(!file->is_audio_stream) | ||
246 | { | ||
247 | /* Seek in a multiplexed stream using the multiplexer. */ | ||
248 | time_position = (double)position / track->sample_rate; | ||
249 | result |= mpeg3bits_seek_time(audio->astream, time_position); | ||
250 | audio->pcm_position = (long)mpeg3bits_packet_time(audio->astream) * track->sample_rate; | ||
251 | /*printf("wanted %f got %f\n", time_position, mpeg3bits_packet_time(audio->astream)); */ | ||
252 | } | ||
253 | else | ||
254 | { | ||
255 | /* Seek in an elemental stream. This algorithm achieves sample accuracy on fixed bitrates. */ | ||
256 | /* Forget about variable bitrates or program streams. */ | ||
257 | frame_number = position / audio->samples_per_frame; | ||
258 | byte_position = (long)(audio->avg_framesize * frame_number); | ||
259 | audio->pcm_position = frame_number * audio->samples_per_frame; | ||
260 | |||
261 | if(byte_position < audio->avg_framesize * 2) | ||
262 | { | ||
263 | result |= mpeg3bits_seek_start(audio->astream); | ||
264 | audio->pcm_position = 0; | ||
265 | } | ||
266 | else | ||
267 | { | ||
268 | result |= mpeg3bits_seek_byte(audio->astream, byte_position); | ||
269 | } | ||
270 | } | ||
271 | |||
272 | /* Arm the backstep buffer for layer 3 if not at the beginning already. */ | ||
273 | if(byte_position >= audio->avg_framesize * 2 && audio->layer == 3 && !result) | ||
274 | { | ||
275 | result |= mpeg3audio_prev_header(audio); | ||
276 | result |= mpeg3audio_read_layer3_frame(audio); | ||
277 | } | ||
278 | |||
279 | /* Reset the tables. */ | ||
280 | mpeg3audio_reset_synths(audio); | ||
281 | audio->pcm_size = 0; | ||
282 | audio->pcm_point = 0; | ||
283 | return result; | ||
284 | } | ||
285 | |||
286 | /* ================================================================ */ | ||
287 | /* ENTRY POINTS */ | ||
288 | /* ================================================================ */ | ||
289 | |||
290 | |||
291 | |||
292 | |||
293 | mpeg3audio_t* mpeg3audio_new(mpeg3_t *file, mpeg3_atrack_t *track, int format) | ||
294 | { | ||
295 | mpeg3audio_t *audio = mpeg3audio_allocate_struct(file, track); | ||
296 | int result = 0; | ||
297 | |||
298 | /* Init tables */ | ||
299 | mpeg3audio_new_decode_tables(audio); | ||
300 | audio->percentage_seek = -1; | ||
301 | audio->sample_seek = -1; | ||
302 | audio->format = format; | ||
303 | |||
304 | /* Determine the format of the stream */ | ||
305 | if(format == AUDIO_UNKNOWN) | ||
306 | { | ||
307 | if(((mpeg3bits_showbits(audio->astream, 32) & 0xffff0000) >> 16) == MPEG3_AC3_START_CODE) | ||
308 | audio->format = AUDIO_AC3; | ||
309 | else | ||
310 | audio->format = AUDIO_MPEG; | ||
311 | } | ||
312 | |||
313 | /* get channel count */ | ||
314 | result = mpeg3audio_read_header(audio); | ||
315 | |||
316 | /* Set up the sample buffer */ | ||
317 | mpeg3audio_replace_buffer(audio, 262144); | ||
318 | |||
319 | /* Copy information to the mpeg struct */ | ||
320 | if(!result) | ||
321 | { | ||
322 | track->channels = audio->channels; | ||
323 | |||
324 | switch(audio->format) | ||
325 | { | ||
326 | case AUDIO_AC3: | ||
327 | track->sample_rate = mpeg3_ac3_samplerates[audio->sampling_frequency_code]; | ||
328 | break; | ||
329 | |||
330 | case AUDIO_MPEG: | ||
331 | track->sample_rate = mpeg3_freqs[audio->sampling_frequency_code]; | ||
332 | break; | ||
333 | |||
334 | case AUDIO_PCM: | ||
335 | track->sample_rate = 48000; | ||
336 | break; | ||
337 | } | ||
338 | |||
339 | track->total_samples = mpeg3audio_get_length(audio, track); | ||
340 | result |= mpeg3bits_seek_start(audio->astream); | ||
341 | } | ||
342 | else | ||
343 | { | ||
344 | mpeg3audio_delete_struct(audio); | ||
345 | audio = 0; | ||
346 | } | ||
347 | |||
348 | return audio; | ||
349 | } | ||
350 | |||
351 | int mpeg3audio_delete(mpeg3audio_t *audio) | ||
352 | { | ||
353 | mpeg3audio_delete_struct(audio); | ||
354 | return 0; | ||
355 | } | ||
356 | |||
357 | int mpeg3audio_seek_percentage(mpeg3audio_t *audio, double percentage) | ||
358 | { | ||
359 | audio->percentage_seek = percentage; | ||
360 | return 0; | ||
361 | } | ||
362 | |||
363 | int mpeg3audio_seek_sample(mpeg3audio_t *audio, long sample) | ||
364 | { | ||
365 | audio->sample_seek = sample; | ||
366 | return 0; | ||
367 | } | ||
368 | |||
369 | /* Read raw frames for concatenation purposes */ | ||
370 | int mpeg3audio_read_raw(mpeg3audio_t *audio, unsigned char *output, long *size, long max_size) | ||
371 | { | ||
372 | int result = 0; | ||
373 | int i; | ||
374 | *size = 0; | ||
375 | |||
376 | switch(audio->format) | ||
377 | { | ||
378 | case AUDIO_AC3: | ||
379 | /* Just write the AC3 stream */ | ||
380 | if(mpeg3bits_read_buffer(audio->astream, output, audio->framesize)) | ||
381 | return 1; | ||
382 | *size = audio->framesize; | ||
383 | break; | ||
384 | |||
385 | case AUDIO_MPEG: | ||
386 | /* Fix the mpeg stream */ | ||
387 | result = mpeg3audio_read_header(audio); | ||
388 | if(!result) | ||
389 | { | ||
390 | if(max_size < 4) return 1; | ||
391 | *output++ = (audio->newhead & 0xff000000) >> 24; | ||
392 | *output++ = (audio->newhead & 0xff0000) >> 16; | ||
393 | *output++ = (audio->newhead & 0xff00) >> 8; | ||
394 | *output++ = (audio->newhead & 0xff); | ||
395 | *size += 4; | ||
396 | |||
397 | if(max_size < 4 + audio->framesize) return 1; | ||
398 | if(mpeg3bits_read_buffer(audio->astream, output, audio->framesize)) | ||
399 | return 1; | ||
400 | |||
401 | *size += audio->framesize; | ||
402 | } | ||
403 | break; | ||
404 | |||
405 | case AUDIO_PCM: | ||
406 | if(mpeg3bits_read_buffer(audio->astream, output, audio->framesize)) | ||
407 | return 1; | ||
408 | *size = audio->framesize; | ||
409 | break; | ||
410 | } | ||
411 | return result; | ||
412 | } | ||
413 | |||
414 | /* Channel is 0 to channels - 1 */ | ||
415 | int mpeg3audio_decode_audio(mpeg3audio_t *audio, | ||
416 | mpeg3_real_t *output_f, | ||
417 | short *output_i, int sampleSpacing, | ||
418 | int channel, | ||
419 | long start_position, | ||
420 | long len) | ||
421 | { | ||
422 | long allocation_needed = len + MPEG3AUDIO_PADDING; | ||
423 | long i, j, result = 0; | ||
424 | mpeg3_t *file = audio->file; | ||
425 | mpeg3_atrack_t *atrack = audio->track; | ||
426 | long attempts; | ||
427 | |||
428 | /* Create new buffer */ | ||
429 | if(audio->pcm_allocated < allocation_needed) | ||
430 | { | ||
431 | mpeg3audio_replace_buffer(audio, allocation_needed); | ||
432 | } | ||
433 | |||
434 | /* There was a percentage seek */ | ||
435 | if(audio->percentage_seek >= 0) | ||
436 | { | ||
437 | mpeg3bits_seek_percentage(audio->astream, audio->percentage_seek); | ||
438 | /* Force the pcm buffer to be reread. */ | ||
439 | audio->pcm_position = start_position; | ||
440 | audio->pcm_size = 0; | ||
441 | audio->percentage_seek = -1; | ||
442 | } | ||
443 | else | ||
444 | { | ||
445 | /* Entire output is in buffer so don't do anything. */ | ||
446 | if(start_position >= audio->pcm_position && start_position < audio->pcm_position + audio->pcm_size && | ||
447 | start_position + len <= audio->pcm_size) | ||
448 | { | ||
449 | ; | ||
450 | } | ||
451 | else | ||
452 | /* Output starts in buffer but ends later so slide it back. */ | ||
453 | if(start_position <= audio->pcm_position + audio->pcm_size && | ||
454 | start_position >= audio->pcm_position) | ||
455 | { | ||
456 | for(i = 0, j = (start_position - audio->pcm_position) * audio->channels; | ||
457 | j < audio->pcm_size * audio->channels; | ||
458 | i++, j++) | ||
459 | { | ||
460 | audio->pcm_sample[i] = audio->pcm_sample[j]; | ||
461 | } | ||
462 | |||
463 | audio->pcm_point = i; | ||
464 | audio->pcm_size -= start_position - audio->pcm_position; | ||
465 | audio->pcm_position = start_position; | ||
466 | } | ||
467 | else | ||
468 | { | ||
469 | /* Output is outside buffer completely. */ | ||
470 | result = mpeg3audio_seek(audio, start_position); | ||
471 | audio->sample_seek = -1; | ||
472 | /* Check sanity */ | ||
473 | if(start_position < audio->pcm_position) audio->pcm_position = start_position; | ||
474 | } | ||
475 | audio->sample_seek = -1; | ||
476 | } | ||
477 | |||
478 | /* Read packets until the buffer is full. */ | ||
479 | if(!result) | ||
480 | { | ||
481 | attempts = 0; | ||
482 | result = 1; | ||
483 | while(attempts < 6 && | ||
484 | !mpeg3bits_eof(audio->astream) && | ||
485 | audio->pcm_size + audio->pcm_position < start_position + len) | ||
486 | { | ||
487 | result = mpeg3audio_read_frame(audio); | ||
488 | if(result) attempts++; | ||
489 | audio->pcm_size = audio->pcm_point / audio->channels; | ||
490 | } | ||
491 | } | ||
492 | |||
493 | |||
494 | |||
495 | /* Copy the buffer to the output */ | ||
496 | if(output_f) | ||
497 | { | ||
498 | for(i = 0, j = (start_position - audio->pcm_position) * audio->channels + channel; | ||
499 | i < len && j < audio->pcm_size * audio->channels; | ||
500 | i++, j += audio->channels) | ||
501 | { | ||
502 | output_f[i] = audio->pcm_sample[j]; | ||
503 | } | ||
504 | for( ; i < len; i++) | ||
505 | { | ||
506 | output_f[i] = 0; | ||
507 | } | ||
508 | } | ||
509 | else | ||
510 | if(output_i) | ||
511 | { | ||
512 | int sample; | ||
513 | for(i = 0, j = (start_position - audio->pcm_position) * audio->channels + channel; | ||
514 | i < (len*(sampleSpacing+1)) && j < audio->pcm_size * audio->channels; | ||
515 | i++, j += audio->channels) | ||
516 | { | ||
517 | sample = (int)(audio->pcm_sample[j] * 32767); | ||
518 | if(sample > 32767) sample = 32767; | ||
519 | else | ||
520 | if(sample < -32768) sample = -32768; | ||
521 | |||
522 | output_i[i] = sample; | ||
523 | i += sampleSpacing; | ||
524 | } | ||
525 | for( ; i < (len*(sampleSpacing+1)); i++) | ||
526 | { | ||
527 | output_i[i] = 0; | ||
528 | i += sampleSpacing; | ||
529 | } | ||
530 | } | ||
531 | |||
532 | if(audio->pcm_point > 0) | ||
533 | return 0; | ||
534 | else | ||
535 | return result; | ||
536 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/mpeg3audio.h b/core/multimedia/opieplayer/libmpeg3/audio/mpeg3audio.h new file mode 100644 index 0000000..2117be7 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/mpeg3audio.h | |||
@@ -0,0 +1,144 @@ | |||
1 | /********************************************************************** | ||
2 | ** Copyright (C) 2000 Trolltech AS. All rights reserved. | ||
3 | ** | ||
4 | ** This file is part of Qtopia Environment. | ||
5 | ** | ||
6 | ** This file may be distributed and/or modified under the terms of the | ||
7 | ** GNU General Public License version 2 as published by the Free Software | ||
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | ||
9 | ** packaging of this file. | ||
10 | ** | ||
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | ||
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | ||
13 | ** | ||
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | ||
15 | ** | ||
16 | ** Contact info@trolltech.com if any conditions of this licensing are | ||
17 | ** not clear to you. | ||
18 | ** | ||
19 | **********************************************************************/ | ||
20 | #ifndef MPEG3AUDIO_H | ||
21 | #define MPEG3AUDIO_H | ||
22 | |||
23 | #include "ac3.h" | ||
24 | #include "../bitstream.h" | ||
25 | typedef struct mpeg3_atrack_rec mpeg3_atrack_t; | ||
26 | |||
27 | #define MAXFRAMESIZE 1792 | ||
28 | #define HDRCMPMASK 0xfffffd00 | ||
29 | #define SBLIMIT 32 | ||
30 | #define SSLIMIT 18 | ||
31 | #define SCALE_BLOCK 12 | ||
32 | #define MPEG3AUDIO_PADDING 1024 | ||
33 | |||
34 | /* Values for mode */ | ||
35 | #define MPG_MD_STEREO 0 | ||
36 | #define MPG_MD_JOINT_STEREO 1 | ||
37 | #define MPG_MD_DUAL_CHANNEL 2 | ||
38 | #define MPG_MD_MONO 3 | ||
39 | |||
40 | /* IMDCT variables */ | ||
41 | typedef struct | ||
42 | { | ||
43 | mpeg3_real_t real; | ||
44 | mpeg3_real_t imag; | ||
45 | } mpeg3_complex_t; | ||
46 | |||
47 | #define AC3_N 512 | ||
48 | |||
49 | struct al_table | ||
50 | { | ||
51 | short bits; | ||
52 | short d; | ||
53 | }; | ||
54 | |||
55 | typedef struct | ||
56 | { | ||
57 | struct mpeg3_rec* file; | ||
58 | mpeg3_atrack_t* track; | ||
59 | mpeg3_bits_t *astream; | ||
60 | |||
61 | /* In order of importance */ | ||
62 | int format; /* format of audio */ | ||
63 | int layer; /* layer if mpeg */ | ||
64 | int channels; | ||
65 | long outscale; | ||
66 | long framenum; | ||
67 | long prev_framesize; | ||
68 | long framesize; /* For mp3 current framesize without header. For AC3 current framesize with header. */ | ||
69 | int avg_framesize; /* Includes the 4 byte header */ | ||
70 | mpeg3_real_t *pcm_sample; /* Interlaced output from synthesizer in floats */ | ||
71 | int pcm_point; /* Float offset in pcm_sample to write to */ | ||
72 | long pcm_position; /* Sample start of pcm_samples in file */ | ||
73 | long pcm_size; /* Number of pcm samples in the buffer */ | ||
74 | long pcm_allocated; /* Allocated number of samples in pcm_samples */ | ||
75 | int sample_seek; | ||
76 | double percentage_seek; | ||
77 | unsigned long oldhead; | ||
78 | unsigned long newhead; | ||
79 | unsigned long firsthead; | ||
80 | int bsnum; | ||
81 | int lsf; | ||
82 | int mpeg35; | ||
83 | int sampling_frequency_code; | ||
84 | int bitrate_index; | ||
85 | int bitrate; | ||
86 | int samples_per_frame; | ||
87 | int padding; | ||
88 | int extension; | ||
89 | int mode; | ||
90 | int mode_ext; | ||
91 | int copyright; | ||
92 | int original; | ||
93 | int emphasis; | ||
94 | int error_protection; | ||
95 | |||
96 | /* Back step buffers for mp3 */ | ||
97 | unsigned char bsspace[2][MAXFRAMESIZE + 512]; /* MAXFRAMESIZE */ | ||
98 | unsigned char *bsbuf, *bsbufold; | ||
99 | long ssize; | ||
100 | int init; | ||
101 | int single; | ||
102 | struct al_table *alloc; | ||
103 | int II_sblimit; | ||
104 | int jsbound; | ||
105 | int bo; /* Static variable in synthesizer */ | ||
106 | |||
107 | /* MP3 Static arrays here */ | ||
108 | mpeg3_real_t synth_stereo_buffs[2][2][0x110]; | ||
109 | mpeg3_real_t synth_mono_buff[64]; | ||
110 | unsigned int layer2_scfsi_buf[64]; | ||
111 | |||
112 | mpeg3_real_t mp3_block[2][2][SBLIMIT * SSLIMIT]; | ||
113 | int mp3_blc[2]; | ||
114 | |||
115 | /* AC3 specific stuff. AC3 also shares objects with MPEG */ | ||
116 | unsigned int ac3_framesize_code; | ||
117 | mpeg3_ac3bsi_t ac3_bsi; | ||
118 | mpeg3_ac3audblk_t ac3_audblk; | ||
119 | mpeg3_ac3_bitallocation_t ac3_bit_allocation; | ||
120 | mpeg3_ac3_mantissa_t ac3_mantissa; | ||
121 | mpeg3_complex_t ac3_imdct_buf[AC3_N / 4]; | ||
122 | |||
123 | /* Delay buffer for DCT interleaving */ | ||
124 | mpeg3_real_t ac3_delay[6][AC3_N / 2]; | ||
125 | /* Twiddle factor LUT */ | ||
126 | mpeg3_complex_t *ac3_w[7]; | ||
127 | #if !defined(USE_FIXED_POINT) || defined(PRINT_FIXED_POINT_TABLES) | ||
128 | /* Just for allocated memory */ | ||
129 | mpeg3_complex_t ac3_w_1[1]; | ||
130 | mpeg3_complex_t ac3_w_2[2]; | ||
131 | mpeg3_complex_t ac3_w_4[4]; | ||
132 | mpeg3_complex_t ac3_w_8[8]; | ||
133 | mpeg3_complex_t ac3_w_16[16]; | ||
134 | mpeg3_complex_t ac3_w_32[32]; | ||
135 | mpeg3_complex_t ac3_w_64[64]; | ||
136 | #endif | ||
137 | int ac3_lfsr_state; | ||
138 | unsigned char ac3_buffer[MAX_AC3_FRAMESIZE]; | ||
139 | mpeg3ac3_stream_samples_t ac3_samples; | ||
140 | } mpeg3audio_t; | ||
141 | |||
142 | |||
143 | |||
144 | #endif | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/mpeg3real.h b/core/multimedia/opieplayer/libmpeg3/audio/mpeg3real.h new file mode 100644 index 0000000..cdcac3d --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/mpeg3real.h | |||
@@ -0,0 +1,232 @@ | |||
1 | /********************************************************************** | ||
2 | ** Copyright (C) 2000 Trolltech AS. All rights reserved. | ||
3 | ** | ||
4 | ** This file is part of Qtopia Environment. | ||
5 | ** | ||
6 | ** This file may be distributed and/or modified under the terms of the | ||
7 | ** GNU General Public License version 2 as published by the Free Software | ||
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | ||
9 | ** packaging of this file. | ||
10 | ** | ||
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | ||
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | ||
13 | ** | ||
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | ||
15 | ** | ||
16 | ** Contact info@trolltech.com if any conditions of this licensing are | ||
17 | ** not clear to you. | ||
18 | ** | ||
19 | **********************************************************************/ | ||
20 | #ifndef MPEG3REAL_H | ||
21 | #define MPEG3REAL_H | ||
22 | |||
23 | #ifdef USE_FIXED_POINT | ||
24 | |||
25 | #include <limits.h> | ||
26 | #include <stdio.h> | ||
27 | |||
28 | #ifndef LONGLONG | ||
29 | #define LONGLONG long long | ||
30 | #endif | ||
31 | |||
32 | //#define SC (1<<16) | ||
33 | #define SC (1<<15) | ||
34 | |||
35 | class mpeg3_real_t { | ||
36 | long v; | ||
37 | public: | ||
38 | mpeg3_real_t() { } // Uninitialized, just like a float | ||
39 | mpeg3_real_t(double d) { v=long(d*SC); } | ||
40 | mpeg3_real_t(float f) { v=long(f*SC); } | ||
41 | mpeg3_real_t(int i) { v=long(i*SC); } | ||
42 | long fixedPoint() const { return v; } | ||
43 | operator float() const { return ((float)v)/SC; } | ||
44 | operator int() const { return (int)(v/SC); } | ||
45 | mpeg3_real_t operator+() const; | ||
46 | mpeg3_real_t operator-() const; | ||
47 | mpeg3_real_t& operator= (const mpeg3_real_t&); | ||
48 | mpeg3_real_t& operator+= (const mpeg3_real_t&); | ||
49 | mpeg3_real_t& operator-= (const mpeg3_real_t&); | ||
50 | mpeg3_real_t& operator*= (const mpeg3_real_t&); | ||
51 | mpeg3_real_t& operator/= (const mpeg3_real_t&); | ||
52 | friend mpeg3_real_t operator+ (const mpeg3_real_t&, const mpeg3_real_t&); | ||
53 | friend mpeg3_real_t operator- (const mpeg3_real_t&, const mpeg3_real_t&); | ||
54 | friend mpeg3_real_t operator* (const mpeg3_real_t&, const mpeg3_real_t&); | ||
55 | friend mpeg3_real_t operator/ (const mpeg3_real_t&, const mpeg3_real_t&); | ||
56 | friend mpeg3_real_t operator+ (const mpeg3_real_t&, const float&); | ||
57 | friend mpeg3_real_t operator- (const mpeg3_real_t&, const float&); | ||
58 | friend mpeg3_real_t operator* (const mpeg3_real_t&, const float&); | ||
59 | friend mpeg3_real_t operator/ (const mpeg3_real_t&, const float&); | ||
60 | friend mpeg3_real_t operator+ (const float&, const mpeg3_real_t&); | ||
61 | friend mpeg3_real_t operator- (const float&, const mpeg3_real_t&); | ||
62 | friend mpeg3_real_t operator* (const float&, const mpeg3_real_t&); | ||
63 | friend mpeg3_real_t operator/ (const float&, const mpeg3_real_t&); | ||
64 | friend mpeg3_real_t operator+ (const mpeg3_real_t&, const int&); | ||
65 | friend mpeg3_real_t operator- (const mpeg3_real_t&, const int&); | ||
66 | friend mpeg3_real_t operator* (const mpeg3_real_t&, const int&); | ||
67 | friend mpeg3_real_t operator/ (const mpeg3_real_t&, const int&); | ||
68 | friend mpeg3_real_t operator+ (const int&, const mpeg3_real_t&); | ||
69 | friend mpeg3_real_t operator- (const int&, const mpeg3_real_t&); | ||
70 | friend mpeg3_real_t operator* (const int&, const mpeg3_real_t&); | ||
71 | friend mpeg3_real_t operator/ (const int&, const mpeg3_real_t&); | ||
72 | }; | ||
73 | |||
74 | inline mpeg3_real_t mpeg3_real_t::operator+() const | ||
75 | { | ||
76 | return *this; | ||
77 | } | ||
78 | |||
79 | inline mpeg3_real_t mpeg3_real_t::operator-() const | ||
80 | { | ||
81 | mpeg3_real_t r; | ||
82 | r.v=-v; | ||
83 | return r; | ||
84 | } | ||
85 | |||
86 | inline mpeg3_real_t& mpeg3_real_t::operator= (const mpeg3_real_t& o) | ||
87 | { | ||
88 | v=o.v; | ||
89 | return *this; | ||
90 | } | ||
91 | |||
92 | inline mpeg3_real_t& mpeg3_real_t::operator+= (const mpeg3_real_t& o) | ||
93 | { | ||
94 | v += o.v; | ||
95 | return *this; | ||
96 | } | ||
97 | |||
98 | inline mpeg3_real_t& mpeg3_real_t::operator-= (const mpeg3_real_t& o) | ||
99 | { | ||
100 | v -= o.v; | ||
101 | return *this; | ||
102 | } | ||
103 | |||
104 | inline mpeg3_real_t& mpeg3_real_t::operator*= (const mpeg3_real_t& o) | ||
105 | { | ||
106 | *this = *this * o; | ||
107 | return *this; | ||
108 | } | ||
109 | |||
110 | inline mpeg3_real_t& mpeg3_real_t::operator/= (const mpeg3_real_t& o) | ||
111 | { | ||
112 | *this = *this / o; | ||
113 | return *this; | ||
114 | } | ||
115 | |||
116 | |||
117 | inline mpeg3_real_t operator+ (const mpeg3_real_t&a, const mpeg3_real_t&b) | ||
118 | { | ||
119 | mpeg3_real_t r; | ||
120 | r.v=a.v+b.v; | ||
121 | return r; | ||
122 | } | ||
123 | |||
124 | inline mpeg3_real_t operator- (const mpeg3_real_t&a, const mpeg3_real_t&b) | ||
125 | { | ||
126 | mpeg3_real_t r; | ||
127 | r.v=a.v-b.v; | ||
128 | return r; | ||
129 | } | ||
130 | |||
131 | inline mpeg3_real_t operator* (const mpeg3_real_t&a, const mpeg3_real_t&b) | ||
132 | { | ||
133 | mpeg3_real_t r; | ||
134 | r.v = (LONGLONG)a.v * b.v / SC; | ||
135 | return r; | ||
136 | } | ||
137 | |||
138 | inline mpeg3_real_t operator/ (const mpeg3_real_t&a, const mpeg3_real_t&b) | ||
139 | { | ||
140 | mpeg3_real_t r; | ||
141 | r.v = (LONGLONG)a.v * SC / b.v; | ||
142 | return r; | ||
143 | } | ||
144 | |||
145 | inline mpeg3_real_t operator+ (const mpeg3_real_t&a, const float&b) | ||
146 | { | ||
147 | return a+mpeg3_real_t(b); | ||
148 | } | ||
149 | |||
150 | inline mpeg3_real_t operator- (const mpeg3_real_t&a, const float&b) | ||
151 | { | ||
152 | return a-mpeg3_real_t(b); | ||
153 | } | ||
154 | |||
155 | inline mpeg3_real_t operator* (const mpeg3_real_t&a, const float&b) | ||
156 | { | ||
157 | return a*mpeg3_real_t(b); | ||
158 | } | ||
159 | |||
160 | inline mpeg3_real_t operator/ (const mpeg3_real_t&a, const float&b) | ||
161 | { | ||
162 | return a/mpeg3_real_t(b); | ||
163 | } | ||
164 | |||
165 | |||
166 | inline mpeg3_real_t operator+ (const float&a, const mpeg3_real_t&b) | ||
167 | { | ||
168 | return mpeg3_real_t(a)+b; | ||
169 | } | ||
170 | |||
171 | inline mpeg3_real_t operator- (const float&a, const mpeg3_real_t&b) | ||
172 | { | ||
173 | return mpeg3_real_t(a)-b; | ||
174 | } | ||
175 | |||
176 | inline mpeg3_real_t operator* (const float&a, const mpeg3_real_t&b) | ||
177 | { | ||
178 | return mpeg3_real_t(a)*b; | ||
179 | } | ||
180 | |||
181 | inline mpeg3_real_t operator/ (const float&a, const mpeg3_real_t&b) | ||
182 | { | ||
183 | return mpeg3_real_t(a)/b; | ||
184 | } | ||
185 | |||
186 | |||
187 | inline mpeg3_real_t operator+ (const mpeg3_real_t&a, const int&b) | ||
188 | { | ||
189 | return a+mpeg3_real_t(b); | ||
190 | } | ||
191 | |||
192 | inline mpeg3_real_t operator- (const mpeg3_real_t&a, const int&b) | ||
193 | { | ||
194 | return a-mpeg3_real_t(b); | ||
195 | } | ||
196 | |||
197 | inline mpeg3_real_t operator* (const mpeg3_real_t&a, const int&b) | ||
198 | { | ||
199 | return a*mpeg3_real_t(b); | ||
200 | } | ||
201 | |||
202 | inline mpeg3_real_t operator/ (const mpeg3_real_t&a, const int&b) | ||
203 | { | ||
204 | return a/mpeg3_real_t(b); | ||
205 | } | ||
206 | |||
207 | |||
208 | inline mpeg3_real_t operator+ (const int&a, const mpeg3_real_t&b) | ||
209 | { | ||
210 | return mpeg3_real_t(a)+b; | ||
211 | } | ||
212 | |||
213 | inline mpeg3_real_t operator- (const int&a, const mpeg3_real_t&b) | ||
214 | { | ||
215 | return mpeg3_real_t(a)-b; | ||
216 | } | ||
217 | |||
218 | inline mpeg3_real_t operator* (const int&a, const mpeg3_real_t&b) | ||
219 | { | ||
220 | return mpeg3_real_t(a)*b; | ||
221 | } | ||
222 | |||
223 | inline mpeg3_real_t operator/ (const int&a, const mpeg3_real_t&b) | ||
224 | { | ||
225 | return mpeg3_real_t(a)/b; | ||
226 | } | ||
227 | |||
228 | #else | ||
229 | typedef float mpeg3_real_t; | ||
230 | #endif | ||
231 | |||
232 | #endif | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/pcm.c b/core/multimedia/opieplayer/libmpeg3/audio/pcm.c new file mode 100644 index 0000000..8fa0d25 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/pcm.c | |||
@@ -0,0 +1,51 @@ | |||
1 | #include "mpeg3audio.h" | ||
2 | #include "../libmpeg3.h" | ||
3 | #include "../mpeg3protos.h" | ||
4 | |||
5 | int mpeg3audio_read_pcm_header(mpeg3audio_t *audio) | ||
6 | { | ||
7 | unsigned int code; | ||
8 | |||
9 | code = mpeg3bits_getbits(audio->astream, 16); | ||
10 | while(!mpeg3bits_eof(audio->astream) && code != MPEG3_PCM_START_CODE) | ||
11 | { | ||
12 | code <<= 8; | ||
13 | code &= 0xffff; | ||
14 | code |= mpeg3bits_getbits(audio->astream, 8); | ||
15 | } | ||
16 | |||
17 | audio->avg_framesize = audio->framesize = 0x7db; | ||
18 | audio->channels = 2; | ||
19 | |||
20 | return mpeg3bits_eof(audio->astream); | ||
21 | } | ||
22 | |||
23 | int mpeg3audio_do_pcm(mpeg3audio_t *audio) | ||
24 | { | ||
25 | int i, j, k; | ||
26 | MPEG3_INT16 sample; | ||
27 | int frame_samples = (audio->framesize - 3) / audio->channels / 2; | ||
28 | |||
29 | if(mpeg3bits_read_buffer(audio->astream, audio->ac3_buffer, frame_samples * audio->channels * 2)) | ||
30 | return 1; | ||
31 | |||
32 | /* Need more room */ | ||
33 | if(audio->pcm_point / audio->channels >= audio->pcm_allocated - MPEG3AUDIO_PADDING * audio->channels) | ||
34 | { | ||
35 | mpeg3audio_replace_buffer(audio, audio->pcm_allocated + MPEG3AUDIO_PADDING * audio->channels); | ||
36 | } | ||
37 | |||
38 | k = 0; | ||
39 | for(i = 0; i < frame_samples; i++) | ||
40 | { | ||
41 | for(j = 0; j < audio->channels; j++) | ||
42 | { | ||
43 | sample = ((MPEG3_INT16)(audio->ac3_buffer[k++])) << 8; | ||
44 | sample |= audio->ac3_buffer[k++]; | ||
45 | audio->pcm_sample[audio->pcm_point + i * audio->channels + j] = | ||
46 | (mpeg3_real_t)sample / 32767; | ||
47 | } | ||
48 | } | ||
49 | audio->pcm_point += frame_samples * audio->channels; | ||
50 | return 0; | ||
51 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/synthesizers.c b/core/multimedia/opieplayer/libmpeg3/audio/synthesizers.c new file mode 100644 index 0000000..71a74b3 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/synthesizers.c | |||
@@ -0,0 +1,174 @@ | |||
1 | #include "mpeg3audio.h" | ||
2 | #include "../libmpeg3.h" | ||
3 | #include "../mpeg3protos.h" | ||
4 | #include "tables.h" | ||
5 | |||
6 | #define WRITE_SAMPLE(samples, sum) \ | ||
7 | { \ | ||
8 | (*samples) = (sum); \ | ||
9 | } | ||
10 | |||
11 | int mpeg3audio_synth_stereo(mpeg3audio_t *audio, mpeg3_real_t *bandPtr, int channel, mpeg3_real_t *out, int *pnt) | ||
12 | { | ||
13 | const int step = 2; | ||
14 | mpeg3_real_t *samples = out + *pnt; | ||
15 | register mpeg3_real_t sum; | ||
16 | mpeg3_real_t *b0, (*buf)[0x110]; | ||
17 | int bo1; | ||
18 | |||
19 | if(!channel) | ||
20 | { | ||
21 | audio->bo--; | ||
22 | audio->bo &= 0xf; | ||
23 | buf = audio->synth_stereo_buffs[0]; | ||
24 | } | ||
25 | else | ||
26 | { | ||
27 | samples++; | ||
28 | buf = audio->synth_stereo_buffs[1]; | ||
29 | } | ||
30 | |||
31 | if(audio->bo & 0x1) | ||
32 | { | ||
33 | b0 = buf[0]; | ||
34 | bo1 = audio->bo; | ||
35 | mpeg3audio_dct64(buf[1] + ((audio->bo + 1) & 0xf), buf[0] + audio->bo, bandPtr); | ||
36 | } | ||
37 | else | ||
38 | { | ||
39 | b0 = buf[1]; | ||
40 | bo1 = audio->bo + 1; | ||
41 | mpeg3audio_dct64(buf[0] + audio->bo, buf[1] + audio->bo + 1, bandPtr); | ||
42 | } | ||
43 | |||
44 | /*printf("%f %f %f\n", buf[0][0], buf[1][0], bandPtr[0]); */ | ||
45 | |||
46 | { | ||
47 | register int j; | ||
48 | mpeg3_real_t *window = mpeg3_decwin + 16 - bo1; | ||
49 | |||
50 | for(j = 16; j; j--, b0 += 0x10, window += 0x20, samples += step) | ||
51 | { | ||
52 | sum = window[0x0] * b0[0x0]; | ||
53 | sum -= window[0x1] * b0[0x1]; | ||
54 | sum += window[0x2] * b0[0x2]; | ||
55 | sum -= window[0x3] * b0[0x3]; | ||
56 | sum += window[0x4] * b0[0x4]; | ||
57 | sum -= window[0x5] * b0[0x5]; | ||
58 | sum += window[0x6] * b0[0x6]; | ||
59 | sum -= window[0x7] * b0[0x7]; | ||
60 | sum += window[0x8] * b0[0x8]; | ||
61 | sum -= window[0x9] * b0[0x9]; | ||
62 | sum += window[0xA] * b0[0xA]; | ||
63 | sum -= window[0xB] * b0[0xB]; | ||
64 | sum += window[0xC] * b0[0xC]; | ||
65 | sum -= window[0xD] * b0[0xD]; | ||
66 | sum += window[0xE] * b0[0xE]; | ||
67 | sum -= window[0xF] * b0[0xF]; | ||
68 | |||
69 | WRITE_SAMPLE(samples, sum); | ||
70 | } | ||
71 | |||
72 | sum = window[0x0] * b0[0x0]; | ||
73 | sum += window[0x2] * b0[0x2]; | ||
74 | sum += window[0x4] * b0[0x4]; | ||
75 | sum += window[0x6] * b0[0x6]; | ||
76 | sum += window[0x8] * b0[0x8]; | ||
77 | sum += window[0xA] * b0[0xA]; | ||
78 | sum += window[0xC] * b0[0xC]; | ||
79 | sum += window[0xE] * b0[0xE]; | ||
80 | WRITE_SAMPLE(samples, sum); | ||
81 | b0 -= 0x10; | ||
82 | window -= 0x20; | ||
83 | samples += step; | ||
84 | window += bo1 << 1; | ||
85 | |||
86 | for(j = 15; j; j--, b0 -= 0x10, window -= 0x20, samples += step) | ||
87 | { | ||
88 | sum = -window[-0x1] * b0[0x0]; | ||
89 | sum -= window[-0x2] * b0[0x1]; | ||
90 | sum -= window[-0x3] * b0[0x2]; | ||
91 | sum -= window[-0x4] * b0[0x3]; | ||
92 | sum -= window[-0x5] * b0[0x4]; | ||
93 | sum -= window[-0x6] * b0[0x5]; | ||
94 | sum -= window[-0x7] * b0[0x6]; | ||
95 | sum -= window[-0x8] * b0[0x7]; | ||
96 | sum -= window[-0x9] * b0[0x8]; | ||
97 | sum -= window[-0xA] * b0[0x9]; | ||
98 | sum -= window[-0xB] * b0[0xA]; | ||
99 | sum -= window[-0xC] * b0[0xB]; | ||
100 | sum -= window[-0xD] * b0[0xC]; | ||
101 | sum -= window[-0xE] * b0[0xD]; | ||
102 | sum -= window[-0xF] * b0[0xE]; | ||
103 | sum -= window[-0x0] * b0[0xF]; | ||
104 | |||
105 | WRITE_SAMPLE(samples, sum); | ||
106 | } | ||
107 | } | ||
108 | *pnt += 64; | ||
109 | |||
110 | return 0; | ||
111 | } | ||
112 | |||
113 | int mpeg3audio_synth_mono(mpeg3audio_t *audio, mpeg3_real_t *bandPtr, mpeg3_real_t *samples, int *pnt) | ||
114 | { | ||
115 | mpeg3_real_t *samples_tmp = audio->synth_mono_buff; | ||
116 | mpeg3_real_t *tmp1 = samples_tmp; | ||
117 | int i, ret; | ||
118 | int pnt1 = 0; | ||
119 | |||
120 | ret = mpeg3audio_synth_stereo(audio, bandPtr, 0, samples_tmp, &pnt1); | ||
121 | samples += *pnt; | ||
122 | |||
123 | for(i = 0; i < 32; i++) | ||
124 | { | ||
125 | *samples = *tmp1; | ||
126 | samples++; | ||
127 | tmp1 += 2; | ||
128 | } | ||
129 | *pnt += 32; | ||
130 | |||
131 | return ret; | ||
132 | } | ||
133 | |||
134 | |||
135 | /* Call this after every seek to reset the buffers */ | ||
136 | int mpeg3audio_reset_synths(mpeg3audio_t *audio) | ||
137 | { | ||
138 | int i, j, k; | ||
139 | for(i = 0; i < 2; i++) | ||
140 | { | ||
141 | for(j = 0; j < 2; j++) | ||
142 | { | ||
143 | for(k = 0; k < 0x110; k++) | ||
144 | { | ||
145 | audio->synth_stereo_buffs[i][j][k] = 0; | ||
146 | } | ||
147 | } | ||
148 | } | ||
149 | for(i = 0; i < 64; i++) | ||
150 | { | ||
151 | audio->synth_mono_buff[i] = 0; | ||
152 | audio->layer2_scfsi_buf[i] = 0; | ||
153 | } | ||
154 | for(i = 0; i < 2; i++) | ||
155 | { | ||
156 | for(j = 0; j < 2; j++) | ||
157 | { | ||
158 | for(k = 0; k < SBLIMIT * SSLIMIT; k++) | ||
159 | { | ||
160 | audio->mp3_block[i][j][k] = 0; | ||
161 | } | ||
162 | } | ||
163 | } | ||
164 | audio->mp3_blc[0] = 0; | ||
165 | audio->mp3_blc[1] = 0; | ||
166 | for(i = 0; i < audio->channels; i++) | ||
167 | { | ||
168 | for(j = 0; j < AC3_N / 2; j++) | ||
169 | { | ||
170 | audio->ac3_delay[i][j] = 0; | ||
171 | } | ||
172 | } | ||
173 | return 0; | ||
174 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/tables.c b/core/multimedia/opieplayer/libmpeg3/audio/tables.c new file mode 100644 index 0000000..aeab335 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/tables.c | |||
@@ -0,0 +1,554 @@ | |||
1 | #include "mpeg3audio.h" | ||
2 | #include "../libmpeg3.h" | ||
3 | #include "../mpeg3protos.h" | ||
4 | #include "tables.h" | ||
5 | |||
6 | #include <math.h> | ||
7 | |||
8 | /* Bitrate indexes */ | ||
9 | int mpeg3_tabsel_123[2][3][16] = { | ||
10 | { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,}, | ||
11 | {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,}, | ||
12 | {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} }, | ||
13 | |||
14 | { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,}, | ||
15 | {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}, | ||
16 | {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} } | ||
17 | }; | ||
18 | |||
19 | long mpeg3_freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 }; | ||
20 | |||
21 | #ifdef USE_3DNOW | ||
22 | mpeg3_real_t mpeg3_decwin[2 * (512 + 32)]; | ||
23 | mpeg3_real_t mpeg3_cos64[32], mpeg3_cos32[16], mpeg3_cos16[8], mpeg3_cos8[4], mpeg3_cos4[2]; | ||
24 | #else | ||
25 | mpeg3_real_t mpeg3_decwin[512 + 32]; | ||
26 | mpeg3_real_t mpeg3_cos64[16], mpeg3_cos32[8], mpeg3_cos16[4], mpeg3_cos8[2], mpeg3_cos4[1]; | ||
27 | #endif | ||
28 | |||
29 | mpeg3_real_t *mpeg3_pnts[] = { mpeg3_cos64, mpeg3_cos32, mpeg3_cos16, mpeg3_cos8, mpeg3_cos4 }; | ||
30 | |||
31 | int mpeg3_grp_3tab[32 * 3] = { 0, }; /* used: 27 */ | ||
32 | int mpeg3_grp_5tab[128 * 3] = { 0, }; /* used: 125 */ | ||
33 | int mpeg3_grp_9tab[1024 * 3] = { 0, }; /* used: 729 */ | ||
34 | |||
35 | REAL_MATRIX(mpeg3_muls, [27], [64]);/* also used by layer 1 */ | ||
36 | REAL_MATRIX(mpeg3_gainpow2, [256 + 118 + 4], ); | ||
37 | REAL_MATRIX(mpeg3_ispow, [8207], ); | ||
38 | REAL_MATRIX(mpeg3_aa_ca, [8], ); | ||
39 | REAL_MATRIX(mpeg3_aa_cs, [8], ); | ||
40 | REAL_MATRIX(mpeg3_win, [4], [36]); | ||
41 | REAL_MATRIX(mpeg3_win1, [4], [36]); | ||
42 | REAL_MATRIX(mpeg3_COS1, [12], [6]); | ||
43 | REAL_MATRIX(mpeg3_COS9, [9], ); | ||
44 | REAL_MATRIX(mpeg3_tfcos36, [9], ); | ||
45 | REAL_MATRIX(mpeg3_tfcos12, [3], ); | ||
46 | REAL_MATRIX(mpeg3_cos9, [3], ); | ||
47 | REAL_MATRIX(mpeg3_cos18, [3], ); | ||
48 | REAL_MATRIX(mpeg3_tan1_1, [16], ); | ||
49 | REAL_MATRIX(mpeg3_tan2_1, [16], ); | ||
50 | REAL_MATRIX(mpeg3_tan1_2, [16], ); | ||
51 | REAL_MATRIX(mpeg3_tan2_2, [16], ); | ||
52 | REAL_MATRIX(mpeg3_pow1_1, [2], [16]); | ||
53 | REAL_MATRIX(mpeg3_pow2_1, [2], [16]); | ||
54 | REAL_MATRIX(mpeg3_pow1_2, [2], [16]); | ||
55 | REAL_MATRIX(mpeg3_pow2_2, [2], [16]); | ||
56 | |||
57 | mpeg3_real_t mpeg3_COS6_1, mpeg3_COS6_2; | ||
58 | |||
59 | #ifdef PRINT_FIXED_POINT_TABLES | ||
60 | static void print_table(const char* var, mpeg3_real_t* data, int count) | ||
61 | { | ||
62 | int i; | ||
63 | printf("#ifdef USE_DATA_TABLES\n"); | ||
64 | printf("static long %s_data[] = {",var); | ||
65 | for(i = 0; i < count; i++) { | ||
66 | printf("%c0x%08x,", i%8?' ':'\n', data[i].fixedPoint()); | ||
67 | } | ||
68 | printf("};\n"); | ||
69 | printf("#endif\n"); | ||
70 | } | ||
71 | #endif | ||
72 | |||
73 | #ifdef PRINT_FIXED_POINT_TABLES | ||
74 | # define DO_TABLE(T) print_table(#T, T, sizeof(T)/sizeof(mpeg3_real_t)) | ||
75 | # define DO_TABLE2(T,DIM) print_table(#T, (mpeg3_real_t*)T, sizeof(T)/sizeof(mpeg3_real_t)) | ||
76 | #elif USE_FIXED_POINT | ||
77 | # define DO_TABLE(T) T = (mpeg3_real_t*)T##_data | ||
78 | // multidimensional | ||
79 | # define DO_TABLE2(T,DIM) T = (mpeg3_real_t(*)DIM)T##_data | ||
80 | #else | ||
81 | # define DO_TABLE(T) | ||
82 | # define DO_TABLE2(T,DIM) | ||
83 | #endif | ||
84 | |||
85 | #if defined(USE_FIXED_POINT) && !defined(PRINT_FIXED_POINT_TABLES) | ||
86 | #define USE_DATA_TABLES | ||
87 | #include "fptables.h" | ||
88 | #endif | ||
89 | |||
90 | long mpeg3_intwinbase[] = { | ||
91 | 0, -1, -1, -1, -1, -1, -1, -2, -2, -2, | ||
92 | -2, -3, -3, -4, -4, -5, -5, -6, -7, -7, | ||
93 | -8, -9, -10, -11, -13, -14, -16, -17, -19, -21, | ||
94 | -24, -26, -29, -31, -35, -38, -41, -45, -49, -53, | ||
95 | -58, -63, -68, -73, -79, -85, -91, -97, -104, -111, | ||
96 | -117, -125, -132, -139, -147, -154, -161, -169, -176, -183, | ||
97 | -190, -196, -202, -208, -213, -218, -222, -225, -227, -228, | ||
98 | -228, -227, -224, -221, -215, -208, -200, -189, -177, -163, | ||
99 | -146, -127, -106, -83, -57, -29, 2, 36, 72, 111, | ||
100 | 153, 197, 244, 294, 347, 401, 459, 519, 581, 645, | ||
101 | 711, 779, 848, 919, 991, 1064, 1137, 1210, 1283, 1356, | ||
102 | 1428, 1498, 1567, 1634, 1698, 1759, 1817, 1870, 1919, 1962, | ||
103 | 2001, 2032, 2057, 2075, 2085, 2087, 2080, 2063, 2037, 2000, | ||
104 | 1952, 1893, 1822, 1739, 1644, 1535, 1414, 1280, 1131, 970, | ||
105 | 794, 605, 402, 185, -45, -288, -545, -814, -1095, -1388, | ||
106 | -1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788, | ||
107 | -5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209, | ||
108 | -8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959, | ||
109 | -9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092, | ||
110 | -7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082, | ||
111 | -70, 998, 2122, 3300, 4533, 5818, 7154, 8540, 9975, 11455, | ||
112 | 12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289, | ||
113 | 30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617, | ||
114 | 48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684, | ||
115 | 64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835, | ||
116 | 73415, 73908, 74313, 74630, 74856, 74992, 75038 }; | ||
117 | |||
118 | int mpeg3_longLimit[9][23]; | ||
119 | int mpeg3_shortLimit[9][14]; | ||
120 | |||
121 | struct mpeg3_bandInfoStruct mpeg3_bandInfo[9] = | ||
122 | { | ||
123 | |||
124 | /* MPEG 1.0 */ | ||
125 | { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576}, | ||
126 | {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158}, | ||
127 | {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3}, | ||
128 | {4,4,4,4,6,8,10,12,14,18,22,30,56} } , | ||
129 | |||
130 | { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576}, | ||
131 | {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192}, | ||
132 | {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3}, | ||
133 | {4,4,4,4,6,6,10,12,14,16,20,26,66} } , | ||
134 | |||
135 | { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} , | ||
136 | {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} , | ||
137 | {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} , | ||
138 | {4,4,4,4,6,8,12,16,20,26,34,42,12} } , | ||
139 | |||
140 | /* MPEG 2.0 */ | ||
141 | { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, | ||
142 | {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } , | ||
143 | {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} , | ||
144 | {4,4,4,6,6,8,10,14,18,26,32,42,18 } } , | ||
145 | |||
146 | { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576}, | ||
147 | {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } , | ||
148 | {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} , | ||
149 | {4,4,4,6,8,10,12,14,18,24,32,44,12 } } , | ||
150 | |||
151 | { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, | ||
152 | {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 }, | ||
153 | {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3}, | ||
154 | {4,4,4,6,8,10,12,14,18,24,30,40,18 } } , | ||
155 | /* MPEG 2.5 */ | ||
156 | { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} , | ||
157 | {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54}, | ||
158 | {0,12,24,36,54,78,108,144,186,240,312,402,522,576}, | ||
159 | {4,4,4,6,8,10,12,14,18,24,30,40,18} }, | ||
160 | { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} , | ||
161 | {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54}, | ||
162 | {0,12,24,36,54,78,108,144,186,240,312,402,522,576}, | ||
163 | {4,4,4,6,8,10,12,14,18,24,30,40,18} }, | ||
164 | { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576}, | ||
165 | {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2}, | ||
166 | {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576}, | ||
167 | {8,8,8,12,16,20,24,28,36,2,2,2,26} } , | ||
168 | }; | ||
169 | |||
170 | int mpeg3_mapbuf0[9][152]; | ||
171 | int mpeg3_mapbuf1[9][156]; | ||
172 | int mpeg3_mapbuf2[9][44]; | ||
173 | int *mpeg3_map[9][3]; | ||
174 | int *mpeg3_mapend[9][3]; | ||
175 | |||
176 | unsigned int mpeg3_n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */ | ||
177 | unsigned int mpeg3_i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */ | ||
178 | |||
179 | int mpeg3audio_init_layer3(mpeg3audio_t *audio); | ||
180 | |||
181 | int mpeg3audio_init_layer2(mpeg3audio_t *audio) | ||
182 | { | ||
183 | static double mulmul[27] = | ||
184 | { | ||
185 | 0.0 , -2.0/3.0 , 2.0/3.0 , | ||
186 | 2.0/7.0 , 2.0/15.0 , 2.0/31.0, 2.0/63.0 , 2.0/127.0 , 2.0/255.0 , | ||
187 | 2.0/511.0 , 2.0/1023.0 , 2.0/2047.0 , 2.0/4095.0 , 2.0/8191.0 , | ||
188 | 2.0/16383.0 , 2.0/32767.0 , 2.0/65535.0 , | ||
189 | -4.0/5.0 , -2.0/5.0 , 2.0/5.0, 4.0/5.0 , | ||
190 | -8.0/9.0 , -4.0/9.0 , -2.0/9.0 , 2.0/9.0 , 4.0/9.0 , 8.0/9.0 | ||
191 | }; | ||
192 | static int base[3][9] = | ||
193 | { | ||
194 | { 1 , 0, 2 , } , | ||
195 | { 17, 18, 0 , 19, 20 , } , | ||
196 | { 21, 1, 22, 23, 0, 24, 25, 2, 26 } | ||
197 | }; | ||
198 | static int tablen[3] = { 3, 5, 9 }; | ||
199 | static int *itable, *tables[3] = {mpeg3_grp_3tab, mpeg3_grp_5tab, mpeg3_grp_9tab}; | ||
200 | int i, j, k, l, len; | ||
201 | mpeg3_real_t *table; | ||
202 | |||
203 | for(i = 0; i < 3; i++) | ||
204 | { | ||
205 | itable = tables[i]; | ||
206 | len = tablen[i]; | ||
207 | for(j = 0; j < len; j++) | ||
208 | for(k = 0; k < len; k++) | ||
209 | for(l = 0; l < len; l++) | ||
210 | { | ||
211 | *itable++ = base[i][l]; | ||
212 | *itable++ = base[i][k]; | ||
213 | *itable++ = base[i][j]; | ||
214 | } | ||
215 | } | ||
216 | |||
217 | #if !defined(USE_FIXED_POINT) || defined(PRINT_FIXED_POINT_TABLES) | ||
218 | #if defined(PRINT_FIXED_POINT_TABLES) | ||
219 | //mpeg3audio_init_layer3(audio); // we depend on mpeg3_muls table | ||
220 | #endif | ||
221 | for(k = 0; k < 27; k++) | ||
222 | { | ||
223 | double m = mulmul[k]; | ||
224 | table = mpeg3_muls[k]; | ||
225 | for(j = 3, i = 0; i < 63; i++, j--) | ||
226 | *table++ = m * pow(2.0, (double)j / 3.0); | ||
227 | *table++ = 0.0; | ||
228 | } | ||
229 | #endif | ||
230 | DO_TABLE2(mpeg3_muls,[64]); | ||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | int mpeg3audio_init_layer3(mpeg3audio_t *audio) | ||
235 | { | ||
236 | int i, j, k, l; | ||
237 | int down_sample_sblimit = 32; | ||
238 | |||
239 | audio->mp3_block[0][0][0] = 0; | ||
240 | audio->mp3_blc[0] = 0; | ||
241 | audio->mp3_blc[1] = 0; | ||
242 | |||
243 | #if !defined(USE_FIXED_POINT) || defined(PRINT_FIXED_POINT_TABLES) | ||
244 | for(i = -256; i < 118 + 4; i++) | ||
245 | mpeg3_gainpow2[i + 256] = pow((double)2.0, -0.25 * (double)(i + 210)); | ||
246 | |||
247 | for(i = 0; i < 8207; i++) | ||
248 | mpeg3_ispow[i] = pow((double)i, (double)4.0 / 3.0); | ||
249 | |||
250 | for(i = 0; i < 8; i++) | ||
251 | { | ||
252 | static double Ci[8] = {-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037}; | ||
253 | double sq = sqrt(1.0+Ci[i]*Ci[i]); | ||
254 | mpeg3_aa_cs[i] = 1.0/sq; | ||
255 | mpeg3_aa_ca[i] = Ci[i]/sq; | ||
256 | } | ||
257 | |||
258 | for(i = 0; i < 18; i++) | ||
259 | { | ||
260 | mpeg3_win[0][i] = mpeg3_win[1][i] = 0.5 * sin( M_PI / 72.0 * (double)(2 * (i + 0) + 1) ) / cos (M_PI * (double)(2 * (i + 0) + 19) / 72.0); | ||
261 | mpeg3_win[0][i+18] = mpeg3_win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double)(2 * (i + 18) + 1) ) / cos (M_PI * (double)(2 * (i + 18) + 19) / 72.0); | ||
262 | } | ||
263 | for(i = 0; i < 6; i++) | ||
264 | { | ||
265 | mpeg3_win[1][i + 18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ); | ||
266 | mpeg3_win[3][i + 12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 ); | ||
267 | mpeg3_win[1][i + 24] = 0.5 * sin( M_PI / 24.0 * (double)(2 * i + 13) ) / cos (M_PI * (double)(2 * (i + 24)+ 19) / 72.0 ); | ||
268 | mpeg3_win[1][i + 30] = mpeg3_win[3][i] = 0.0; | ||
269 | mpeg3_win[3][i + 6 ] = 0.5 * sin( M_PI / 24.0 * (double)(2 * i + 1) ) / cos (M_PI * (double)(2 * (i + 6 )+ 19) / 72.0 ); | ||
270 | } | ||
271 | |||
272 | for(i = 0; i < 9; i++) | ||
273 | mpeg3_COS9[i] = cos(M_PI / 18.0 * (double)i); | ||
274 | |||
275 | for(i = 0; i < 9; i++) | ||
276 | mpeg3_tfcos36[i] = 0.5 / cos (M_PI * (double) (i*2+1) / 36.0); | ||
277 | for(i = 0; i < 3; i++) | ||
278 | mpeg3_tfcos12[i] = 0.5 / cos (M_PI * (double) (i*2+1) / 12.0); | ||
279 | |||
280 | mpeg3_cos9[0] = cos(1.0 * M_PI / 9.0); | ||
281 | mpeg3_cos9[1] = cos(5.0 * M_PI / 9.0); | ||
282 | mpeg3_cos9[2] = cos(7.0 * M_PI / 9.0); | ||
283 | mpeg3_cos18[0] = cos(1.0 * M_PI / 18.0); | ||
284 | mpeg3_cos18[1] = cos(11.0 * M_PI / 18.0); | ||
285 | mpeg3_cos18[2] = cos(13.0 * M_PI / 18.0); | ||
286 | |||
287 | for(i = 0; i < 12; i++) | ||
288 | { | ||
289 | mpeg3_win[2][i] = 0.5 * sin(M_PI / 24.0 * (double) (2 * i + 1)) / cos(M_PI * (double)(2 * i + 7) / 24.0); | ||
290 | for(j = 0; j < 6; j++) | ||
291 | mpeg3_COS1[i][j] = cos(M_PI / 24.0 * (double) ((2 * i + 7) * (2 * j + 1))); | ||
292 | } | ||
293 | |||
294 | for(j = 0; j < 4; j++) | ||
295 | { | ||
296 | static int len[4] = {36, 36, 12, 36}; | ||
297 | for(i = 0; i < len[j]; i += 2) | ||
298 | mpeg3_win1[j][i] = + mpeg3_win[j][i]; | ||
299 | for(i = 1; i < len[j]; i += 2) | ||
300 | mpeg3_win1[j][i] = - mpeg3_win[j][i]; | ||
301 | } | ||
302 | |||
303 | for(i = 0; i < 16; i++) | ||
304 | { | ||
305 | double t = tan( (double) i * M_PI / 12.0 ); | ||
306 | mpeg3_tan1_1[i] = t / (1.0 + t); | ||
307 | mpeg3_tan2_1[i] = 1.0 / (1.0 + t); | ||
308 | mpeg3_tan1_2[i] = M_SQRT2 * t / (1.0 + t); | ||
309 | mpeg3_tan2_2[i] = M_SQRT2 / (1.0 + t); | ||
310 | |||
311 | for(j = 0; j < 2; j++) | ||
312 | { | ||
313 | double base = pow(2.0, -0.25 * (j + 1.0)); | ||
314 | double p1 = 1.0,p2 = 1.0; | ||
315 | if(i > 0) | ||
316 | { | ||
317 | if( i & 1 ) | ||
318 | p1 = pow(base, (i + 1.0) * 0.5); | ||
319 | else | ||
320 | p2 = pow(base, i * 0.5); | ||
321 | } | ||
322 | mpeg3_pow1_1[j][i] = p1; | ||
323 | mpeg3_pow2_1[j][i] = p2; | ||
324 | mpeg3_pow1_2[j][i] = M_SQRT2 * p1; | ||
325 | mpeg3_pow2_2[j][i] = M_SQRT2 * p2; | ||
326 | } | ||
327 | } | ||
328 | |||
329 | #endif | ||
330 | |||
331 | DO_TABLE(mpeg3_gainpow2); | ||
332 | DO_TABLE(mpeg3_ispow); | ||
333 | DO_TABLE(mpeg3_aa_cs); | ||
334 | DO_TABLE(mpeg3_aa_ca); | ||
335 | DO_TABLE2(mpeg3_win,[36]); | ||
336 | DO_TABLE(mpeg3_COS9); | ||
337 | DO_TABLE(mpeg3_tfcos36); | ||
338 | DO_TABLE(mpeg3_tfcos12); | ||
339 | DO_TABLE(mpeg3_cos9); | ||
340 | DO_TABLE(mpeg3_cos18); | ||
341 | DO_TABLE2(mpeg3_COS1,[6]); | ||
342 | DO_TABLE2(mpeg3_win1,[36]); | ||
343 | DO_TABLE(mpeg3_tan1_1); | ||
344 | DO_TABLE(mpeg3_tan2_1); | ||
345 | DO_TABLE(mpeg3_tan1_2); | ||
346 | DO_TABLE(mpeg3_tan2_2); | ||
347 | DO_TABLE2(mpeg3_pow1_1,[16]); | ||
348 | DO_TABLE2(mpeg3_pow2_1,[16]); | ||
349 | DO_TABLE2(mpeg3_pow1_2,[16]); | ||
350 | DO_TABLE2(mpeg3_pow2_2,[16]); | ||
351 | |||
352 | mpeg3_COS6_1 = cos( M_PI / 6.0 * (double) 1); | ||
353 | mpeg3_COS6_2 = cos( M_PI / 6.0 * (double) 2); | ||
354 | |||
355 | for(j = 0; j < 9; j++) | ||
356 | { | ||
357 | struct mpeg3_bandInfoStruct *bi = &mpeg3_bandInfo[j]; | ||
358 | int *mp; | ||
359 | int cb,lwin; | ||
360 | int *bdf; | ||
361 | |||
362 | mp = mpeg3_map[j][0] = mpeg3_mapbuf0[j]; | ||
363 | bdf = bi->longDiff; | ||
364 | for(i = 0, cb = 0; cb < 8; cb++, i += *bdf++) | ||
365 | { | ||
366 | *mp++ = (*bdf) >> 1; | ||
367 | *mp++ = i; | ||
368 | *mp++ = 3; | ||
369 | *mp++ = cb; | ||
370 | } | ||
371 | bdf = bi->shortDiff + 3; | ||
372 | for(cb = 3; cb < 13; cb++) | ||
373 | { | ||
374 | int l = (*bdf++) >> 1; | ||
375 | for(lwin = 0; lwin < 3; lwin++) | ||
376 | { | ||
377 | *mp++ = l; | ||
378 | *mp++ = i + lwin; | ||
379 | *mp++ = lwin; | ||
380 | *mp++ = cb; | ||
381 | } | ||
382 | i += 6 * l; | ||
383 | } | ||
384 | mpeg3_mapend[j][0] = mp; | ||
385 | |||
386 | mp = mpeg3_map[j][1] = mpeg3_mapbuf1[j]; | ||
387 | bdf = bi->shortDiff+0; | ||
388 | for(i = 0,cb = 0; cb < 13; cb++) | ||
389 | { | ||
390 | int l = (*bdf++) >> 1; | ||
391 | for(lwin = 0; lwin < 3; lwin++) | ||
392 | { | ||
393 | *mp++ = l; | ||
394 | *mp++ = i + lwin; | ||
395 | *mp++ = lwin; | ||
396 | *mp++ = cb; | ||
397 | } | ||
398 | i += 6 * l; | ||
399 | } | ||
400 | mpeg3_mapend[j][1] = mp; | ||
401 | |||
402 | mp = mpeg3_map[j][2] = mpeg3_mapbuf2[j]; | ||
403 | bdf = bi->longDiff; | ||
404 | for(cb = 0; cb < 22 ; cb++) | ||
405 | { | ||
406 | *mp++ = (*bdf++) >> 1; | ||
407 | *mp++ = cb; | ||
408 | } | ||
409 | mpeg3_mapend[j][2] = mp; | ||
410 | } | ||
411 | |||
412 | for(j = 0; j < 9; j++) | ||
413 | { | ||
414 | for(i = 0; i < 23; i++) | ||
415 | { | ||
416 | mpeg3_longLimit[j][i] = (mpeg3_bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1; | ||
417 | if(mpeg3_longLimit[j][i] > (down_sample_sblimit)) | ||
418 | mpeg3_longLimit[j][i] = down_sample_sblimit; | ||
419 | } | ||
420 | for(i = 0; i < 14; i++) | ||
421 | { | ||
422 | mpeg3_shortLimit[j][i] = (mpeg3_bandInfo[j].shortIdx[i] - 1) / 18 + 1; | ||
423 | if(mpeg3_shortLimit[j][i] > (down_sample_sblimit) ) | ||
424 | mpeg3_shortLimit[j][i] = down_sample_sblimit; | ||
425 | } | ||
426 | } | ||
427 | |||
428 | for(i = 0; i < 5; i++) | ||
429 | { | ||
430 | for(j = 0; j < 6; j++) | ||
431 | { | ||
432 | for(k = 0; k < 6; k++) | ||
433 | { | ||
434 | int n = k + j * 6 + i * 36; | ||
435 | mpeg3_i_slen2[n] = i | (j << 3) | (k << 6) | (3 << 12); | ||
436 | } | ||
437 | } | ||
438 | } | ||
439 | for(i = 0; i < 4; i++) | ||
440 | { | ||
441 | for(j = 0; j < 4; j++) | ||
442 | { | ||
443 | for(k = 0; k < 4; k++) | ||
444 | { | ||
445 | int n = k + j * 4 + i * 16; | ||
446 | mpeg3_i_slen2[n+180] = i | (j << 3) | (k << 6) | (4 << 12); | ||
447 | } | ||
448 | } | ||
449 | } | ||
450 | for(i = 0; i < 4; i++) | ||
451 | { | ||
452 | for(j = 0; j < 3; j++) | ||
453 | { | ||
454 | int n = j + i * 3; | ||
455 | mpeg3_i_slen2[n + 244] = i | (j << 3) | (5 << 12); | ||
456 | mpeg3_n_slen2[n + 500] = i | (j << 3) | (2 << 12) | (1 << 15); | ||
457 | } | ||
458 | } | ||
459 | |||
460 | for(i = 0; i < 5; i++) | ||
461 | { | ||
462 | for(j = 0; j < 5; j++) | ||
463 | { | ||
464 | for(k = 0; k < 4; k++) | ||
465 | { | ||
466 | for(l = 0; l < 4; l++) | ||
467 | { | ||
468 | int n = l + k * 4 + j * 16 + i * 80; | ||
469 | mpeg3_n_slen2[n] = i | (j << 3) | ( k << 6) | (l << 9) | (0 << 12); | ||
470 | } | ||
471 | } | ||
472 | } | ||
473 | } | ||
474 | for(i = 0; i < 5; i++) | ||
475 | { | ||
476 | for(j = 0; j < 5; j++) | ||
477 | { | ||
478 | for(k = 0; k < 4; k++) | ||
479 | { | ||
480 | int n = k + j * 4 + i * 20; | ||
481 | mpeg3_n_slen2[n + 400] = i | (j << 3) | (k << 6) | (1 << 12); | ||
482 | } | ||
483 | } | ||
484 | } | ||
485 | |||
486 | return 0; | ||
487 | } | ||
488 | |||
489 | int mpeg3audio_new_decode_tables(mpeg3audio_t *audio) | ||
490 | { | ||
491 | int i, j, k, kr, divv; | ||
492 | mpeg3_real_t *costab; | ||
493 | int idx; | ||
494 | long scaleval = audio->outscale; | ||
495 | |||
496 | |||
497 | for(i = 0; i < 5; i++) | ||
498 | { | ||
499 | kr = 0x10 >> i; | ||
500 | divv = 0x40 >> i; | ||
501 | costab = mpeg3_pnts[i]; | ||
502 | for(k = 0; k < kr; k++) | ||
503 | costab[k] = 1.0 / (2.0 * cos(M_PI * ((double)k * 2.0 + 1.0) / (double)divv)); | ||
504 | |||
505 | #ifdef USE_3DNOW | ||
506 | for(k = 0; k < kr; k++) | ||
507 | costab[k + kr] = -costab[k]; | ||
508 | #endif | ||
509 | |||
510 | } | ||
511 | |||
512 | idx = 0; | ||
513 | scaleval = -scaleval; | ||
514 | for(i = 0, j = 0; i < 256; i++, j++,idx += 32) | ||
515 | { | ||
516 | if(idx < 512 + 16) | ||
517 | mpeg3_decwin[idx+16] = mpeg3_decwin[idx] = (double)mpeg3_intwinbase[j] / 65536.0 * (double)scaleval; | ||
518 | |||
519 | if(i % 32 == 31) | ||
520 | idx -= 1023; | ||
521 | if(i % 64 == 63) | ||
522 | scaleval = -scaleval; | ||
523 | } | ||
524 | |||
525 | for( ; i < 512; i++, j--, idx += 32) | ||
526 | { | ||
527 | if(idx < 512 + 16) | ||
528 | mpeg3_decwin[idx + 16] = mpeg3_decwin[idx] = (double)mpeg3_intwinbase[j] / 65536.0 * (double)scaleval; | ||
529 | |||
530 | if(i % 32 == 31) | ||
531 | idx -= 1023; | ||
532 | if(i % 64 == 63) | ||
533 | scaleval = -scaleval; | ||
534 | } | ||
535 | |||
536 | #ifdef USE_3DNOW | ||
537 | if(!param.down_sample) | ||
538 | { | ||
539 | for(i = 0; i < 512 + 32; i++) | ||
540 | { | ||
541 | mpeg3_decwin[512 + 31 - i] *= 65536.0; /* allows faster clipping in 3dnow code */ | ||
542 | mpeg3_decwin[512 + 32 + i] = mpeg3_decwin[512 + 31 - i]; | ||
543 | } | ||
544 | } | ||
545 | #endif | ||
546 | |||
547 | /* Initialize AC3 */ | ||
548 | audio->ac3_lfsr_state = 1; | ||
549 | mpeg3audio_imdct_init(audio); | ||
550 | /* Initialize MPEG */ | ||
551 | mpeg3audio_init_layer2(audio); /* inits also shared tables with layer1 */ | ||
552 | mpeg3audio_init_layer3(audio); | ||
553 | return 0; | ||
554 | } | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/tables.h b/core/multimedia/opieplayer/libmpeg3/audio/tables.h new file mode 100644 index 0000000..7b14de1 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/tables.h | |||
@@ -0,0 +1,88 @@ | |||
1 | /********************************************************************** | ||
2 | ** Copyright (C) 2000 Trolltech AS. All rights reserved. | ||
3 | ** | ||
4 | ** This file is part of Qtopia Environment. | ||
5 | ** | ||
6 | ** This file may be distributed and/or modified under the terms of the | ||
7 | ** GNU General Public License version 2 as published by the Free Software | ||
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | ||
9 | ** packaging of this file. | ||
10 | ** | ||
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | ||
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | ||
13 | ** | ||
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | ||
15 | ** | ||
16 | ** Contact info@trolltech.com if any conditions of this licensing are | ||
17 | ** not clear to you. | ||
18 | ** | ||
19 | **********************************************************************/ | ||
20 | #ifndef TABLES_H | ||
21 | #define TABLES_H | ||
22 | |||
23 | extern int mpeg3_tabsel_123[2][3][16]; | ||
24 | |||
25 | extern long mpeg3_freqs[9]; | ||
26 | |||
27 | struct mpeg3_bandInfoStruct | ||
28 | { | ||
29 | int longIdx[23]; | ||
30 | int longDiff[22]; | ||
31 | int shortIdx[14]; | ||
32 | int shortDiff[13]; | ||
33 | }; | ||
34 | |||
35 | |||
36 | extern mpeg3_real_t mpeg3_decwin[512 + 32]; | ||
37 | extern mpeg3_real_t mpeg3_cos64[16], mpeg3_cos32[8], mpeg3_cos16[4], mpeg3_cos8[2], mpeg3_cos4[1]; | ||
38 | |||
39 | extern mpeg3_real_t *mpeg3_pnts[5]; | ||
40 | |||
41 | extern int mpeg3_grp_3tab[32 * 3]; /* used: 27 */ | ||
42 | extern int mpeg3_grp_5tab[128 * 3]; /* used: 125 */ | ||
43 | extern int mpeg3_grp_9tab[1024 * 3]; /* used: 729 */ | ||
44 | extern long mpeg3_intwinbase[257]; | ||
45 | extern mpeg3_real_t mpeg3_COS6_1, mpeg3_COS6_2; | ||
46 | |||
47 | #if defined(USE_FIXED_POINT) && !defined(PRINT_FIXED_POINT_TABLES) | ||
48 | # define REAL_MATRIX(var,dim1,dimn) mpeg3_real_t (*var)dimn | ||
49 | #else | ||
50 | # define REAL_MATRIX(var,dim1,dimn) mpeg3_real_t var dim1 dimn | ||
51 | #endif | ||
52 | extern REAL_MATRIX(mpeg3_muls, [27], [64]);/* also used by layer 1 */ | ||
53 | extern REAL_MATRIX(mpeg3_gainpow2, [256 + 118 + 4], ); | ||
54 | extern REAL_MATRIX(mpeg3_ispow, [8207], ); | ||
55 | extern REAL_MATRIX(mpeg3_aa_ca, [8], ); | ||
56 | extern REAL_MATRIX(mpeg3_aa_cs, [8], ); | ||
57 | extern REAL_MATRIX(mpeg3_win, [4], [36]); | ||
58 | extern REAL_MATRIX(mpeg3_win1, [4], [36]); | ||
59 | extern REAL_MATRIX(mpeg3_COS1, [12], [6]); | ||
60 | extern REAL_MATRIX(mpeg3_COS9, [9], ); | ||
61 | extern REAL_MATRIX(mpeg3_tfcos36, [9], ); | ||
62 | extern REAL_MATRIX(mpeg3_tfcos12, [3], ); | ||
63 | extern REAL_MATRIX(mpeg3_cos9, [3], ); | ||
64 | extern REAL_MATRIX(mpeg3_cos18, [3], ); | ||
65 | extern REAL_MATRIX(mpeg3_tan1_1, [16], ); | ||
66 | extern REAL_MATRIX(mpeg3_tan2_1, [16], ); | ||
67 | extern REAL_MATRIX(mpeg3_tan1_2, [16], ); | ||
68 | extern REAL_MATRIX(mpeg3_tan2_2, [16], ); | ||
69 | extern REAL_MATRIX(mpeg3_pow1_1, [2], [16]); | ||
70 | extern REAL_MATRIX(mpeg3_pow2_1, [2], [16]); | ||
71 | extern REAL_MATRIX(mpeg3_pow1_2, [2], [16]); | ||
72 | extern REAL_MATRIX(mpeg3_pow2_2, [2], [16]); | ||
73 | |||
74 | extern int mpeg3_longLimit[9][23]; | ||
75 | extern int mpeg3_shortLimit[9][14]; | ||
76 | |||
77 | extern struct mpeg3_bandInfoStruct mpeg3_bandInfo[9]; | ||
78 | |||
79 | extern int mpeg3_mapbuf0[9][152]; | ||
80 | extern int mpeg3_mapbuf1[9][156]; | ||
81 | extern int mpeg3_mapbuf2[9][44]; | ||
82 | extern int *mpeg3_map[9][3]; | ||
83 | extern int *mpeg3_mapend[9][3]; | ||
84 | |||
85 | extern unsigned int mpeg3_n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */ | ||
86 | extern unsigned int mpeg3_i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */ | ||
87 | |||
88 | #endif | ||
diff --git a/core/multimedia/opieplayer/libmpeg3/audio/uncouple.c b/core/multimedia/opieplayer/libmpeg3/audio/uncouple.c new file mode 100644 index 0000000..d87a078 --- a/dev/null +++ b/core/multimedia/opieplayer/libmpeg3/audio/uncouple.c | |||
@@ -0,0 +1,135 @@ | |||
1 | /* | ||
2 | * | ||
3 | *uncouple.c Copyright (C) Aaron Holtzman - May 1999 | ||
4 | * | ||
5 | * This file is part of libmpeg3 | ||
6 | * | ||
7 | * libmpeg3 is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2, or (at your option) | ||
10 | * any later version. | ||
11 | * | ||
12 | * libmpeg3 is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with GNU Make; see the file COPYING. If not, write to | ||
19 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | ||
20 | * | ||
21 | */ | ||
22 | |||
23 | #include "../bitstream.h" | ||
24 | #include "mpeg3audio.h" | ||
25 | |||
26 | static unsigned char mpeg3_first_bit_lut[256] = | ||
27 | { | ||
28 | 0, 8, 7, 7, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, | ||
29 | 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, | ||
30 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | ||
31 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | ||
32 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | ||
33 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | ||
34 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | ||
35 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | ||
36 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
37 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
38 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
39 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
40 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
41 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
42 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | ||
43 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 | ||
44 | }; | ||
45 | |||
46 | /* Converts an unsigned exponent in the range of 0-24 and a 16 bit mantissa | ||
47 | * to an IEEE single precision floating point value */ | ||
48 | static inline void mpeg3audio_ac3_convert_to_float(unsigned short exp, | ||
49 | unsigned short mantissa, | ||
50 | unsigned MPEG3_INT32 *dest) | ||
51 | { | ||
52 | int num; | ||
53 | short exponent; | ||
54 | int i; | ||
55 | |||
56 | /* If the mantissa is zero we can simply return zero */ | ||
57 | if(mantissa == 0) | ||
58 | { | ||
59 | *dest = 0; | ||
60 | return; | ||
61 | } | ||
62 | |||
63 | /* Exponent is offset by 127 in IEEE format minus the shift to | ||
64 | * align the mantissa to 1.f (subtracted in the final result) */ | ||
65 | exponent = 127 - exp; | ||
66 | |||
67 | /* Take care of the one asymmetric negative number */ | ||
68 | if(mantissa == 0x8000) | ||
69 | mantissa++; | ||
70 | |||
71 | /* Extract the sign bit, invert the mantissa if it's negative, and | ||
72 | shift out the sign bit */ | ||
73 | if(mantissa & 0x8000) | ||
74 | { | ||
75 | mantissa *= -1; | ||
76 | num = 0x80000000 + (exponent << 23); | ||
77 | } | ||
78 | else | ||
79 | { | ||
80 | mantissa *= 1; | ||
81 | num = exponent << 23; | ||
82 | } | ||
83 | |||
84 | /* Find the index of the most significant one bit */ | ||
85 | i = mpeg3_first_bit_lut[mantissa >> 8]; | ||
86 | |||
87 | if(i == 0) | ||
88 | i = mpeg3_first_bit_lut[mantissa & 0xff] + 8; | ||
89 | |||
90 | *dest = num - (i << 23) + (mantissa << (7 + i)); | ||
91 | return; | ||
92 | } | ||
93 | |||
94 | |||
95 | int mpeg3audio_ac3_uncouple(mpeg3audio_t *audio, | ||
96 | mpeg3_ac3bsi_t *bsi, | ||
97 | mpeg3_ac3audblk_t *audblk, | ||
98 | mpeg3_stream_coeffs_t *coeffs) | ||
99 | { | ||
100 | int i, j; | ||
101 | |||
102 | for(i = 0; i < bsi->nfchans; i++) | ||
103 | { | ||
104 | for(j = 0; j < audblk->endmant[i]; j++) | ||
105 | mpeg3audio_ac3_convert_to_float(audblk->fbw_exp[i][j], | ||
106 | audblk->chmant[i][j], | ||
107 | (unsigned MPEG3_INT32*)&coeffs->fbw[i][j]); | ||
108 | } | ||
109 | |||
110 | if(audblk->cplinu) | ||
111 | { | ||
112 | for(i = 0; i < bsi->nfchans; i++) | ||
113 | { | ||
114 | if(audblk->chincpl[i]) | ||
115 | { | ||
116 | mpeg3audio_ac3_uncouple_channel(audio, | ||
117 | coeffs, | ||
118 | audblk, | ||
119 | i); | ||
120 | } | ||
121 | } | ||
122 | |||
123 | } | ||
124 | |||
125 | if(bsi->lfeon) | ||
126 | { | ||
127 | /* There are always 7 mantissas for lfe */ | ||
128 | for(j = 0; j < 7 ; j++) | ||
129 | mpeg3audio_ac3_convert_to_float(audblk->lfe_exp[j], | ||
130 | audblk->lfemant[j], | ||
131 | (unsigned MPEG3_INT32*)&coeffs->lfe[j]); | ||
132 | |||
133 | } | ||
134 | return 0; | ||
135 | } | ||