Go to most recent revision | Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 165 | serge | 1 | #include "layer3.h" |
| 2 | #include "l3huff.h" |
||
| 3 | |||
| 4 | //#ifdef _MSC_VER |
||
| 5 | //#pragma warning(disable: 4505) |
||
| 6 | //#endif |
||
| 7 | |||
| 8 | /*===============================================================*/ |
||
| 9 | |||
| 10 | /* max bits required for any lookup - change if htable changes */ |
||
| 11 | /* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */ |
||
| 12 | #define MAXBITS 9 |
||
| 13 | |||
| 14 | static HUFF_ELEMENT huff_table_0[] = |
||
| 15 | {0, 0, 0, 64}; /* dummy must not use */ |
||
| 16 | |||
| 17 | /*-- 6 bit lookup (purgebits, value) --*/ |
||
| 18 | static unsigned char quad_table_a[][2] = |
||
| 19 | { |
||
| 20 | 6, 11, 6, 15, 6, 13, 6, 14, 6, 7, 6, 5, 5, 9, |
||
| 21 | 5, 9, 5, 6, 5, 6, 5, 3, 5, 3, 5, 10, 5, 10, |
||
| 22 | 5, 12, 5, 12, 4, 2, 4, 2, 4, 2, 4, 2, 4, 1, |
||
| 23 | 4, 1, 4, 1, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, |
||
| 24 | 4, 8, 4, 8, 4, 8, 4, 8, 1, 0, 1, 0, 1, 0, |
||
| 25 | 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, |
||
| 26 | 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, |
||
| 27 | 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, |
||
| 28 | 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, |
||
| 29 | 1, 0, |
||
| 30 | }; |
||
| 31 | |||
| 32 | |||
| 33 | typedef struct |
||
| 34 | { |
||
| 35 | HUFF_ELEMENT *table; |
||
| 36 | int linbits; |
||
| 37 | int ncase; |
||
| 38 | } |
||
| 39 | HUFF_SETUP; |
||
| 40 | |||
| 41 | #define no_bits 0 |
||
| 42 | #define one_shot 1 |
||
| 43 | #define no_linbits 2 |
||
| 44 | #define have_linbits 3 |
||
| 45 | #define quad_a 4 |
||
| 46 | #define quad_b 5 |
||
| 47 | |||
| 48 | |||
| 49 | static HUFF_SETUP table_look[] = |
||
| 50 | { |
||
| 51 | huff_table_0, 0, no_bits, |
||
| 52 | huff_table_1, 0, one_shot, |
||
| 53 | huff_table_2, 0, one_shot, |
||
| 54 | huff_table_3, 0, one_shot, |
||
| 55 | huff_table_0, 0, no_bits, |
||
| 56 | huff_table_5, 0, one_shot, |
||
| 57 | huff_table_6, 0, one_shot, |
||
| 58 | huff_table_7, 0, no_linbits, |
||
| 59 | huff_table_8, 0, no_linbits, |
||
| 60 | huff_table_9, 0, no_linbits, |
||
| 61 | huff_table_10, 0, no_linbits, |
||
| 62 | huff_table_11, 0, no_linbits, |
||
| 63 | huff_table_12, 0, no_linbits, |
||
| 64 | huff_table_13, 0, no_linbits, |
||
| 65 | huff_table_0, 0, no_bits, |
||
| 66 | huff_table_15, 0, no_linbits, |
||
| 67 | huff_table_16, 1, have_linbits, |
||
| 68 | huff_table_16, 2, have_linbits, |
||
| 69 | huff_table_16, 3, have_linbits, |
||
| 70 | huff_table_16, 4, have_linbits, |
||
| 71 | huff_table_16, 6, have_linbits, |
||
| 72 | huff_table_16, 8, have_linbits, |
||
| 73 | huff_table_16, 10, have_linbits, |
||
| 74 | huff_table_16, 13, have_linbits, |
||
| 75 | huff_table_24, 4, have_linbits, |
||
| 76 | huff_table_24, 5, have_linbits, |
||
| 77 | huff_table_24, 6, have_linbits, |
||
| 78 | huff_table_24, 7, have_linbits, |
||
| 79 | huff_table_24, 8, have_linbits, |
||
| 80 | huff_table_24, 9, have_linbits, |
||
| 81 | huff_table_24, 11, have_linbits, |
||
| 82 | huff_table_24, 13, have_linbits, |
||
| 83 | huff_table_0, 0, quad_a, |
||
| 84 | huff_table_0, 0, quad_b, |
||
| 85 | }; |
||
| 86 | |||
| 87 | /*========================================================*/ |
||
| 88 | void huffman(int xy[][2], int n, int ntable) |
||
| 89 | { |
||
| 90 | int i; |
||
| 91 | HUFF_ELEMENT *t; |
||
| 92 | HUFF_ELEMENT *t0; |
||
| 93 | int linbits; |
||
| 94 | int bits; |
||
| 95 | int code; |
||
| 96 | int x, y; |
||
| 97 | |||
| 98 | if (n <= 0) |
||
| 99 | return; |
||
| 100 | n = n >> 1; /* huff in pairs */ |
||
| 101 | /*-------------*/ |
||
| 102 | t0 = table_look[ntable].table; |
||
| 103 | linbits = table_look[ntable].linbits; |
||
| 104 | switch (table_look[ntable].ncase) |
||
| 105 | { |
||
| 106 | default: |
||
| 107 | /*------------------------------------------*/ |
||
| 108 | case no_bits: |
||
| 109 | /*- table 0, no data, x=y=0--*/ |
||
| 110 | for (i = 0; i < n; i++) |
||
| 111 | { |
||
| 112 | xy[i][0] = 0; |
||
| 113 | xy[i][1] = 0; |
||
| 114 | } |
||
| 115 | return; |
||
| 116 | /*------------------------------------------*/ |
||
| 117 | case one_shot: |
||
| 118 | /*- single lookup, no escapes -*/ |
||
| 119 | for (i = 0; i < n; i++) |
||
| 120 | { |
||
| 121 | mac_bitget_check((MAXBITS + 2)); |
||
| 122 | bits = t0[0].b.signbits; |
||
| 123 | code = mac_bitget2(bits); |
||
| 124 | mac_bitget_purge(t0[1 + code].b.purgebits); |
||
| 125 | x = t0[1 + code].b.x; |
||
| 126 | y = t0[1 + code].b.y; |
||
| 127 | if (x) |
||
| 128 | if (mac_bitget_1bit()) |
||
| 129 | x = -x; |
||
| 130 | if (y) |
||
| 131 | if (mac_bitget_1bit()) |
||
| 132 | y = -y; |
||
| 133 | xy[i][0] = x; |
||
| 134 | xy[i][1] = y; |
||
| 135 | if (bitget_overrun()) |
||
| 136 | break; // bad data protect |
||
| 137 | |||
| 138 | } |
||
| 139 | return; |
||
| 140 | /*------------------------------------------*/ |
||
| 141 | case no_linbits: |
||
| 142 | for (i = 0; i < n; i++) |
||
| 143 | { |
||
| 144 | t = t0; |
||
| 145 | for (;;) |
||
| 146 | { |
||
| 147 | mac_bitget_check((MAXBITS + 2)); |
||
| 148 | bits = t[0].b.signbits; |
||
| 149 | code = mac_bitget2(bits); |
||
| 150 | if (t[1 + code].b.purgebits) |
||
| 151 | break; |
||
| 152 | t += t[1 + code].ptr; /* ptr include 1+code */ |
||
| 153 | mac_bitget_purge(bits); |
||
| 154 | } |
||
| 155 | mac_bitget_purge(t[1 + code].b.purgebits); |
||
| 156 | x = t[1 + code].b.x; |
||
| 157 | y = t[1 + code].b.y; |
||
| 158 | if (x) |
||
| 159 | if (mac_bitget_1bit()) |
||
| 160 | x = -x; |
||
| 161 | if (y) |
||
| 162 | if (mac_bitget_1bit()) |
||
| 163 | y = -y; |
||
| 164 | xy[i][0] = x; |
||
| 165 | xy[i][1] = y; |
||
| 166 | if (bitget_overrun()) |
||
| 167 | break; // bad data protect |
||
| 168 | |||
| 169 | } |
||
| 170 | return; |
||
| 171 | /*------------------------------------------*/ |
||
| 172 | case have_linbits: |
||
| 173 | for (i = 0; i < n; i++) |
||
| 174 | { |
||
| 175 | t = t0; |
||
| 176 | for (;;) |
||
| 177 | { |
||
| 178 | bits = t[0].b.signbits; |
||
| 179 | code = bitget2(bits); |
||
| 180 | if (t[1 + code].b.purgebits) |
||
| 181 | break; |
||
| 182 | t += t[1 + code].ptr; /* ptr includes 1+code */ |
||
| 183 | mac_bitget_purge(bits); |
||
| 184 | } |
||
| 185 | mac_bitget_purge(t[1 + code].b.purgebits); |
||
| 186 | x = t[1 + code].b.x; |
||
| 187 | y = t[1 + code].b.y; |
||
| 188 | if (x == 15) |
||
| 189 | x += bitget_lb(linbits); |
||
| 190 | if (x) |
||
| 191 | if (mac_bitget_1bit()) |
||
| 192 | x = -x; |
||
| 193 | if (y == 15) |
||
| 194 | y += bitget_lb(linbits); |
||
| 195 | if (y) |
||
| 196 | if (mac_bitget_1bit()) |
||
| 197 | y = -y; |
||
| 198 | xy[i][0] = x; |
||
| 199 | xy[i][1] = y; |
||
| 200 | if (bitget_overrun()) |
||
| 201 | break; // bad data protect |
||
| 202 | |||
| 203 | } |
||
| 204 | return; |
||
| 205 | } |
||
| 206 | /*--- end switch ---*/ |
||
| 207 | |||
| 208 | } |
||
| 209 | |||
| 210 | int huffman_quad(int vwxy[][4], int n, int nbits, int ntable) |
||
| 211 | { |
||
| 212 | int i; |
||
| 213 | int code; |
||
| 214 | int x, y, v, w; |
||
| 215 | int tmp; |
||
| 216 | int i_non_zero, tmp_nz; |
||
| 217 | |||
| 218 | tmp_nz = 15; |
||
| 219 | i_non_zero = -1; |
||
| 220 | |||
| 221 | n = n >> 2; /* huff in quads */ |
||
| 222 | |||
| 223 | if (ntable) |
||
| 224 | goto case_quad_b; |
||
| 225 | |||
| 226 | /* case_quad_a: */ |
||
| 227 | for (i = 0; i < n; i++) |
||
| 228 | { |
||
| 229 | if (nbits <= 0) |
||
| 230 | break; |
||
| 231 | mac_bitget_check(10); |
||
| 232 | code = mac_bitget2(6); |
||
| 233 | nbits -= quad_table_a[code][0]; |
||
| 234 | mac_bitget_purge(quad_table_a[code][0]); |
||
| 235 | tmp = quad_table_a[code][1]; |
||
| 236 | if (tmp) |
||
| 237 | { |
||
| 238 | i_non_zero = i; |
||
| 239 | tmp_nz = tmp; |
||
| 240 | } |
||
| 241 | v = (tmp >> 3) & 1; |
||
| 242 | w = (tmp >> 2) & 1; |
||
| 243 | x = (tmp >> 1) & 1; |
||
| 244 | y = tmp & 1; |
||
| 245 | if (v) |
||
| 246 | { |
||
| 247 | if (mac_bitget_1bit()) |
||
| 248 | v = -v; |
||
| 249 | nbits--; |
||
| 250 | } |
||
| 251 | if (w) |
||
| 252 | { |
||
| 253 | if (mac_bitget_1bit()) |
||
| 254 | w = -w; |
||
| 255 | nbits--; |
||
| 256 | } |
||
| 257 | if (x) |
||
| 258 | { |
||
| 259 | if (mac_bitget_1bit()) |
||
| 260 | x = -x; |
||
| 261 | nbits--; |
||
| 262 | } |
||
| 263 | if (y) |
||
| 264 | { |
||
| 265 | if (mac_bitget_1bit()) |
||
| 266 | y = -y; |
||
| 267 | nbits--; |
||
| 268 | } |
||
| 269 | vwxy[i][0] = v; |
||
| 270 | vwxy[i][1] = w; |
||
| 271 | vwxy[i][2] = x; |
||
| 272 | vwxy[i][3] = y; |
||
| 273 | if (bitget_overrun()) |
||
| 274 | break; // bad data protect |
||
| 275 | |||
| 276 | } |
||
| 277 | if (nbits < 0) |
||
| 278 | { |
||
| 279 | i--; |
||
| 280 | vwxy[i][0] = 0; |
||
| 281 | vwxy[i][1] = 0; |
||
| 282 | vwxy[i][2] = 0; |
||
| 283 | vwxy[i][3] = 0; |
||
| 284 | } |
||
| 285 | |||
| 286 | i_non_zero = (i_non_zero + 1) << 2; |
||
| 287 | |||
| 288 | if ((tmp_nz & 3) == 0) |
||
| 289 | i_non_zero -= 2; |
||
| 290 | |||
| 291 | return i_non_zero; |
||
| 292 | |||
| 293 | /*--------------------*/ |
||
| 294 | case_quad_b: |
||
| 295 | for (i = 0; i < n; i++) |
||
| 296 | { |
||
| 297 | if (nbits < 4) |
||
| 298 | break; |
||
| 299 | nbits -= 4; |
||
| 300 | mac_bitget_check(8); |
||
| 301 | tmp = mac_bitget(4) ^ 15; /* one's complement of bitstream */ |
||
| 302 | if (tmp) |
||
| 303 | { |
||
| 304 | i_non_zero = i; |
||
| 305 | tmp_nz = tmp; |
||
| 306 | } |
||
| 307 | v = (tmp >> 3) & 1; |
||
| 308 | w = (tmp >> 2) & 1; |
||
| 309 | x = (tmp >> 1) & 1; |
||
| 310 | y = tmp & 1; |
||
| 311 | if (v) |
||
| 312 | { |
||
| 313 | if (mac_bitget_1bit()) |
||
| 314 | v = -v; |
||
| 315 | nbits--; |
||
| 316 | } |
||
| 317 | if (w) |
||
| 318 | { |
||
| 319 | if (mac_bitget_1bit()) |
||
| 320 | w = -w; |
||
| 321 | nbits--; |
||
| 322 | } |
||
| 323 | if (x) |
||
| 324 | { |
||
| 325 | if (mac_bitget_1bit()) |
||
| 326 | x = -x; |
||
| 327 | nbits--; |
||
| 328 | } |
||
| 329 | if (y) |
||
| 330 | { |
||
| 331 | if (mac_bitget_1bit()) |
||
| 332 | y = -y; |
||
| 333 | nbits--; |
||
| 334 | } |
||
| 335 | vwxy[i][0] = v; |
||
| 336 | vwxy[i][1] = w; |
||
| 337 | vwxy[i][2] = x; |
||
| 338 | vwxy[i][3] = y; |
||
| 339 | if (bitget_overrun()) |
||
| 340 | break; // bad data protect |
||
| 341 | |||
| 342 | } |
||
| 343 | if (nbits < 0) |
||
| 344 | { |
||
| 345 | i--; |
||
| 346 | vwxy[i][0] = 0; |
||
| 347 | vwxy[i][1] = 0; |
||
| 348 | vwxy[i][2] = 0; |
||
| 349 | vwxy[i][3] = 0; |
||
| 350 | } |
||
| 351 | |||
| 352 | i_non_zero = (i_non_zero + 1) << 2; |
||
| 353 | |||
| 354 | if ((tmp_nz & 3) == 0) |
||
| 355 | i_non_zero -= 2; |
||
| 356 | |||
| 357 | return i_non_zero; /* return non-zero sample (to nearest pair) */ |
||
| 358 | |||
| 359 | } |