streo mp3 player see: http://mbed.org/users/okini3939/notebook/I2S_AUDIO
Dependencies: FatFileSystemCpp I2SSlave TLV320 mbed
Fork of madplayer by
layer12.cpp@0:7627c79db971, 2010-11-26 (annotated)
- Committer:
- Gruenfrosch
- Date:
- Fri Nov 26 12:18:30 2010 +0000
- Revision:
- 0:7627c79db971
- Child:
- 1:7c923cbe9f1d
First Version
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
Gruenfrosch | 0:7627c79db971 | 1 | /* |
Gruenfrosch | 0:7627c79db971 | 2 | * libmad - MPEG audio decoder library |
Gruenfrosch | 0:7627c79db971 | 3 | * Copyright (C) 2000-2004 Underbit Technologies, Inc. |
Gruenfrosch | 0:7627c79db971 | 4 | * |
Gruenfrosch | 0:7627c79db971 | 5 | * This program is free software; you can redistribute it and/or modify |
Gruenfrosch | 0:7627c79db971 | 6 | * it under the terms of the GNU General Public License as published by |
Gruenfrosch | 0:7627c79db971 | 7 | * the Free Software Foundation; either version 2 of the License, or |
Gruenfrosch | 0:7627c79db971 | 8 | * (at your option) any later version. |
Gruenfrosch | 0:7627c79db971 | 9 | * |
Gruenfrosch | 0:7627c79db971 | 10 | * This program is distributed in the hope that it will be useful, |
Gruenfrosch | 0:7627c79db971 | 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
Gruenfrosch | 0:7627c79db971 | 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
Gruenfrosch | 0:7627c79db971 | 13 | * GNU General Public License for more details. |
Gruenfrosch | 0:7627c79db971 | 14 | * |
Gruenfrosch | 0:7627c79db971 | 15 | * You should have received a copy of the GNU General Public License |
Gruenfrosch | 0:7627c79db971 | 16 | * along with this program; if not, write to the Free Software |
Gruenfrosch | 0:7627c79db971 | 17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Gruenfrosch | 0:7627c79db971 | 18 | * |
Gruenfrosch | 0:7627c79db971 | 19 | * $Id: layer12.c,v 1.1 2010/11/23 20:12:57 andy Exp $ |
Gruenfrosch | 0:7627c79db971 | 20 | */ |
Gruenfrosch | 0:7627c79db971 | 21 | |
Gruenfrosch | 0:7627c79db971 | 22 | # include "config.h" |
Gruenfrosch | 0:7627c79db971 | 23 | |
Gruenfrosch | 0:7627c79db971 | 24 | # include "global.h" |
Gruenfrosch | 0:7627c79db971 | 25 | |
Gruenfrosch | 0:7627c79db971 | 26 | # ifdef HAVE_LIMITS_H |
Gruenfrosch | 0:7627c79db971 | 27 | # include <limits.h> |
Gruenfrosch | 0:7627c79db971 | 28 | # else |
Gruenfrosch | 0:7627c79db971 | 29 | # define CHAR_BIT 8 |
Gruenfrosch | 0:7627c79db971 | 30 | # endif |
Gruenfrosch | 0:7627c79db971 | 31 | |
Gruenfrosch | 0:7627c79db971 | 32 | # include "fixed.h" |
Gruenfrosch | 0:7627c79db971 | 33 | # include "bit.h" |
Gruenfrosch | 0:7627c79db971 | 34 | # include "stream.h" |
Gruenfrosch | 0:7627c79db971 | 35 | # include "frame.h" |
Gruenfrosch | 0:7627c79db971 | 36 | # include "layer12.h" |
Gruenfrosch | 0:7627c79db971 | 37 | |
Gruenfrosch | 0:7627c79db971 | 38 | /* |
Gruenfrosch | 0:7627c79db971 | 39 | * scalefactor table |
Gruenfrosch | 0:7627c79db971 | 40 | * used in both Layer I and Layer II decoding |
Gruenfrosch | 0:7627c79db971 | 41 | */ |
Gruenfrosch | 0:7627c79db971 | 42 | # include "sf_table.h" |
Gruenfrosch | 0:7627c79db971 | 43 | |
Gruenfrosch | 0:7627c79db971 | 44 | /* --- Layer I ------------------------------------------------------------- */ |
Gruenfrosch | 0:7627c79db971 | 45 | |
Gruenfrosch | 0:7627c79db971 | 46 | /* linear scaling table */ |
Gruenfrosch | 0:7627c79db971 | 47 | static |
Gruenfrosch | 0:7627c79db971 | 48 | mad_fixed_t const linear_table[14] = { |
Gruenfrosch | 0:7627c79db971 | 49 | MAD_F(0x15555555), /* 2^2 / (2^2 - 1) == 1.33333333333333 */ |
Gruenfrosch | 0:7627c79db971 | 50 | MAD_F(0x12492492), /* 2^3 / (2^3 - 1) == 1.14285714285714 */ |
Gruenfrosch | 0:7627c79db971 | 51 | MAD_F(0x11111111), /* 2^4 / (2^4 - 1) == 1.06666666666667 */ |
Gruenfrosch | 0:7627c79db971 | 52 | MAD_F(0x10842108), /* 2^5 / (2^5 - 1) == 1.03225806451613 */ |
Gruenfrosch | 0:7627c79db971 | 53 | MAD_F(0x10410410), /* 2^6 / (2^6 - 1) == 1.01587301587302 */ |
Gruenfrosch | 0:7627c79db971 | 54 | MAD_F(0x10204081), /* 2^7 / (2^7 - 1) == 1.00787401574803 */ |
Gruenfrosch | 0:7627c79db971 | 55 | MAD_F(0x10101010), /* 2^8 / (2^8 - 1) == 1.00392156862745 */ |
Gruenfrosch | 0:7627c79db971 | 56 | MAD_F(0x10080402), /* 2^9 / (2^9 - 1) == 1.00195694716243 */ |
Gruenfrosch | 0:7627c79db971 | 57 | MAD_F(0x10040100), /* 2^10 / (2^10 - 1) == 1.00097751710655 */ |
Gruenfrosch | 0:7627c79db971 | 58 | MAD_F(0x10020040), /* 2^11 / (2^11 - 1) == 1.00048851978505 */ |
Gruenfrosch | 0:7627c79db971 | 59 | MAD_F(0x10010010), /* 2^12 / (2^12 - 1) == 1.00024420024420 */ |
Gruenfrosch | 0:7627c79db971 | 60 | MAD_F(0x10008004), /* 2^13 / (2^13 - 1) == 1.00012208521548 */ |
Gruenfrosch | 0:7627c79db971 | 61 | MAD_F(0x10004001), /* 2^14 / (2^14 - 1) == 1.00006103888177 */ |
Gruenfrosch | 0:7627c79db971 | 62 | MAD_F(0x10002000) /* 2^15 / (2^15 - 1) == 1.00003051850948 */ |
Gruenfrosch | 0:7627c79db971 | 63 | }; |
Gruenfrosch | 0:7627c79db971 | 64 | |
Gruenfrosch | 0:7627c79db971 | 65 | /* |
Gruenfrosch | 0:7627c79db971 | 66 | * NAME: I_sample() |
Gruenfrosch | 0:7627c79db971 | 67 | * DESCRIPTION: decode one requantized Layer I sample from a bitstream |
Gruenfrosch | 0:7627c79db971 | 68 | */ |
Gruenfrosch | 0:7627c79db971 | 69 | static |
Gruenfrosch | 0:7627c79db971 | 70 | mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb) |
Gruenfrosch | 0:7627c79db971 | 71 | { |
Gruenfrosch | 0:7627c79db971 | 72 | mad_fixed_t sample; |
Gruenfrosch | 0:7627c79db971 | 73 | |
Gruenfrosch | 0:7627c79db971 | 74 | sample = mad_bit_read(ptr, nb); |
Gruenfrosch | 0:7627c79db971 | 75 | |
Gruenfrosch | 0:7627c79db971 | 76 | /* invert most significant bit, extend sign, then scale to fixed format */ |
Gruenfrosch | 0:7627c79db971 | 77 | |
Gruenfrosch | 0:7627c79db971 | 78 | sample ^= 1 << (nb - 1); |
Gruenfrosch | 0:7627c79db971 | 79 | sample |= -(sample & (1 << (nb - 1))); |
Gruenfrosch | 0:7627c79db971 | 80 | |
Gruenfrosch | 0:7627c79db971 | 81 | sample <<= MAD_F_FRACBITS - (nb - 1); |
Gruenfrosch | 0:7627c79db971 | 82 | |
Gruenfrosch | 0:7627c79db971 | 83 | /* requantize the sample */ |
Gruenfrosch | 0:7627c79db971 | 84 | |
Gruenfrosch | 0:7627c79db971 | 85 | /* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */ |
Gruenfrosch | 0:7627c79db971 | 86 | |
Gruenfrosch | 0:7627c79db971 | 87 | sample += MAD_F_ONE >> (nb - 1); |
Gruenfrosch | 0:7627c79db971 | 88 | |
Gruenfrosch | 0:7627c79db971 | 89 | return mad_f_mul(sample, linear_table[nb - 2]); |
Gruenfrosch | 0:7627c79db971 | 90 | |
Gruenfrosch | 0:7627c79db971 | 91 | /* s' = factor * s'' */ |
Gruenfrosch | 0:7627c79db971 | 92 | /* (to be performed by caller) */ |
Gruenfrosch | 0:7627c79db971 | 93 | } |
Gruenfrosch | 0:7627c79db971 | 94 | |
Gruenfrosch | 0:7627c79db971 | 95 | /* |
Gruenfrosch | 0:7627c79db971 | 96 | * NAME: layer->I() |
Gruenfrosch | 0:7627c79db971 | 97 | * DESCRIPTION: decode a single Layer I frame |
Gruenfrosch | 0:7627c79db971 | 98 | */ |
Gruenfrosch | 0:7627c79db971 | 99 | int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame) |
Gruenfrosch | 0:7627c79db971 | 100 | { |
Gruenfrosch | 0:7627c79db971 | 101 | struct mad_header *header = &frame->header; |
Gruenfrosch | 0:7627c79db971 | 102 | unsigned int nch, bound, ch, s, sb, nb; |
Gruenfrosch | 0:7627c79db971 | 103 | unsigned char allocation[2][32], scalefactor[2][32]; |
Gruenfrosch | 0:7627c79db971 | 104 | |
Gruenfrosch | 0:7627c79db971 | 105 | nch = MAD_NCHANNELS(header); |
Gruenfrosch | 0:7627c79db971 | 106 | |
Gruenfrosch | 0:7627c79db971 | 107 | bound = 32; |
Gruenfrosch | 0:7627c79db971 | 108 | if (header->mode == MAD_MODE_JOINT_STEREO) { |
Gruenfrosch | 0:7627c79db971 | 109 | header->flags |= MAD_FLAG_I_STEREO; |
Gruenfrosch | 0:7627c79db971 | 110 | bound = 4 + header->mode_extension * 4; |
Gruenfrosch | 0:7627c79db971 | 111 | } |
Gruenfrosch | 0:7627c79db971 | 112 | |
Gruenfrosch | 0:7627c79db971 | 113 | /* check CRC word */ |
Gruenfrosch | 0:7627c79db971 | 114 | |
Gruenfrosch | 0:7627c79db971 | 115 | if (header->flags & MAD_FLAG_PROTECTION) { |
Gruenfrosch | 0:7627c79db971 | 116 | header->crc_check = |
Gruenfrosch | 0:7627c79db971 | 117 | mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)), |
Gruenfrosch | 0:7627c79db971 | 118 | header->crc_check); |
Gruenfrosch | 0:7627c79db971 | 119 | |
Gruenfrosch | 0:7627c79db971 | 120 | if (header->crc_check != header->crc_target && |
Gruenfrosch | 0:7627c79db971 | 121 | !(frame->options & MAD_OPTION_IGNORECRC)) { |
Gruenfrosch | 0:7627c79db971 | 122 | stream->error = MAD_ERROR_BADCRC; |
Gruenfrosch | 0:7627c79db971 | 123 | return -1; |
Gruenfrosch | 0:7627c79db971 | 124 | } |
Gruenfrosch | 0:7627c79db971 | 125 | } |
Gruenfrosch | 0:7627c79db971 | 126 | |
Gruenfrosch | 0:7627c79db971 | 127 | /* decode bit allocations */ |
Gruenfrosch | 0:7627c79db971 | 128 | |
Gruenfrosch | 0:7627c79db971 | 129 | for (sb = 0; sb < bound; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 130 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 131 | nb = mad_bit_read(&stream->ptr, 4); |
Gruenfrosch | 0:7627c79db971 | 132 | |
Gruenfrosch | 0:7627c79db971 | 133 | if (nb == 15) { |
Gruenfrosch | 0:7627c79db971 | 134 | stream->error = MAD_ERROR_BADBITALLOC; |
Gruenfrosch | 0:7627c79db971 | 135 | return -1; |
Gruenfrosch | 0:7627c79db971 | 136 | } |
Gruenfrosch | 0:7627c79db971 | 137 | |
Gruenfrosch | 0:7627c79db971 | 138 | allocation[ch][sb] = nb ? nb + 1 : 0; |
Gruenfrosch | 0:7627c79db971 | 139 | } |
Gruenfrosch | 0:7627c79db971 | 140 | } |
Gruenfrosch | 0:7627c79db971 | 141 | |
Gruenfrosch | 0:7627c79db971 | 142 | for (sb = bound; sb < 32; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 143 | nb = mad_bit_read(&stream->ptr, 4); |
Gruenfrosch | 0:7627c79db971 | 144 | |
Gruenfrosch | 0:7627c79db971 | 145 | if (nb == 15) { |
Gruenfrosch | 0:7627c79db971 | 146 | stream->error = MAD_ERROR_BADBITALLOC; |
Gruenfrosch | 0:7627c79db971 | 147 | return -1; |
Gruenfrosch | 0:7627c79db971 | 148 | } |
Gruenfrosch | 0:7627c79db971 | 149 | |
Gruenfrosch | 0:7627c79db971 | 150 | allocation[0][sb] = |
Gruenfrosch | 0:7627c79db971 | 151 | allocation[1][sb] = nb ? nb + 1 : 0; |
Gruenfrosch | 0:7627c79db971 | 152 | } |
Gruenfrosch | 0:7627c79db971 | 153 | |
Gruenfrosch | 0:7627c79db971 | 154 | /* decode scalefactors */ |
Gruenfrosch | 0:7627c79db971 | 155 | |
Gruenfrosch | 0:7627c79db971 | 156 | for (sb = 0; sb < 32; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 157 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 158 | if (allocation[ch][sb]) { |
Gruenfrosch | 0:7627c79db971 | 159 | scalefactor[ch][sb] = mad_bit_read(&stream->ptr, 6); |
Gruenfrosch | 0:7627c79db971 | 160 | |
Gruenfrosch | 0:7627c79db971 | 161 | # if defined(OPT_STRICT) |
Gruenfrosch | 0:7627c79db971 | 162 | /* |
Gruenfrosch | 0:7627c79db971 | 163 | * Scalefactor index 63 does not appear in Table B.1 of |
Gruenfrosch | 0:7627c79db971 | 164 | * ISO/IEC 11172-3. Nonetheless, other implementations accept it, |
Gruenfrosch | 0:7627c79db971 | 165 | * so we only reject it if OPT_STRICT is defined. |
Gruenfrosch | 0:7627c79db971 | 166 | */ |
Gruenfrosch | 0:7627c79db971 | 167 | if (scalefactor[ch][sb] == 63) { |
Gruenfrosch | 0:7627c79db971 | 168 | stream->error = MAD_ERROR_BADSCALEFACTOR; |
Gruenfrosch | 0:7627c79db971 | 169 | return -1; |
Gruenfrosch | 0:7627c79db971 | 170 | } |
Gruenfrosch | 0:7627c79db971 | 171 | # endif |
Gruenfrosch | 0:7627c79db971 | 172 | } |
Gruenfrosch | 0:7627c79db971 | 173 | } |
Gruenfrosch | 0:7627c79db971 | 174 | } |
Gruenfrosch | 0:7627c79db971 | 175 | |
Gruenfrosch | 0:7627c79db971 | 176 | /* decode samples */ |
Gruenfrosch | 0:7627c79db971 | 177 | |
Gruenfrosch | 0:7627c79db971 | 178 | for (s = 0; s < 12; ++s) { |
Gruenfrosch | 0:7627c79db971 | 179 | for (sb = 0; sb < bound; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 180 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 181 | nb = allocation[ch][sb]; |
Gruenfrosch | 0:7627c79db971 | 182 | frame->sbsample[ch][s][sb] = nb ? |
Gruenfrosch | 0:7627c79db971 | 183 | mad_f_mul(I_sample(&stream->ptr, nb), |
Gruenfrosch | 0:7627c79db971 | 184 | sf_table[scalefactor[ch][sb]]) : 0; |
Gruenfrosch | 0:7627c79db971 | 185 | } |
Gruenfrosch | 0:7627c79db971 | 186 | } |
Gruenfrosch | 0:7627c79db971 | 187 | |
Gruenfrosch | 0:7627c79db971 | 188 | for (sb = bound; sb < 32; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 189 | if ((nb = allocation[0][sb]) != 0) { |
Gruenfrosch | 0:7627c79db971 | 190 | mad_fixed_t sample; |
Gruenfrosch | 0:7627c79db971 | 191 | |
Gruenfrosch | 0:7627c79db971 | 192 | sample = I_sample(&stream->ptr, nb); |
Gruenfrosch | 0:7627c79db971 | 193 | |
Gruenfrosch | 0:7627c79db971 | 194 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 195 | frame->sbsample[ch][s][sb] = |
Gruenfrosch | 0:7627c79db971 | 196 | mad_f_mul(sample, sf_table[scalefactor[ch][sb]]); |
Gruenfrosch | 0:7627c79db971 | 197 | } |
Gruenfrosch | 0:7627c79db971 | 198 | } |
Gruenfrosch | 0:7627c79db971 | 199 | else { |
Gruenfrosch | 0:7627c79db971 | 200 | for (ch = 0; ch < nch; ++ch) |
Gruenfrosch | 0:7627c79db971 | 201 | frame->sbsample[ch][s][sb] = 0; |
Gruenfrosch | 0:7627c79db971 | 202 | } |
Gruenfrosch | 0:7627c79db971 | 203 | } |
Gruenfrosch | 0:7627c79db971 | 204 | } |
Gruenfrosch | 0:7627c79db971 | 205 | |
Gruenfrosch | 0:7627c79db971 | 206 | return 0; |
Gruenfrosch | 0:7627c79db971 | 207 | } |
Gruenfrosch | 0:7627c79db971 | 208 | |
Gruenfrosch | 0:7627c79db971 | 209 | /* --- Layer II ------------------------------------------------------------ */ |
Gruenfrosch | 0:7627c79db971 | 210 | |
Gruenfrosch | 0:7627c79db971 | 211 | /* possible quantization per subband table */ |
Gruenfrosch | 0:7627c79db971 | 212 | static |
Gruenfrosch | 0:7627c79db971 | 213 | struct { |
Gruenfrosch | 0:7627c79db971 | 214 | unsigned int sblimit; |
Gruenfrosch | 0:7627c79db971 | 215 | unsigned char const offsets[30]; |
Gruenfrosch | 0:7627c79db971 | 216 | } const sbquant_table[5] = { |
Gruenfrosch | 0:7627c79db971 | 217 | /* ISO/IEC 11172-3 Table B.2a */ |
Gruenfrosch | 0:7627c79db971 | 218 | { 27, { 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3, /* 0 */ |
Gruenfrosch | 0:7627c79db971 | 219 | 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 } }, |
Gruenfrosch | 0:7627c79db971 | 220 | /* ISO/IEC 11172-3 Table B.2b */ |
Gruenfrosch | 0:7627c79db971 | 221 | { 30, { 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3, /* 1 */ |
Gruenfrosch | 0:7627c79db971 | 222 | 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0 } }, |
Gruenfrosch | 0:7627c79db971 | 223 | /* ISO/IEC 11172-3 Table B.2c */ |
Gruenfrosch | 0:7627c79db971 | 224 | { 8, { 5, 5, 2, 2, 2, 2, 2, 2 } }, /* 2 */ |
Gruenfrosch | 0:7627c79db971 | 225 | /* ISO/IEC 11172-3 Table B.2d */ |
Gruenfrosch | 0:7627c79db971 | 226 | { 12, { 5, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 } }, /* 3 */ |
Gruenfrosch | 0:7627c79db971 | 227 | /* ISO/IEC 13818-3 Table B.1 */ |
Gruenfrosch | 0:7627c79db971 | 228 | { 30, { 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, /* 4 */ |
Gruenfrosch | 0:7627c79db971 | 229 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } } |
Gruenfrosch | 0:7627c79db971 | 230 | }; |
Gruenfrosch | 0:7627c79db971 | 231 | |
Gruenfrosch | 0:7627c79db971 | 232 | /* bit allocation table */ |
Gruenfrosch | 0:7627c79db971 | 233 | static |
Gruenfrosch | 0:7627c79db971 | 234 | struct { |
Gruenfrosch | 0:7627c79db971 | 235 | unsigned short nbal; |
Gruenfrosch | 0:7627c79db971 | 236 | unsigned short offset; |
Gruenfrosch | 0:7627c79db971 | 237 | } const bitalloc_table[8] = { |
Gruenfrosch | 0:7627c79db971 | 238 | { 2, 0 }, /* 0 */ |
Gruenfrosch | 0:7627c79db971 | 239 | { 2, 3 }, /* 1 */ |
Gruenfrosch | 0:7627c79db971 | 240 | { 3, 3 }, /* 2 */ |
Gruenfrosch | 0:7627c79db971 | 241 | { 3, 1 }, /* 3 */ |
Gruenfrosch | 0:7627c79db971 | 242 | { 4, 2 }, /* 4 */ |
Gruenfrosch | 0:7627c79db971 | 243 | { 4, 3 }, /* 5 */ |
Gruenfrosch | 0:7627c79db971 | 244 | { 4, 4 }, /* 6 */ |
Gruenfrosch | 0:7627c79db971 | 245 | { 4, 5 } /* 7 */ |
Gruenfrosch | 0:7627c79db971 | 246 | }; |
Gruenfrosch | 0:7627c79db971 | 247 | |
Gruenfrosch | 0:7627c79db971 | 248 | /* offsets into quantization class table */ |
Gruenfrosch | 0:7627c79db971 | 249 | static |
Gruenfrosch | 0:7627c79db971 | 250 | unsigned char const offset_table[6][15] = { |
Gruenfrosch | 0:7627c79db971 | 251 | { 0, 1, 16 }, /* 0 */ |
Gruenfrosch | 0:7627c79db971 | 252 | { 0, 1, 2, 3, 4, 5, 16 }, /* 1 */ |
Gruenfrosch | 0:7627c79db971 | 253 | { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }, /* 2 */ |
Gruenfrosch | 0:7627c79db971 | 254 | { 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, /* 3 */ |
Gruenfrosch | 0:7627c79db971 | 255 | { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16 }, /* 4 */ |
Gruenfrosch | 0:7627c79db971 | 256 | { 0, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 } /* 5 */ |
Gruenfrosch | 0:7627c79db971 | 257 | }; |
Gruenfrosch | 0:7627c79db971 | 258 | |
Gruenfrosch | 0:7627c79db971 | 259 | /* quantization class table */ |
Gruenfrosch | 0:7627c79db971 | 260 | static |
Gruenfrosch | 0:7627c79db971 | 261 | struct quantclass { |
Gruenfrosch | 0:7627c79db971 | 262 | unsigned short nlevels; |
Gruenfrosch | 0:7627c79db971 | 263 | unsigned char group; |
Gruenfrosch | 0:7627c79db971 | 264 | unsigned char bits; |
Gruenfrosch | 0:7627c79db971 | 265 | mad_fixed_t C; |
Gruenfrosch | 0:7627c79db971 | 266 | mad_fixed_t D; |
Gruenfrosch | 0:7627c79db971 | 267 | } const qc_table[17] = { |
Gruenfrosch | 0:7627c79db971 | 268 | # include "qc_table.h" |
Gruenfrosch | 0:7627c79db971 | 269 | }; |
Gruenfrosch | 0:7627c79db971 | 270 | |
Gruenfrosch | 0:7627c79db971 | 271 | /* |
Gruenfrosch | 0:7627c79db971 | 272 | * NAME: II_samples() |
Gruenfrosch | 0:7627c79db971 | 273 | * DESCRIPTION: decode three requantized Layer II samples from a bitstream |
Gruenfrosch | 0:7627c79db971 | 274 | */ |
Gruenfrosch | 0:7627c79db971 | 275 | static |
Gruenfrosch | 0:7627c79db971 | 276 | void II_samples(struct mad_bitptr *ptr, |
Gruenfrosch | 0:7627c79db971 | 277 | struct quantclass const *quantclass, |
Gruenfrosch | 0:7627c79db971 | 278 | mad_fixed_t output[3]) |
Gruenfrosch | 0:7627c79db971 | 279 | { |
Gruenfrosch | 0:7627c79db971 | 280 | unsigned int nb, s, sample[3]; |
Gruenfrosch | 0:7627c79db971 | 281 | |
Gruenfrosch | 0:7627c79db971 | 282 | if ((nb = quantclass->group) != 0) { |
Gruenfrosch | 0:7627c79db971 | 283 | unsigned int c, nlevels; |
Gruenfrosch | 0:7627c79db971 | 284 | |
Gruenfrosch | 0:7627c79db971 | 285 | /* degrouping */ |
Gruenfrosch | 0:7627c79db971 | 286 | c = mad_bit_read(ptr, quantclass->bits); |
Gruenfrosch | 0:7627c79db971 | 287 | nlevels = quantclass->nlevels; |
Gruenfrosch | 0:7627c79db971 | 288 | |
Gruenfrosch | 0:7627c79db971 | 289 | for (s = 0; s < 3; ++s) { |
Gruenfrosch | 0:7627c79db971 | 290 | sample[s] = c % nlevels; |
Gruenfrosch | 0:7627c79db971 | 291 | c /= nlevels; |
Gruenfrosch | 0:7627c79db971 | 292 | } |
Gruenfrosch | 0:7627c79db971 | 293 | } |
Gruenfrosch | 0:7627c79db971 | 294 | else { |
Gruenfrosch | 0:7627c79db971 | 295 | nb = quantclass->bits; |
Gruenfrosch | 0:7627c79db971 | 296 | |
Gruenfrosch | 0:7627c79db971 | 297 | for (s = 0; s < 3; ++s) |
Gruenfrosch | 0:7627c79db971 | 298 | sample[s] = mad_bit_read(ptr, nb); |
Gruenfrosch | 0:7627c79db971 | 299 | } |
Gruenfrosch | 0:7627c79db971 | 300 | |
Gruenfrosch | 0:7627c79db971 | 301 | for (s = 0; s < 3; ++s) { |
Gruenfrosch | 0:7627c79db971 | 302 | mad_fixed_t requantized; |
Gruenfrosch | 0:7627c79db971 | 303 | |
Gruenfrosch | 0:7627c79db971 | 304 | /* invert most significant bit, extend sign, then scale to fixed format */ |
Gruenfrosch | 0:7627c79db971 | 305 | |
Gruenfrosch | 0:7627c79db971 | 306 | requantized = sample[s] ^ (1 << (nb - 1)); |
Gruenfrosch | 0:7627c79db971 | 307 | requantized |= -(requantized & (1 << (nb - 1))); |
Gruenfrosch | 0:7627c79db971 | 308 | |
Gruenfrosch | 0:7627c79db971 | 309 | requantized <<= MAD_F_FRACBITS - (nb - 1); |
Gruenfrosch | 0:7627c79db971 | 310 | |
Gruenfrosch | 0:7627c79db971 | 311 | /* requantize the sample */ |
Gruenfrosch | 0:7627c79db971 | 312 | |
Gruenfrosch | 0:7627c79db971 | 313 | /* s'' = C * (s''' + D) */ |
Gruenfrosch | 0:7627c79db971 | 314 | |
Gruenfrosch | 0:7627c79db971 | 315 | output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C); |
Gruenfrosch | 0:7627c79db971 | 316 | |
Gruenfrosch | 0:7627c79db971 | 317 | /* s' = factor * s'' */ |
Gruenfrosch | 0:7627c79db971 | 318 | /* (to be performed by caller) */ |
Gruenfrosch | 0:7627c79db971 | 319 | } |
Gruenfrosch | 0:7627c79db971 | 320 | } |
Gruenfrosch | 0:7627c79db971 | 321 | |
Gruenfrosch | 0:7627c79db971 | 322 | /* |
Gruenfrosch | 0:7627c79db971 | 323 | * NAME: layer->II() |
Gruenfrosch | 0:7627c79db971 | 324 | * DESCRIPTION: decode a single Layer II frame |
Gruenfrosch | 0:7627c79db971 | 325 | */ |
Gruenfrosch | 0:7627c79db971 | 326 | int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame) |
Gruenfrosch | 0:7627c79db971 | 327 | { |
Gruenfrosch | 0:7627c79db971 | 328 | struct mad_header *header = &frame->header; |
Gruenfrosch | 0:7627c79db971 | 329 | struct mad_bitptr start; |
Gruenfrosch | 0:7627c79db971 | 330 | unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb; |
Gruenfrosch | 0:7627c79db971 | 331 | unsigned char const *offsets; |
Gruenfrosch | 0:7627c79db971 | 332 | unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3]; |
Gruenfrosch | 0:7627c79db971 | 333 | mad_fixed_t samples[3]; |
Gruenfrosch | 0:7627c79db971 | 334 | |
Gruenfrosch | 0:7627c79db971 | 335 | nch = MAD_NCHANNELS(header); |
Gruenfrosch | 0:7627c79db971 | 336 | |
Gruenfrosch | 0:7627c79db971 | 337 | if (header->flags & MAD_FLAG_LSF_EXT) |
Gruenfrosch | 0:7627c79db971 | 338 | index = 4; |
Gruenfrosch | 0:7627c79db971 | 339 | else if (header->flags & MAD_FLAG_FREEFORMAT) |
Gruenfrosch | 0:7627c79db971 | 340 | goto freeformat; |
Gruenfrosch | 0:7627c79db971 | 341 | else { |
Gruenfrosch | 0:7627c79db971 | 342 | unsigned long bitrate_per_channel; |
Gruenfrosch | 0:7627c79db971 | 343 | |
Gruenfrosch | 0:7627c79db971 | 344 | bitrate_per_channel = header->bitrate; |
Gruenfrosch | 0:7627c79db971 | 345 | if (nch == 2) { |
Gruenfrosch | 0:7627c79db971 | 346 | bitrate_per_channel /= 2; |
Gruenfrosch | 0:7627c79db971 | 347 | |
Gruenfrosch | 0:7627c79db971 | 348 | # if defined(OPT_STRICT) |
Gruenfrosch | 0:7627c79db971 | 349 | /* |
Gruenfrosch | 0:7627c79db971 | 350 | * ISO/IEC 11172-3 allows only single channel mode for 32, 48, 56, and |
Gruenfrosch | 0:7627c79db971 | 351 | * 80 kbps bitrates in Layer II, but some encoders ignore this |
Gruenfrosch | 0:7627c79db971 | 352 | * restriction. We enforce it if OPT_STRICT is defined. |
Gruenfrosch | 0:7627c79db971 | 353 | */ |
Gruenfrosch | 0:7627c79db971 | 354 | if (bitrate_per_channel <= 28000 || bitrate_per_channel == 40000) { |
Gruenfrosch | 0:7627c79db971 | 355 | stream->error = MAD_ERROR_BADMODE; |
Gruenfrosch | 0:7627c79db971 | 356 | return -1; |
Gruenfrosch | 0:7627c79db971 | 357 | } |
Gruenfrosch | 0:7627c79db971 | 358 | # endif |
Gruenfrosch | 0:7627c79db971 | 359 | } |
Gruenfrosch | 0:7627c79db971 | 360 | else { /* nch == 1 */ |
Gruenfrosch | 0:7627c79db971 | 361 | if (bitrate_per_channel > 192000) { |
Gruenfrosch | 0:7627c79db971 | 362 | /* |
Gruenfrosch | 0:7627c79db971 | 363 | * ISO/IEC 11172-3 does not allow single channel mode for 224, 256, |
Gruenfrosch | 0:7627c79db971 | 364 | * 320, or 384 kbps bitrates in Layer II. |
Gruenfrosch | 0:7627c79db971 | 365 | */ |
Gruenfrosch | 0:7627c79db971 | 366 | stream->error = MAD_ERROR_BADMODE; |
Gruenfrosch | 0:7627c79db971 | 367 | return -1; |
Gruenfrosch | 0:7627c79db971 | 368 | } |
Gruenfrosch | 0:7627c79db971 | 369 | } |
Gruenfrosch | 0:7627c79db971 | 370 | |
Gruenfrosch | 0:7627c79db971 | 371 | if (bitrate_per_channel <= 48000) |
Gruenfrosch | 0:7627c79db971 | 372 | index = (header->samplerate == 32000) ? 3 : 2; |
Gruenfrosch | 0:7627c79db971 | 373 | else if (bitrate_per_channel <= 80000) |
Gruenfrosch | 0:7627c79db971 | 374 | index = 0; |
Gruenfrosch | 0:7627c79db971 | 375 | else { |
Gruenfrosch | 0:7627c79db971 | 376 | freeformat: |
Gruenfrosch | 0:7627c79db971 | 377 | index = (header->samplerate == 48000) ? 0 : 1; |
Gruenfrosch | 0:7627c79db971 | 378 | } |
Gruenfrosch | 0:7627c79db971 | 379 | } |
Gruenfrosch | 0:7627c79db971 | 380 | |
Gruenfrosch | 0:7627c79db971 | 381 | sblimit = sbquant_table[index].sblimit; |
Gruenfrosch | 0:7627c79db971 | 382 | offsets = sbquant_table[index].offsets; |
Gruenfrosch | 0:7627c79db971 | 383 | |
Gruenfrosch | 0:7627c79db971 | 384 | bound = 32; |
Gruenfrosch | 0:7627c79db971 | 385 | if (header->mode == MAD_MODE_JOINT_STEREO) { |
Gruenfrosch | 0:7627c79db971 | 386 | header->flags |= MAD_FLAG_I_STEREO; |
Gruenfrosch | 0:7627c79db971 | 387 | bound = 4 + header->mode_extension * 4; |
Gruenfrosch | 0:7627c79db971 | 388 | } |
Gruenfrosch | 0:7627c79db971 | 389 | |
Gruenfrosch | 0:7627c79db971 | 390 | if (bound > sblimit) |
Gruenfrosch | 0:7627c79db971 | 391 | bound = sblimit; |
Gruenfrosch | 0:7627c79db971 | 392 | |
Gruenfrosch | 0:7627c79db971 | 393 | start = stream->ptr; |
Gruenfrosch | 0:7627c79db971 | 394 | |
Gruenfrosch | 0:7627c79db971 | 395 | /* decode bit allocations */ |
Gruenfrosch | 0:7627c79db971 | 396 | |
Gruenfrosch | 0:7627c79db971 | 397 | for (sb = 0; sb < bound; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 398 | nbal = bitalloc_table[offsets[sb]].nbal; |
Gruenfrosch | 0:7627c79db971 | 399 | |
Gruenfrosch | 0:7627c79db971 | 400 | for (ch = 0; ch < nch; ++ch) |
Gruenfrosch | 0:7627c79db971 | 401 | allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal); |
Gruenfrosch | 0:7627c79db971 | 402 | } |
Gruenfrosch | 0:7627c79db971 | 403 | |
Gruenfrosch | 0:7627c79db971 | 404 | for (sb = bound; sb < sblimit; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 405 | nbal = bitalloc_table[offsets[sb]].nbal; |
Gruenfrosch | 0:7627c79db971 | 406 | |
Gruenfrosch | 0:7627c79db971 | 407 | allocation[0][sb] = |
Gruenfrosch | 0:7627c79db971 | 408 | allocation[1][sb] = mad_bit_read(&stream->ptr, nbal); |
Gruenfrosch | 0:7627c79db971 | 409 | } |
Gruenfrosch | 0:7627c79db971 | 410 | |
Gruenfrosch | 0:7627c79db971 | 411 | /* decode scalefactor selection info */ |
Gruenfrosch | 0:7627c79db971 | 412 | |
Gruenfrosch | 0:7627c79db971 | 413 | for (sb = 0; sb < sblimit; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 414 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 415 | if (allocation[ch][sb]) |
Gruenfrosch | 0:7627c79db971 | 416 | scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2); |
Gruenfrosch | 0:7627c79db971 | 417 | } |
Gruenfrosch | 0:7627c79db971 | 418 | } |
Gruenfrosch | 0:7627c79db971 | 419 | |
Gruenfrosch | 0:7627c79db971 | 420 | /* check CRC word */ |
Gruenfrosch | 0:7627c79db971 | 421 | |
Gruenfrosch | 0:7627c79db971 | 422 | if (header->flags & MAD_FLAG_PROTECTION) { |
Gruenfrosch | 0:7627c79db971 | 423 | header->crc_check = |
Gruenfrosch | 0:7627c79db971 | 424 | mad_bit_crc(start, mad_bit_length(&start, &stream->ptr), |
Gruenfrosch | 0:7627c79db971 | 425 | header->crc_check); |
Gruenfrosch | 0:7627c79db971 | 426 | |
Gruenfrosch | 0:7627c79db971 | 427 | if (header->crc_check != header->crc_target && |
Gruenfrosch | 0:7627c79db971 | 428 | !(frame->options & MAD_OPTION_IGNORECRC)) { |
Gruenfrosch | 0:7627c79db971 | 429 | stream->error = MAD_ERROR_BADCRC; |
Gruenfrosch | 0:7627c79db971 | 430 | return -1; |
Gruenfrosch | 0:7627c79db971 | 431 | } |
Gruenfrosch | 0:7627c79db971 | 432 | } |
Gruenfrosch | 0:7627c79db971 | 433 | |
Gruenfrosch | 0:7627c79db971 | 434 | /* decode scalefactors */ |
Gruenfrosch | 0:7627c79db971 | 435 | |
Gruenfrosch | 0:7627c79db971 | 436 | for (sb = 0; sb < sblimit; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 437 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 438 | if (allocation[ch][sb]) { |
Gruenfrosch | 0:7627c79db971 | 439 | scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6); |
Gruenfrosch | 0:7627c79db971 | 440 | |
Gruenfrosch | 0:7627c79db971 | 441 | switch (scfsi[ch][sb]) { |
Gruenfrosch | 0:7627c79db971 | 442 | case 2: |
Gruenfrosch | 0:7627c79db971 | 443 | scalefactor[ch][sb][2] = |
Gruenfrosch | 0:7627c79db971 | 444 | scalefactor[ch][sb][1] = |
Gruenfrosch | 0:7627c79db971 | 445 | scalefactor[ch][sb][0]; |
Gruenfrosch | 0:7627c79db971 | 446 | break; |
Gruenfrosch | 0:7627c79db971 | 447 | |
Gruenfrosch | 0:7627c79db971 | 448 | case 0: |
Gruenfrosch | 0:7627c79db971 | 449 | scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6); |
Gruenfrosch | 0:7627c79db971 | 450 | /* fall through */ |
Gruenfrosch | 0:7627c79db971 | 451 | |
Gruenfrosch | 0:7627c79db971 | 452 | case 1: |
Gruenfrosch | 0:7627c79db971 | 453 | case 3: |
Gruenfrosch | 0:7627c79db971 | 454 | scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6); |
Gruenfrosch | 0:7627c79db971 | 455 | } |
Gruenfrosch | 0:7627c79db971 | 456 | |
Gruenfrosch | 0:7627c79db971 | 457 | if (scfsi[ch][sb] & 1) |
Gruenfrosch | 0:7627c79db971 | 458 | scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1]; |
Gruenfrosch | 0:7627c79db971 | 459 | |
Gruenfrosch | 0:7627c79db971 | 460 | # if defined(OPT_STRICT) |
Gruenfrosch | 0:7627c79db971 | 461 | /* |
Gruenfrosch | 0:7627c79db971 | 462 | * Scalefactor index 63 does not appear in Table B.1 of |
Gruenfrosch | 0:7627c79db971 | 463 | * ISO/IEC 11172-3. Nonetheless, other implementations accept it, |
Gruenfrosch | 0:7627c79db971 | 464 | * so we only reject it if OPT_STRICT is defined. |
Gruenfrosch | 0:7627c79db971 | 465 | */ |
Gruenfrosch | 0:7627c79db971 | 466 | if (scalefactor[ch][sb][0] == 63 || |
Gruenfrosch | 0:7627c79db971 | 467 | scalefactor[ch][sb][1] == 63 || |
Gruenfrosch | 0:7627c79db971 | 468 | scalefactor[ch][sb][2] == 63) { |
Gruenfrosch | 0:7627c79db971 | 469 | stream->error = MAD_ERROR_BADSCALEFACTOR; |
Gruenfrosch | 0:7627c79db971 | 470 | return -1; |
Gruenfrosch | 0:7627c79db971 | 471 | } |
Gruenfrosch | 0:7627c79db971 | 472 | # endif |
Gruenfrosch | 0:7627c79db971 | 473 | } |
Gruenfrosch | 0:7627c79db971 | 474 | } |
Gruenfrosch | 0:7627c79db971 | 475 | } |
Gruenfrosch | 0:7627c79db971 | 476 | |
Gruenfrosch | 0:7627c79db971 | 477 | /* decode samples */ |
Gruenfrosch | 0:7627c79db971 | 478 | |
Gruenfrosch | 0:7627c79db971 | 479 | for (gr = 0; gr < 12; ++gr) { |
Gruenfrosch | 0:7627c79db971 | 480 | for (sb = 0; sb < bound; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 481 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 482 | if ((index = allocation[ch][sb]) != 0) { |
Gruenfrosch | 0:7627c79db971 | 483 | index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1]; |
Gruenfrosch | 0:7627c79db971 | 484 | |
Gruenfrosch | 0:7627c79db971 | 485 | II_samples(&stream->ptr, &qc_table[index], samples); |
Gruenfrosch | 0:7627c79db971 | 486 | |
Gruenfrosch | 0:7627c79db971 | 487 | for (s = 0; s < 3; ++s) { |
Gruenfrosch | 0:7627c79db971 | 488 | frame->sbsample[ch][3 * gr + s][sb] = |
Gruenfrosch | 0:7627c79db971 | 489 | mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]); |
Gruenfrosch | 0:7627c79db971 | 490 | } |
Gruenfrosch | 0:7627c79db971 | 491 | } |
Gruenfrosch | 0:7627c79db971 | 492 | else { |
Gruenfrosch | 0:7627c79db971 | 493 | for (s = 0; s < 3; ++s) |
Gruenfrosch | 0:7627c79db971 | 494 | frame->sbsample[ch][3 * gr + s][sb] = 0; |
Gruenfrosch | 0:7627c79db971 | 495 | } |
Gruenfrosch | 0:7627c79db971 | 496 | } |
Gruenfrosch | 0:7627c79db971 | 497 | } |
Gruenfrosch | 0:7627c79db971 | 498 | |
Gruenfrosch | 0:7627c79db971 | 499 | for (sb = bound; sb < sblimit; ++sb) { |
Gruenfrosch | 0:7627c79db971 | 500 | if ((index = allocation[0][sb])!= 0) { |
Gruenfrosch | 0:7627c79db971 | 501 | index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1]; |
Gruenfrosch | 0:7627c79db971 | 502 | |
Gruenfrosch | 0:7627c79db971 | 503 | II_samples(&stream->ptr, &qc_table[index], samples); |
Gruenfrosch | 0:7627c79db971 | 504 | |
Gruenfrosch | 0:7627c79db971 | 505 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 506 | for (s = 0; s < 3; ++s) { |
Gruenfrosch | 0:7627c79db971 | 507 | frame->sbsample[ch][3 * gr + s][sb] = |
Gruenfrosch | 0:7627c79db971 | 508 | mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]); |
Gruenfrosch | 0:7627c79db971 | 509 | } |
Gruenfrosch | 0:7627c79db971 | 510 | } |
Gruenfrosch | 0:7627c79db971 | 511 | } |
Gruenfrosch | 0:7627c79db971 | 512 | else { |
Gruenfrosch | 0:7627c79db971 | 513 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 514 | for (s = 0; s < 3; ++s) |
Gruenfrosch | 0:7627c79db971 | 515 | frame->sbsample[ch][3 * gr + s][sb] = 0; |
Gruenfrosch | 0:7627c79db971 | 516 | } |
Gruenfrosch | 0:7627c79db971 | 517 | } |
Gruenfrosch | 0:7627c79db971 | 518 | } |
Gruenfrosch | 0:7627c79db971 | 519 | |
Gruenfrosch | 0:7627c79db971 | 520 | for (ch = 0; ch < nch; ++ch) { |
Gruenfrosch | 0:7627c79db971 | 521 | for (s = 0; s < 3; ++s) { |
Gruenfrosch | 0:7627c79db971 | 522 | for (sb = sblimit; sb < 32; ++sb) |
Gruenfrosch | 0:7627c79db971 | 523 | frame->sbsample[ch][3 * gr + s][sb] = 0; |
Gruenfrosch | 0:7627c79db971 | 524 | } |
Gruenfrosch | 0:7627c79db971 | 525 | } |
Gruenfrosch | 0:7627c79db971 | 526 | } |
Gruenfrosch | 0:7627c79db971 | 527 | |
Gruenfrosch | 0:7627c79db971 | 528 | return 0; |
Gruenfrosch | 0:7627c79db971 | 529 | } |