?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / media / video / pwc / pwc-dec23.c
blob79333603d8bb36709b74882a2c21c1aadac8c433
1 /* Linux driver for Philips webcam
2 Decompression for chipset version 2 et 3
3 (C) 2004-2006 Luc Saillard (luc@saillard.org)
4
5 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
6 driver and thus may have bugs that are not present in the original version.
7 Please send bug reports and support requests to <luc@saillard.org>.
8 The decompression routines have been implemented by reverse-engineering the
9 Nemosoft binary pwcx module. Caveat emptor.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24
25 */
26
27 #include "pwc-timon.h"
28 #include "pwc-kiara.h"
29 #include "pwc-dec23.h"
30 #include <media/pwc-ioctl.h>
31
32 #include <linux/string.h>
33 #include <linux/slab.h>
34
35 /*
36 * USE_LOOKUP_TABLE_TO_CLAMP
37 * 0: use a C version of this tests: { a<0?0:(a>255?255:a) }
38 * 1: use a faster lookup table for cpu with a big cache (intel)
39 */
40 #define USE_LOOKUP_TABLE_TO_CLAMP 1
41 /*
42 * UNROLL_LOOP_FOR_COPYING_BLOCK
43 * 0: use a loop for a smaller code (but little slower)
44 * 1: when unrolling the loop, gcc produces some faster code (perhaps only
45 * valid for intel processor class). Activating this option, automaticaly
46 * activate USE_LOOKUP_TABLE_TO_CLAMP
47 */
48 #define UNROLL_LOOP_FOR_COPY 1
49 #if UNROLL_LOOP_FOR_COPY
50 # undef USE_LOOKUP_TABLE_TO_CLAMP
51 # define USE_LOOKUP_TABLE_TO_CLAMP 1
52 #endif
53
54 /*
55 * ENABLE_BAYER_DECODER
56 * 0: bayer decoder is not build (save some space)
57 * 1: bayer decoder is build and can be used
58 */
59 #define ENABLE_BAYER_DECODER 0
60
61 static void build_subblock_pattern(struct pwc_dec23_private *pdec)
62 {
63 static const unsigned int initial_values[12] = {
64 -0x526500, -0x221200, 0x221200, 0x526500,
65 -0x3de200, 0x3de200,
66 -0x6db480, -0x2d5d00, 0x2d5d00, 0x6db480,
67 -0x12c200, 0x12c200
68
69 };
70 static const unsigned int values_derivated[12] = {
71 0xa4ca, 0x4424, -0x4424, -0xa4ca,
72 0x7bc4, -0x7bc4,
73 0xdb69, 0x5aba, -0x5aba, -0xdb69,
74 0x2584, -0x2584
75 };
76 unsigned int temp_values[12];
77 int i, j;
78
79 memcpy(temp_values, initial_values, sizeof(initial_values));
80 for (i = 0; i < 256; i++) {
81 for (j = 0; j < 12; j++) {
82 pdec->table_subblock[i][j] = temp_values[j];
83 temp_values[j] += values_derivated[j];
84 }
85 }
86 }
87
88 static void build_bit_powermask_table(struct pwc_dec23_private *pdec)
89 {
90 unsigned char *p;
91 unsigned int bit, byte, mask, val;
92 unsigned int bitpower = 1;
93
94 for (bit = 0; bit < 8; bit++) {
95 mask = bitpower - 1;
96 p = pdec->table_bitpowermask[bit];
97 for (byte = 0; byte < 256; byte++) {
98 val = (byte & mask);
99 if (byte & bitpower)
100 val = -val;
101 *p++ = val;
102 }
103 bitpower<<=1;
104 }
105 }
106
107
108 static void build_table_color(const unsigned int romtable[16][8],
109 unsigned char p0004[16][1024],
110 unsigned char p8004[16][256])
111 {
112 int compression_mode, j, k, bit, pw;
113 unsigned char *p0, *p8;
114 const unsigned int *r;
115
116 /* We have 16 compressions tables */
117 for (compression_mode = 0; compression_mode < 16; compression_mode++) {
118 p0 = p0004[compression_mode];
119 p8 = p8004[compression_mode];
120 r = romtable[compression_mode];
121
122 for (j = 0; j < 8; j++, r++, p0 += 128) {
123
124 for (k = 0; k < 16; k++) {
125 if (k == 0)
126 bit = 1;
127 else if (k >= 1 && k < 3)
128 bit = (r[0] >> 15) & 7;
129 else if (k >= 3 && k < 6)
130 bit = (r[0] >> 12) & 7;
131 else if (k >= 6 && k < 10)
132 bit = (r[0] >> 9) & 7;
133 else if (k >= 10 && k < 13)
134 bit = (r[0] >> 6) & 7;
135 else if (k >= 13 && k < 15)
136 bit = (r[0] >> 3) & 7;
137 else
138 bit = (r[0]) & 7;
139 if (k == 0)
140 *p8++ = 8;
141 else
142 *p8++ = j - bit;
143 *p8++ = bit;
144
145 pw = 1 << bit;
146 p0[k + 0x00] = (1 * pw) + 0x80;
147 p0[k + 0x10] = (2 * pw) + 0x80;
148 p0[k + 0x20] = (3 * pw) + 0x80;
149 p0[k + 0x30] = (4 * pw) + 0x80;
150 p0[k + 0x40] = (-1 * pw) + 0x80;
151 p0[k + 0x50] = (-2 * pw) + 0x80;
152 p0[k + 0x60] = (-3 * pw) + 0x80;
153 p0[k + 0x70] = (-4 * pw) + 0x80;
154 } /* end of for (k=0; k<16; k++, p8++) */
155 } /* end of for (j=0; j<8; j++ , table++) */
156 } /* end of foreach compression_mode */
157 }
158
159 /*
160 *
161 */
162 static void fill_table_dc00_d800(struct pwc_dec23_private *pdec)
163 {
164 #define SCALEBITS 15
165 #define ONE_HALF (1UL << (SCALEBITS - 1))
166 int i;
167 unsigned int offset1 = ONE_HALF;
168 unsigned int offset2 = 0x0000;
169
170 for (i=0; i<256; i++) {
171 pdec->table_dc00[i] = offset1 & ~(ONE_HALF);
172 pdec->table_d800[i] = offset2;
173
174 offset1 += 0x7bc4;
175 offset2 += 0x7bc4;
176 }
177 }
178
179 static const unsigned char hash_table_ops[64*4] = {
180 0x02, 0x00, 0x00, 0x00,
181 0x00, 0x03, 0x01, 0x00,
182 0x00, 0x04, 0x01, 0x10,
183 0x00, 0x06, 0x01, 0x30,
184 0x02, 0x00, 0x00, 0x00,
185 0x00, 0x03, 0x01, 0x40,
186 0x00, 0x05, 0x01, 0x20,
187 0x01, 0x00, 0x00, 0x00,
188 0x02, 0x00, 0x00, 0x00,
189 0x00, 0x03, 0x01, 0x00,
190 0x00, 0x04, 0x01, 0x50,
191 0x00, 0x05, 0x02, 0x00,
192 0x02, 0x00, 0x00, 0x00,
193 0x00, 0x03, 0x01, 0x40,
194 0x00, 0x05, 0x03, 0x00,
195 0x01, 0x00, 0x00, 0x00,
196 0x02, 0x00, 0x00, 0x00,
197 0x00, 0x03, 0x01, 0x00,
198 0x00, 0x04, 0x01, 0x10,
199 0x00, 0x06, 0x02, 0x10,
200 0x02, 0x00, 0x00, 0x00,
201 0x00, 0x03, 0x01, 0x40,
202 0x00, 0x05, 0x01, 0x60,
203 0x01, 0x00, 0x00, 0x00,
204 0x02, 0x00, 0x00, 0x00,
205 0x00, 0x03, 0x01, 0x00,
206 0x00, 0x04, 0x01, 0x50,
207 0x00, 0x05, 0x02, 0x40,
208 0x02, 0x00, 0x00, 0x00,
209 0x00, 0x03, 0x01, 0x40,
210 0x00, 0x05, 0x03, 0x40,
211 0x01, 0x00, 0x00, 0x00,
212 0x02, 0x00, 0x00, 0x00,
213 0x00, 0x03, 0x01, 0x00,
214 0x00, 0x04, 0x01, 0x10,
215 0x00, 0x06, 0x01, 0x70,
216 0x02, 0x00, 0x00, 0x00,
217 0x00, 0x03, 0x01, 0x40,
218 0x00, 0x05, 0x01, 0x20,
219 0x01, 0x00, 0x00, 0x00,
220 0x02, 0x00, 0x00, 0x00,
221 0x00, 0x03, 0x01, 0x00,
222 0x00, 0x04, 0x01, 0x50,
223 0x00, 0x05, 0x02, 0x00,
224 0x02, 0x00, 0x00, 0x00,
225 0x00, 0x03, 0x01, 0x40,
226 0x00, 0x05, 0x03, 0x00,
227 0x01, 0x00, 0x00, 0x00,
228 0x02, 0x00, 0x00, 0x00,
229 0x00, 0x03, 0x01, 0x00,
230 0x00, 0x04, 0x01, 0x10,
231 0x00, 0x06, 0x02, 0x50,
232 0x02, 0x00, 0x00, 0x00,
233 0x00, 0x03, 0x01, 0x40,
234 0x00, 0x05, 0x01, 0x60,
235 0x01, 0x00, 0x00, 0x00,
236 0x02, 0x00, 0x00, 0x00,
237 0x00, 0x03, 0x01, 0x00,
238 0x00, 0x04, 0x01, 0x50,
239 0x00, 0x05, 0x02, 0x40,
240 0x02, 0x00, 0x00, 0x00,
241 0x00, 0x03, 0x01, 0x40,
242 0x00, 0x05, 0x03, 0x40,
243 0x01, 0x00, 0x00, 0x00
244 };
245
246 /*
247 *
248 */
249 static const unsigned int MulIdx[16][16] = {
250 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
251 {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,},
252 {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,},
253 {4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4,},
254 {6, 7, 8, 9, 7, 10, 11, 8, 8, 11, 10, 7, 9, 8, 7, 6,},
255 {4, 5, 5, 4, 4, 5, 5, 4, 4, 5, 5, 4, 4, 5, 5, 4,},
256 {1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2,},
257 {0, 3, 3, 0, 1, 2, 2, 1, 2, 1, 1, 2, 3, 0, 0, 3,},
258 {0, 1, 2, 3, 3, 2, 1, 0, 3, 2, 1, 0, 0, 1, 2, 3,},
259 {1, 1, 1, 1, 3, 3, 3, 3, 0, 0, 0, 0, 2, 2, 2, 2,},
260 {7, 10, 11, 8, 9, 8, 7, 6, 6, 7, 8, 9, 8, 11, 10, 7,},
261 {4, 5, 5, 4, 5, 4, 4, 5, 5, 4, 4, 5, 4, 5, 5, 4,},
262 {7, 9, 6, 8, 10, 8, 7, 11, 11, 7, 8, 10, 8, 6, 9, 7,},
263 {1, 3, 0, 2, 2, 0, 3, 1, 2, 0, 3, 1, 1, 3, 0, 2,},
264 {1, 2, 2, 1, 3, 0, 0, 3, 0, 3, 3, 0, 2, 1, 1, 2,},
265 {10, 8, 7, 11, 8, 6, 9, 7, 7, 9, 6, 8, 11, 7, 8, 10}
266 };
267
268 #if USE_LOOKUP_TABLE_TO_CLAMP
269 #define MAX_OUTER_CROP_VALUE (512)
270 static unsigned char pwc_crop_table[256 + 2*MAX_OUTER_CROP_VALUE];
271 #define CLAMP(x) (pwc_crop_table[MAX_OUTER_CROP_VALUE+(x)])
272 #else
273 #define CLAMP(x) ((x)>255?255:((x)<0?0:x))
274 #endif
275
276
277 /* If the type or the command change, we rebuild the lookup table */
278 int pwc_dec23_init(struct pwc_device *pwc, int type, unsigned char *cmd)
279 {
280 int flags, version, shift, i;
281 struct pwc_dec23_private *pdec;
282
283 if (pwc->decompress_data == NULL) {
284 pdec = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);
285 if (pdec == NULL)
286 return -ENOMEM;
287 pwc->decompress_data = pdec;
288 }
289 pdec = pwc->decompress_data;
290
291 if (DEVICE_USE_CODEC3(type)) {
292 flags = cmd[2] & 0x18;
293 if (flags == 8)
294 pdec->nbits = 7; /* More bits, mean more bits to encode the stream, but better quality */
295 else if (flags == 0x10)
296 pdec->nbits = 8;
297 else
298 pdec->nbits = 6;
299
300 version = cmd[2] >> 5;
301 build_table_color(KiaraRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
302 build_table_color(KiaraRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
303
304 } else {
305
306 flags = cmd[2] & 6;
307 if (flags == 2)
308 pdec->nbits = 7;
309 else if (flags == 4)
310 pdec->nbits = 8;
311 else
312 pdec->nbits = 6;
313
314 version = cmd[2] >> 3;
315 build_table_color(TimonRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
316 build_table_color(TimonRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
317 }
318
319 /* Informations can be coded on a variable number of bits but never less than 8 */
320 shift = 8 - pdec->nbits;
321 pdec->scalebits = SCALEBITS - shift;
322 pdec->nbitsmask = 0xFF >> shift;
323
324 fill_table_dc00_d800(pdec);
325 build_subblock_pattern(pdec);
326 build_bit_powermask_table(pdec);
327
328 #if USE_LOOKUP_TABLE_TO_CLAMP
329 /* Build the static table to clamp value [0-255] */
330 for (i=0;i<MAX_OUTER_CROP_VALUE;i++)
331 pwc_crop_table[i] = 0;
332 for (i=0; i<256; i++)
333 pwc_crop_table[MAX_OUTER_CROP_VALUE+i] = i;
334 for (i=0; i<MAX_OUTER_CROP_VALUE; i++)
335 pwc_crop_table[MAX_OUTER_CROP_VALUE+256+i] = 255;
336 #endif
337
338 return 0;
339 }
340
341 /*
342 * Copy the 4x4 image block to Y plane buffer
343 */
344 static void copy_image_block_Y(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
345 {
346 #if UNROLL_LOOP_FOR_COPY
347 const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
348 const int *c = src;
349 unsigned char *d = dst;
350
351 *d++ = cm[c[0] >> scalebits];
352 *d++ = cm[c[1] >> scalebits];
353 *d++ = cm[c[2] >> scalebits];
354 *d++ = cm[c[3] >> scalebits];
355
356 d = dst + bytes_per_line;
357 *d++ = cm[c[4] >> scalebits];
358 *d++ = cm[c[5] >> scalebits];
359 *d++ = cm[c[6] >> scalebits];
360 *d++ = cm[c[7] >> scalebits];
361
362 d = dst + bytes_per_line*2;
363 *d++ = cm[c[8] >> scalebits];
364 *d++ = cm[c[9] >> scalebits];
365 *d++ = cm[c[10] >> scalebits];
366 *d++ = cm[c[11] >> scalebits];
367
368 d = dst + bytes_per_line*3;
369 *d++ = cm[c[12] >> scalebits];
370 *d++ = cm[c[13] >> scalebits];
371 *d++ = cm[c[14] >> scalebits];
372 *d++ = cm[c[15] >> scalebits];
373 #else
374 int i;
375 const int *c = src;
376 unsigned char *d = dst;
377 for (i = 0; i < 4; i++, c++)
378 *d++ = CLAMP((*c) >> scalebits);
379
380 d = dst + bytes_per_line;
381 for (i = 0; i < 4; i++, c++)
382 *d++ = CLAMP((*c) >> scalebits);
383
384 d = dst + bytes_per_line*2;
385 for (i = 0; i < 4; i++, c++)
386 *d++ = CLAMP((*c) >> scalebits);
387
388 d = dst + bytes_per_line*3;
389 for (i = 0; i < 4; i++, c++)
390 *d++ = CLAMP((*c) >> scalebits);
391 #endif
392 }
393
394 /*
395 * Copy the 4x4 image block to a CrCb plane buffer
396 *
397 */
398 static void copy_image_block_CrCb(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
399 {
400 #if UNROLL_LOOP_FOR_COPY
401 /* Unroll all loops */
402 const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
403 const int *c = src;
404 unsigned char *d = dst;
405
406 *d++ = cm[c[0] >> scalebits];
407 *d++ = cm[c[4] >> scalebits];
408 *d++ = cm[c[1] >> scalebits];
409 *d++ = cm[c[5] >> scalebits];
410 *d++ = cm[c[2] >> scalebits];
411 *d++ = cm[c[6] >> scalebits];
412 *d++ = cm[c[3] >> scalebits];
413 *d++ = cm[c[7] >> scalebits];
414
415 d = dst + bytes_per_line;
416 *d++ = cm[c[12] >> scalebits];
417 *d++ = cm[c[8] >> scalebits];
418 *d++ = cm[c[13] >> scalebits];
419 *d++ = cm[c[9] >> scalebits];
420 *d++ = cm[c[14] >> scalebits];
421 *d++ = cm[c[10] >> scalebits];
422 *d++ = cm[c[15] >> scalebits];
423 *d++ = cm[c[11] >> scalebits];
424 #else
425 int i;
426 const int *c1 = src;
427 const int *c2 = src + 4;
428 unsigned char *d = dst;
429
430 for (i = 0; i < 4; i++, c1++, c2++) {
431 *d++ = CLAMP((*c1) >> scalebits);
432 *d++ = CLAMP((*c2) >> scalebits);
433 }
434 c1 = src + 12;
435 d = dst + bytes_per_line;
436 for (i = 0; i < 4; i++, c1++, c2++) {
437 *d++ = CLAMP((*c1) >> scalebits);
438 *d++ = CLAMP((*c2) >> scalebits);
439 }
440 #endif
441 }
442
443 #if ENABLE_BAYER_DECODER
444 /*
445 * Format: 8x2 pixels
446 * . G . G . G . G . G . G . G
447 * . . . . . . . . . . . . . .
448 * . G . G . G . G . G . G . G
449 * . . . . . . . . . . . . . .
450 * or
451 * . . . . . . . . . . . . . .
452 * G . G . G . G . G . G . G .
453 * . . . . . . . . . . . . . .
454 * G . G . G . G . G . G . G .
455 */
456 static void copy_image_block_Green(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
457 {
458 #if UNROLL_LOOP_FOR_COPY
459 /* Unroll all loops */
460 const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
461 unsigned char *d = dst;
462 const int *c = src;
463
464 d[0] = cm[c[0] >> scalebits];
465 d[2] = cm[c[1] >> scalebits];
466 d[4] = cm[c[2] >> scalebits];
467 d[6] = cm[c[3] >> scalebits];
468 d[8] = cm[c[4] >> scalebits];
469 d[10] = cm[c[5] >> scalebits];
470 d[12] = cm[c[6] >> scalebits];
471 d[14] = cm[c[7] >> scalebits];
472
473 d = dst + bytes_per_line;
474 d[0] = cm[c[8] >> scalebits];
475 d[2] = cm[c[9] >> scalebits];
476 d[4] = cm[c[10] >> scalebits];
477 d[6] = cm[c[11] >> scalebits];
478 d[8] = cm[c[12] >> scalebits];
479 d[10] = cm[c[13] >> scalebits];
480 d[12] = cm[c[14] >> scalebits];
481 d[14] = cm[c[15] >> scalebits];
482 #else
483 int i;
484 unsigned char *d;
485 const int *c = src;
486
487 d = dst;
488 for (i = 0; i < 8; i++, c++)
489 d[i*2] = CLAMP((*c) >> scalebits);
490
491 d = dst + bytes_per_line;
492 for (i = 0; i < 8; i++, c++)
493 d[i*2] = CLAMP((*c) >> scalebits);
494 #endif
495 }
496 #endif
497
498 #if ENABLE_BAYER_DECODER
499 /*
500 * Format: 4x4 pixels
501 * R . R . R . R
502 * . B . B . B .
503 * R . R . R . R
504 * . B . B . B .
505 */
506 static void copy_image_block_RedBlue(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
507 {
508 #if UNROLL_LOOP_FOR_COPY
509 /* Unroll all loops */
510 const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
511 unsigned char *d = dst;
512 const int *c = src;
513
514 d[0] = cm[c[0] >> scalebits];
515 d[2] = cm[c[1] >> scalebits];
516 d[4] = cm[c[2] >> scalebits];
517 d[6] = cm[c[3] >> scalebits];
518
519 d = dst + bytes_per_line;
520 d[1] = cm[c[4] >> scalebits];
521 d[3] = cm[c[5] >> scalebits];
522 d[5] = cm[c[6] >> scalebits];
523 d[7] = cm[c[7] >> scalebits];
524
525 d = dst + bytes_per_line*2;
526 d[0] = cm[c[8] >> scalebits];
527 d[2] = cm[c[9] >> scalebits];
528 d[4] = cm[c[10] >> scalebits];
529 d[6] = cm[c[11] >> scalebits];
530
531 d = dst + bytes_per_line*3;
532 d[1] = cm[c[12] >> scalebits];
533 d[3] = cm[c[13] >> scalebits];
534 d[5] = cm[c[14] >> scalebits];
535 d[7] = cm[c[15] >> scalebits];
536 #else
537 int i;
538 unsigned char *d;
539 const int *c = src;
540
541 d = dst;
542 for (i = 0; i < 4; i++, c++)
543 d[i*2] = CLAMP((*c) >> scalebits);
544
545 d = dst + bytes_per_line;
546 for (i = 0; i < 4; i++, c++)
547 d[i*2+1] = CLAMP((*c) >> scalebits);
548
549 d = dst + bytes_per_line*2;
550 for (i = 0; i < 4; i++, c++)
551 d[i*2] = CLAMP((*c) >> scalebits);
552
553 d = dst + bytes_per_line*3;
554 for (i = 0; i < 4; i++, c++)
555 d[i*2+1] = CLAMP((*c) >> scalebits);
556 #endif
557 }
558 #endif
559
560 /*
561 * To manage the stream, we keep bits in a 32 bits register.
562 * fill_nbits(n): fill the reservoir with at least n bits
563 * skip_bits(n): discard n bits from the reservoir
564 * get_bits(n): fill the reservoir, returns the first n bits and discard the
565 * bits from the reservoir.
566 * __get_nbits(n): faster version of get_bits(n), but asumes that the reservoir
567 * contains at least n bits. bits returned is discarded.
568 */
569 #define fill_nbits(pdec, nbits_wanted) do { \
570 while (pdec->nbits_in_reservoir<(nbits_wanted)) \
571 { \
572 pdec->reservoir |= (*(pdec->stream)++) << (pdec->nbits_in_reservoir); \
573 pdec->nbits_in_reservoir += 8; \
574 } \
575 } while(0);
576
577 #define skip_nbits(pdec, nbits_to_skip) do { \
578 pdec->reservoir >>= (nbits_to_skip); \
579 pdec->nbits_in_reservoir -= (nbits_to_skip); \
580 } while(0);
581
582 #define get_nbits(pdec, nbits_wanted, result) do { \
583 fill_nbits(pdec, nbits_wanted); \
584 result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
585 skip_nbits(pdec, nbits_wanted); \
586 } while(0);
587
588 #define __get_nbits(pdec, nbits_wanted, result) do { \
589 result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
590 skip_nbits(pdec, nbits_wanted); \
591 } while(0);
592
593 #define look_nbits(pdec, nbits_wanted) \
594 ((pdec->reservoir) & ((1U<<(nbits_wanted))-1))
595
596 /*
597 * Decode a 4x4 pixel block
598 */
599 static void decode_block(struct pwc_dec23_private *pdec,
600 const unsigned char *ptable0004,
601 const unsigned char *ptable8004)
602 {
603 unsigned int primary_color;
604 unsigned int channel_v, offset1, op;
605 int i;
606
607 fill_nbits(pdec, 16);
608 __get_nbits(pdec, pdec->nbits, primary_color);
609
610 if (look_nbits(pdec,2) == 0) {
611 skip_nbits(pdec, 2);
612 /* Very simple, the color is the same for all pixels of the square */
613 for (i = 0; i < 16; i++)
614 pdec->temp_colors[i] = pdec->table_dc00[primary_color];
615
616 return;
617 }
618
619 /* This block is encoded with small pattern */
620 for (i = 0; i < 16; i++)
621 pdec->temp_colors[i] = pdec->table_d800[primary_color];
622
623 __get_nbits(pdec, 3, channel_v);
624 channel_v = ((channel_v & 1) << 2) | (channel_v & 2) | ((channel_v & 4) >> 2);
625
626 ptable0004 += (channel_v * 128);
627 ptable8004 += (channel_v * 32);
628
629 offset1 = 0;
630 do
631 {
632 unsigned int htable_idx, rows = 0;
633 const unsigned int *block;
634
635 /* [ zzzz y x x ]
636 * xx == 00 :=> end of the block def, remove the two bits from the stream
637 * yxx == 111
638 * yxx == any other value
639 *
640 */
641 fill_nbits(pdec, 16);
642 htable_idx = look_nbits(pdec, 6);
643 op = hash_table_ops[htable_idx * 4];
644
645 if (op == 2) {
646 skip_nbits(pdec, 2);
647
648 } else if (op == 1) {
649 unsigned int mask, shift;
650 unsigned int nbits, col1;
651 unsigned int yyyy;
652
653 skip_nbits(pdec, 3);
654 /* offset1 += yyyy */
655 __get_nbits(pdec, 4, yyyy);
656 offset1 += 1 + yyyy;
657 offset1 &= 0x0F;
658 nbits = ptable8004[offset1 * 2];
659
660 __get_nbits(pdec, nbits+1, col1);
661
662 /* Bit mask table */
663 mask = pdec->table_bitpowermask[nbits][col1];
664 shift = ptable8004[offset1 * 2 + 1];
665 rows = ((mask << shift) + 0x80) & 0xFF;
666
667 block = pdec->table_subblock[rows];
668 for (i = 0; i < 16; i++)
669 pdec->temp_colors[i] += block[MulIdx[offset1][i]];
670
671 } else {
672 /* op == 0
673 * offset1 is coded on 3 bits
674 */
675 unsigned int shift;
676
677 offset1 += hash_table_ops [htable_idx * 4 + 2];
678 offset1 &= 0x0F;
679
680 rows = ptable0004[offset1 + hash_table_ops [htable_idx * 4 + 3]];
681 block = pdec->table_subblock[rows];
682 for (i = 0; i < 16; i++)
683 pdec->temp_colors[i] += block[MulIdx[offset1][i]];
684
685 shift = hash_table_ops[htable_idx * 4 + 1];
686 skip_nbits(pdec, shift);
687 }
688
689 } while (op != 2);
690
691 }
692
693 static void DecompressBand23(struct pwc_dec23_private *pdec,
694 const unsigned char *rawyuv,
695 unsigned char *planar_y,
696 unsigned char *planar_u,
697 unsigned char *planar_v,
698 unsigned int compressed_image_width,
699 unsigned int real_image_width)
700 {
701 int compression_index, nblocks;
702 const unsigned char *ptable0004;
703 const unsigned char *ptable8004;
704
705 pdec->reservoir = 0;
706 pdec->nbits_in_reservoir = 0;
707 pdec->stream = rawyuv + 1; /* The first byte of the stream is skipped */
708
709 get_nbits(pdec, 4, compression_index);
710
711 /* pass 1: uncompress Y component */
712 nblocks = compressed_image_width / 4;
713
714 ptable0004 = pdec->table_0004_pass1[compression_index];
715 ptable8004 = pdec->table_8004_pass1[compression_index];
716
717 /* Each block decode a square of 4x4 */
718 while (nblocks) {
719 decode_block(pdec, ptable0004, ptable8004);
720 copy_image_block_Y(pdec->temp_colors, planar_y, real_image_width, pdec->scalebits);
721 planar_y += 4;
722 nblocks--;
723 }
724
725 /* pass 2: uncompress UV component */
726 nblocks = compressed_image_width / 8;
727
728 ptable0004 = pdec->table_0004_pass2[compression_index];
729 ptable8004 = pdec->table_8004_pass2[compression_index];
730
731 /* Each block decode a square of 4x4 */
732 while (nblocks) {
733 decode_block(pdec, ptable0004, ptable8004);
734 copy_image_block_CrCb(pdec->temp_colors, planar_u, real_image_width/2, pdec->scalebits);
735
736 decode_block(pdec, ptable0004, ptable8004);
737 copy_image_block_CrCb(pdec->temp_colors, planar_v, real_image_width/2, pdec->scalebits);
738
739 planar_v += 8;
740 planar_u += 8;
741 nblocks -= 2;
742 }
743
744 }
745
746 #if ENABLE_BAYER_DECODER
747 /*
748 * Size need to be a multiple of 8 in width
749 *
750 * Return a block of four line encoded like this:
751 *
752 * G R G R G R G R G R G R G R G R
753 * B G B G B G B G B G B G B G B G
754 * G R G R G R G R G R G R G R G R
755 * B G B G B G B G B G B G B G B G
756 *
757 */
758 static void DecompressBandBayer(struct pwc_dec23_private *pdec,
759 const unsigned char *rawyuv,
760 unsigned char *rgbbayer,
761 unsigned int compressed_image_width,
762 unsigned int real_image_width)
763 {
764 int compression_index, nblocks;
765 const unsigned char *ptable0004;
766 const unsigned char *ptable8004;
767 unsigned char *dest;
768
769 pdec->reservoir = 0;
770 pdec->nbits_in_reservoir = 0;
771 pdec->stream = rawyuv + 1; /* The first byte of the stream is skipped */
772
773 get_nbits(pdec, 4, compression_index);
774
775 /* pass 1: uncompress RB component */
776 nblocks = compressed_image_width / 4;
777
778 ptable0004 = pdec->table_0004_pass1[compression_index];
779 ptable8004 = pdec->table_8004_pass1[compression_index];
780 dest = rgbbayer;
781
782 /* Each block decode a square of 4x4 */
783 while (nblocks) {
784 decode_block(pdec, ptable0004, ptable8004);
785 copy_image_block_RedBlue(pdec->temp_colors, rgbbayer, real_image_width, pdec->scalebits);
786 dest += 8;
787 nblocks--;
788 }
789
790 /* pass 2: uncompress G component */
791 nblocks = compressed_image_width / 8;
792
793 ptable0004 = pdec->table_0004_pass2[compression_index];
794 ptable8004 = pdec->table_8004_pass2[compression_index];
795
796 /* Each block decode a square of 4x4 */
797 while (nblocks) {
798 decode_block(pdec, ptable0004, ptable8004);
799 copy_image_block_Green(pdec->temp_colors, rgbbayer+1, real_image_width, pdec->scalebits);
800
801 decode_block(pdec, ptable0004, ptable8004);
802 copy_image_block_Green(pdec->temp_colors, rgbbayer+real_image_width, real_image_width, pdec->scalebits);
803
804 rgbbayer += 16;
805 nblocks -= 2;
806 }
807 }
808 #endif
809
810
811 /**
812 *
813 * Uncompress a pwc23 buffer.
814 *
815 * pwc.view: size of the image wanted
816 * pwc.image: size of the image returned by the camera
817 * pwc.offset: (x,y) to displayer image in the view
818 *
819 * src: raw data
820 * dst: image output
821 * flags: PWCX_FLAG_PLANAR or PWCX_FLAG_BAYER
822 */
823 void pwc_dec23_decompress(const struct pwc_device *pwc,
824 const void *src,
825 void *dst,
826 int flags)
827 {
828 int bandlines_left, stride, bytes_per_block;
829
830 bandlines_left = pwc->image.y / 4;
831 bytes_per_block = pwc->view.x * 4;
832
833 if (flags & PWCX_FLAG_BAYER) {
834 #if ENABLE_BAYER_DECODER
835 /* RGB Bayer format */
836 unsigned char *rgbout;
837
838 stride = pwc->view.x * pwc->offset.y;
839 rgbout = dst + stride + pwc->offset.x;
840
841
842 while (bandlines_left--) {
843
844 DecompressBandBayer(pwc->decompress_data,
845 src,
846 rgbout,
847 pwc->image.x, pwc->view.x);
848
849 src += pwc->vbandlength;
850 rgbout += bytes_per_block;
851
852 }
853 #else
854 memset(dst, 0, pwc->view.x * pwc->view.y);
855 #endif
856
857 } else {
858 /* YUV420P image format */
859 unsigned char *pout_planar_y;
860 unsigned char *pout_planar_u;
861 unsigned char *pout_planar_v;
862 unsigned int plane_size;
863
864 plane_size = pwc->view.x * pwc->view.y;
865
866 /* offset in Y plane */
867 stride = pwc->view.x * pwc->offset.y;
868 pout_planar_y = dst + stride + pwc->offset.x;
869
870 /* offsets in U/V planes */
871 stride = (pwc->view.x * pwc->offset.y) / 4 + pwc->offset.x / 2;
872 pout_planar_u = dst + plane_size + stride;
873 pout_planar_v = dst + plane_size + plane_size / 4 + stride;
874
875 while (bandlines_left--) {
876
877 DecompressBand23(pwc->decompress_data,
878 src,
879 pout_planar_y, pout_planar_u, pout_planar_v,
880 pwc->image.x, pwc->view.x);
881 src += pwc->vbandlength;
882 pout_planar_y += bytes_per_block;
883 pout_planar_u += pwc->view.x;
884 pout_planar_v += pwc->view.x;
885
886 }
887
888 }
889
890 }
891
892 void pwc_dec23_exit(void)
893 {
894 /* Do nothing */
895
896 }
897
898 /**
899 * Allocate a private structure used by lookup table.
900 * You must call kfree() to free the memory allocated.
901 */
902 int pwc_dec23_alloc(struct pwc_device *pwc)
903 {
904 pwc->decompress_data = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);
905 if (pwc->decompress_data == NULL)
906 return -ENOMEM;
907 return 0;
908 }
909
910 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
Tomato firmware and modifications.