?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid beyond bounds copy while caching ACL
[zen-stable.git] / drivers / media / video / pwc / pwc-dec23.c
blob3792fedff9515e85734200d8ffb22aa1ed15bb93
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
31 #include <linux/string.h>
32 #include <linux/slab.h>
33
34 /*
35 * USE_LOOKUP_TABLE_TO_CLAMP
36 * 0: use a C version of this tests: { a<0?0:(a>255?255:a) }
37 * 1: use a faster lookup table for cpu with a big cache (intel)
38 */
39 #define USE_LOOKUP_TABLE_TO_CLAMP 1
40 /*
41 * UNROLL_LOOP_FOR_COPYING_BLOCK
42 * 0: use a loop for a smaller code (but little slower)
43 * 1: when unrolling the loop, gcc produces some faster code (perhaps only
44 * valid for intel processor class). Activating this option, automaticaly
45 * activate USE_LOOKUP_TABLE_TO_CLAMP
46 */
47 #define UNROLL_LOOP_FOR_COPY 1
48 #if UNROLL_LOOP_FOR_COPY
49 # undef USE_LOOKUP_TABLE_TO_CLAMP
50 # define USE_LOOKUP_TABLE_TO_CLAMP 1
51 #endif
52
53 static void build_subblock_pattern(struct pwc_dec23_private *pdec)
54 {
55 static const unsigned int initial_values[12] = {
56 -0x526500, -0x221200, 0x221200, 0x526500,
57 -0x3de200, 0x3de200,
58 -0x6db480, -0x2d5d00, 0x2d5d00, 0x6db480,
59 -0x12c200, 0x12c200
60
61 };
62 static const unsigned int values_derivated[12] = {
63 0xa4ca, 0x4424, -0x4424, -0xa4ca,
64 0x7bc4, -0x7bc4,
65 0xdb69, 0x5aba, -0x5aba, -0xdb69,
66 0x2584, -0x2584
67 };
68 unsigned int temp_values[12];
69 int i, j;
70
71 memcpy(temp_values, initial_values, sizeof(initial_values));
72 for (i = 0; i < 256; i++) {
73 for (j = 0; j < 12; j++) {
74 pdec->table_subblock[i][j] = temp_values[j];
75 temp_values[j] += values_derivated[j];
76 }
77 }
78 }
79
80 static void build_bit_powermask_table(struct pwc_dec23_private *pdec)
81 {
82 unsigned char *p;
83 unsigned int bit, byte, mask, val;
84 unsigned int bitpower = 1;
85
86 for (bit = 0; bit < 8; bit++) {
87 mask = bitpower - 1;
88 p = pdec->table_bitpowermask[bit];
89 for (byte = 0; byte < 256; byte++) {
90 val = (byte & mask);
91 if (byte & bitpower)
92 val = -val;
93 *p++ = val;
94 }
95 bitpower<<=1;
96 }
97 }
98
99
100 static void build_table_color(const unsigned int romtable[16][8],
101 unsigned char p0004[16][1024],
102 unsigned char p8004[16][256])
103 {
104 int compression_mode, j, k, bit, pw;
105 unsigned char *p0, *p8;
106 const unsigned int *r;
107
108 /* We have 16 compressions tables */
109 for (compression_mode = 0; compression_mode < 16; compression_mode++) {
110 p0 = p0004[compression_mode];
111 p8 = p8004[compression_mode];
112 r = romtable[compression_mode];
113
114 for (j = 0; j < 8; j++, r++, p0 += 128) {
115
116 for (k = 0; k < 16; k++) {
117 if (k == 0)
118 bit = 1;
119 else if (k >= 1 && k < 3)
120 bit = (r[0] >> 15) & 7;
121 else if (k >= 3 && k < 6)
122 bit = (r[0] >> 12) & 7;
123 else if (k >= 6 && k < 10)
124 bit = (r[0] >> 9) & 7;
125 else if (k >= 10 && k < 13)
126 bit = (r[0] >> 6) & 7;
127 else if (k >= 13 && k < 15)
128 bit = (r[0] >> 3) & 7;
129 else
130 bit = (r[0]) & 7;
131 if (k == 0)
132 *p8++ = 8;
133 else
134 *p8++ = j - bit;
135 *p8++ = bit;
136
137 pw = 1 << bit;
138 p0[k + 0x00] = (1 * pw) + 0x80;
139 p0[k + 0x10] = (2 * pw) + 0x80;
140 p0[k + 0x20] = (3 * pw) + 0x80;
141 p0[k + 0x30] = (4 * pw) + 0x80;
142 p0[k + 0x40] = (-1 * pw) + 0x80;
143 p0[k + 0x50] = (-2 * pw) + 0x80;
144 p0[k + 0x60] = (-3 * pw) + 0x80;
145 p0[k + 0x70] = (-4 * pw) + 0x80;
146 } /* end of for (k=0; k<16; k++, p8++) */
147 } /* end of for (j=0; j<8; j++ , table++) */
148 } /* end of foreach compression_mode */
149 }
150
151 /*
152 *
153 */
154 static void fill_table_dc00_d800(struct pwc_dec23_private *pdec)
155 {
156 #define SCALEBITS 15
157 #define ONE_HALF (1UL << (SCALEBITS - 1))
158 int i;
159 unsigned int offset1 = ONE_HALF;
160 unsigned int offset2 = 0x0000;
161
162 for (i=0; i<256; i++) {
163 pdec->table_dc00[i] = offset1 & ~(ONE_HALF);
164 pdec->table_d800[i] = offset2;
165
166 offset1 += 0x7bc4;
167 offset2 += 0x7bc4;
168 }
169 }
170
171 /*
172 * To decode the stream:
173 * if look_bits(2) == 0: # op == 2 in the lookup table
174 * skip_bits(2)
175 * end of the stream
176 * elif look_bits(3) == 7: # op == 1 in the lookup table
177 * skip_bits(3)
178 * yyyy = get_bits(4)
179 * xxxx = get_bits(8)
180 * else: # op == 0 in the lookup table
181 * skip_bits(x)
182 *
183 * For speedup processing, we build a lookup table and we takes the first 6 bits.
184 *
185 * struct {
186 * unsigned char op; // operation to execute
187 * unsigned char bits; // bits use to perform operation
188 * unsigned char offset1; // offset to add to access in the table_0004 % 16
189 * unsigned char offset2; // offset to add to access in the table_0004
190 * }
191 *
192 * How to build this table ?
193 * op == 2 when (i%4)==0
194 * op == 1 when (i%8)==7
195 * op == 0 otherwise
196 *
197 */
198 static const unsigned char hash_table_ops[64*4] = {
199 0x02, 0x00, 0x00, 0x00,
200 0x00, 0x03, 0x01, 0x00,
201 0x00, 0x04, 0x01, 0x10,
202 0x00, 0x06, 0x01, 0x30,
203 0x02, 0x00, 0x00, 0x00,
204 0x00, 0x03, 0x01, 0x40,
205 0x00, 0x05, 0x01, 0x20,
206 0x01, 0x00, 0x00, 0x00,
207 0x02, 0x00, 0x00, 0x00,
208 0x00, 0x03, 0x01, 0x00,
209 0x00, 0x04, 0x01, 0x50,
210 0x00, 0x05, 0x02, 0x00,
211 0x02, 0x00, 0x00, 0x00,
212 0x00, 0x03, 0x01, 0x40,
213 0x00, 0x05, 0x03, 0x00,
214 0x01, 0x00, 0x00, 0x00,
215 0x02, 0x00, 0x00, 0x00,
216 0x00, 0x03, 0x01, 0x00,
217 0x00, 0x04, 0x01, 0x10,
218 0x00, 0x06, 0x02, 0x10,
219 0x02, 0x00, 0x00, 0x00,
220 0x00, 0x03, 0x01, 0x40,
221 0x00, 0x05, 0x01, 0x60,
222 0x01, 0x00, 0x00, 0x00,
223 0x02, 0x00, 0x00, 0x00,
224 0x00, 0x03, 0x01, 0x00,
225 0x00, 0x04, 0x01, 0x50,
226 0x00, 0x05, 0x02, 0x40,
227 0x02, 0x00, 0x00, 0x00,
228 0x00, 0x03, 0x01, 0x40,
229 0x00, 0x05, 0x03, 0x40,
230 0x01, 0x00, 0x00, 0x00,
231 0x02, 0x00, 0x00, 0x00,
232 0x00, 0x03, 0x01, 0x00,
233 0x00, 0x04, 0x01, 0x10,
234 0x00, 0x06, 0x01, 0x70,
235 0x02, 0x00, 0x00, 0x00,
236 0x00, 0x03, 0x01, 0x40,
237 0x00, 0x05, 0x01, 0x20,
238 0x01, 0x00, 0x00, 0x00,
239 0x02, 0x00, 0x00, 0x00,
240 0x00, 0x03, 0x01, 0x00,
241 0x00, 0x04, 0x01, 0x50,
242 0x00, 0x05, 0x02, 0x00,
243 0x02, 0x00, 0x00, 0x00,
244 0x00, 0x03, 0x01, 0x40,
245 0x00, 0x05, 0x03, 0x00,
246 0x01, 0x00, 0x00, 0x00,
247 0x02, 0x00, 0x00, 0x00,
248 0x00, 0x03, 0x01, 0x00,
249 0x00, 0x04, 0x01, 0x10,
250 0x00, 0x06, 0x02, 0x50,
251 0x02, 0x00, 0x00, 0x00,
252 0x00, 0x03, 0x01, 0x40,
253 0x00, 0x05, 0x01, 0x60,
254 0x01, 0x00, 0x00, 0x00,
255 0x02, 0x00, 0x00, 0x00,
256 0x00, 0x03, 0x01, 0x00,
257 0x00, 0x04, 0x01, 0x50,
258 0x00, 0x05, 0x02, 0x40,
259 0x02, 0x00, 0x00, 0x00,
260 0x00, 0x03, 0x01, 0x40,
261 0x00, 0x05, 0x03, 0x40,
262 0x01, 0x00, 0x00, 0x00
263 };
264
265 /*
266 *
267 */
268 static const unsigned int MulIdx[16][16] = {
269 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
270 {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,},
271 {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,},
272 {4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4,},
273 {6, 7, 8, 9, 7, 10, 11, 8, 8, 11, 10, 7, 9, 8, 7, 6,},
274 {4, 5, 5, 4, 4, 5, 5, 4, 4, 5, 5, 4, 4, 5, 5, 4,},
275 {1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2,},
276 {0, 3, 3, 0, 1, 2, 2, 1, 2, 1, 1, 2, 3, 0, 0, 3,},
277 {0, 1, 2, 3, 3, 2, 1, 0, 3, 2, 1, 0, 0, 1, 2, 3,},
278 {1, 1, 1, 1, 3, 3, 3, 3, 0, 0, 0, 0, 2, 2, 2, 2,},
279 {7, 10, 11, 8, 9, 8, 7, 6, 6, 7, 8, 9, 8, 11, 10, 7,},
280 {4, 5, 5, 4, 5, 4, 4, 5, 5, 4, 4, 5, 4, 5, 5, 4,},
281 {7, 9, 6, 8, 10, 8, 7, 11, 11, 7, 8, 10, 8, 6, 9, 7,},
282 {1, 3, 0, 2, 2, 0, 3, 1, 2, 0, 3, 1, 1, 3, 0, 2,},
283 {1, 2, 2, 1, 3, 0, 0, 3, 0, 3, 3, 0, 2, 1, 1, 2,},
284 {10, 8, 7, 11, 8, 6, 9, 7, 7, 9, 6, 8, 11, 7, 8, 10}
285 };
286
287 #if USE_LOOKUP_TABLE_TO_CLAMP
288 #define MAX_OUTER_CROP_VALUE (512)
289 static unsigned char pwc_crop_table[256 + 2*MAX_OUTER_CROP_VALUE];
290 #define CLAMP(x) (pwc_crop_table[MAX_OUTER_CROP_VALUE+(x)])
291 #else
292 #define CLAMP(x) ((x)>255?255:((x)<0?0:x))
293 #endif
294
295
296 /* If the type or the command change, we rebuild the lookup table */
297 void pwc_dec23_init(struct pwc_device *pdev, const unsigned char *cmd)
298 {
299 int flags, version, shift, i;
300 struct pwc_dec23_private *pdec = &pdev->dec23;
301
302 mutex_init(&pdec->lock);
303
304 if (pdec->last_cmd_valid && pdec->last_cmd == cmd[2])
305 return;
306
307 if (DEVICE_USE_CODEC3(pdev->type)) {
308 flags = cmd[2] & 0x18;
309 if (flags == 8)
310 pdec->nbits = 7; /* More bits, mean more bits to encode the stream, but better quality */
311 else if (flags == 0x10)
312 pdec->nbits = 8;
313 else
314 pdec->nbits = 6;
315
316 version = cmd[2] >> 5;
317 build_table_color(KiaraRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
318 build_table_color(KiaraRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
319
320 } else {
321
322 flags = cmd[2] & 6;
323 if (flags == 2)
324 pdec->nbits = 7;
325 else if (flags == 4)
326 pdec->nbits = 8;
327 else
328 pdec->nbits = 6;
329
330 version = cmd[2] >> 3;
331 build_table_color(TimonRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
332 build_table_color(TimonRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
333 }
334
335 /* Informations can be coded on a variable number of bits but never less than 8 */
336 shift = 8 - pdec->nbits;
337 pdec->scalebits = SCALEBITS - shift;
338 pdec->nbitsmask = 0xFF >> shift;
339
340 fill_table_dc00_d800(pdec);
341 build_subblock_pattern(pdec);
342 build_bit_powermask_table(pdec);
343
344 #if USE_LOOKUP_TABLE_TO_CLAMP
345 /* Build the static table to clamp value [0-255] */
346 for (i=0;i<MAX_OUTER_CROP_VALUE;i++)
347 pwc_crop_table[i] = 0;
348 for (i=0; i<256; i++)
349 pwc_crop_table[MAX_OUTER_CROP_VALUE+i] = i;
350 for (i=0; i<MAX_OUTER_CROP_VALUE; i++)
351 pwc_crop_table[MAX_OUTER_CROP_VALUE+256+i] = 255;
352 #endif
353
354 pdec->last_cmd = cmd[2];
355 pdec->last_cmd_valid = 1;
356 }
357
358 /*
359 * Copy the 4x4 image block to Y plane buffer
360 */
361 static void copy_image_block_Y(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
362 {
363 #if UNROLL_LOOP_FOR_COPY
364 const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
365 const int *c = src;
366 unsigned char *d = dst;
367
368 *d++ = cm[c[0] >> scalebits];
369 *d++ = cm[c[1] >> scalebits];
370 *d++ = cm[c[2] >> scalebits];
371 *d++ = cm[c[3] >> scalebits];
372
373 d = dst + bytes_per_line;
374 *d++ = cm[c[4] >> scalebits];
375 *d++ = cm[c[5] >> scalebits];
376 *d++ = cm[c[6] >> scalebits];
377 *d++ = cm[c[7] >> scalebits];
378
379 d = dst + bytes_per_line*2;
380 *d++ = cm[c[8] >> scalebits];
381 *d++ = cm[c[9] >> scalebits];
382 *d++ = cm[c[10] >> scalebits];
383 *d++ = cm[c[11] >> scalebits];
384
385 d = dst + bytes_per_line*3;
386 *d++ = cm[c[12] >> scalebits];
387 *d++ = cm[c[13] >> scalebits];
388 *d++ = cm[c[14] >> scalebits];
389 *d++ = cm[c[15] >> scalebits];
390 #else
391 int i;
392 const int *c = src;
393 unsigned char *d = dst;
394 for (i = 0; i < 4; i++, c++)
395 *d++ = CLAMP((*c) >> scalebits);
396
397 d = dst + bytes_per_line;
398 for (i = 0; i < 4; i++, c++)
399 *d++ = CLAMP((*c) >> scalebits);
400
401 d = dst + bytes_per_line*2;
402 for (i = 0; i < 4; i++, c++)
403 *d++ = CLAMP((*c) >> scalebits);
404
405 d = dst + bytes_per_line*3;
406 for (i = 0; i < 4; i++, c++)
407 *d++ = CLAMP((*c) >> scalebits);
408 #endif
409 }
410
411 /*
412 * Copy the 4x4 image block to a CrCb plane buffer
413 *
414 */
415 static void copy_image_block_CrCb(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
416 {
417 #if UNROLL_LOOP_FOR_COPY
418 /* Unroll all loops */
419 const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
420 const int *c = src;
421 unsigned char *d = dst;
422
423 *d++ = cm[c[0] >> scalebits];
424 *d++ = cm[c[4] >> scalebits];
425 *d++ = cm[c[1] >> scalebits];
426 *d++ = cm[c[5] >> scalebits];
427 *d++ = cm[c[2] >> scalebits];
428 *d++ = cm[c[6] >> scalebits];
429 *d++ = cm[c[3] >> scalebits];
430 *d++ = cm[c[7] >> scalebits];
431
432 d = dst + bytes_per_line;
433 *d++ = cm[c[12] >> scalebits];
434 *d++ = cm[c[8] >> scalebits];
435 *d++ = cm[c[13] >> scalebits];
436 *d++ = cm[c[9] >> scalebits];
437 *d++ = cm[c[14] >> scalebits];
438 *d++ = cm[c[10] >> scalebits];
439 *d++ = cm[c[15] >> scalebits];
440 *d++ = cm[c[11] >> scalebits];
441 #else
442 int i;
443 const int *c1 = src;
444 const int *c2 = src + 4;
445 unsigned char *d = dst;
446
447 for (i = 0; i < 4; i++, c1++, c2++) {
448 *d++ = CLAMP((*c1) >> scalebits);
449 *d++ = CLAMP((*c2) >> scalebits);
450 }
451 c1 = src + 12;
452 d = dst + bytes_per_line;
453 for (i = 0; i < 4; i++, c1++, c2++) {
454 *d++ = CLAMP((*c1) >> scalebits);
455 *d++ = CLAMP((*c2) >> scalebits);
456 }
457 #endif
458 }
459
460 /*
461 * To manage the stream, we keep bits in a 32 bits register.
462 * fill_nbits(n): fill the reservoir with at least n bits
463 * skip_bits(n): discard n bits from the reservoir
464 * get_bits(n): fill the reservoir, returns the first n bits and discard the
465 * bits from the reservoir.
466 * __get_nbits(n): faster version of get_bits(n), but asumes that the reservoir
467 * contains at least n bits. bits returned is discarded.
468 */
469 #define fill_nbits(pdec, nbits_wanted) do { \
470 while (pdec->nbits_in_reservoir<(nbits_wanted)) \
471 { \
472 pdec->reservoir |= (*(pdec->stream)++) << (pdec->nbits_in_reservoir); \
473 pdec->nbits_in_reservoir += 8; \
474 } \
475 } while(0);
476
477 #define skip_nbits(pdec, nbits_to_skip) do { \
478 pdec->reservoir >>= (nbits_to_skip); \
479 pdec->nbits_in_reservoir -= (nbits_to_skip); \
480 } while(0);
481
482 #define get_nbits(pdec, nbits_wanted, result) do { \
483 fill_nbits(pdec, nbits_wanted); \
484 result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
485 skip_nbits(pdec, nbits_wanted); \
486 } while(0);
487
488 #define __get_nbits(pdec, nbits_wanted, result) do { \
489 result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
490 skip_nbits(pdec, nbits_wanted); \
491 } while(0);
492
493 #define look_nbits(pdec, nbits_wanted) \
494 ((pdec->reservoir) & ((1U<<(nbits_wanted))-1))
495
496 /*
497 * Decode a 4x4 pixel block
498 */
499 static void decode_block(struct pwc_dec23_private *pdec,
500 const unsigned char *ptable0004,
501 const unsigned char *ptable8004)
502 {
503 unsigned int primary_color;
504 unsigned int channel_v, offset1, op;
505 int i;
506
507 fill_nbits(pdec, 16);
508 __get_nbits(pdec, pdec->nbits, primary_color);
509
510 if (look_nbits(pdec,2) == 0) {
511 skip_nbits(pdec, 2);
512 /* Very simple, the color is the same for all pixels of the square */
513 for (i = 0; i < 16; i++)
514 pdec->temp_colors[i] = pdec->table_dc00[primary_color];
515
516 return;
517 }
518
519 /* This block is encoded with small pattern */
520 for (i = 0; i < 16; i++)
521 pdec->temp_colors[i] = pdec->table_d800[primary_color];
522
523 __get_nbits(pdec, 3, channel_v);
524 channel_v = ((channel_v & 1) << 2) | (channel_v & 2) | ((channel_v & 4) >> 2);
525
526 ptable0004 += (channel_v * 128);
527 ptable8004 += (channel_v * 32);
528
529 offset1 = 0;
530 do
531 {
532 unsigned int htable_idx, rows = 0;
533 const unsigned int *block;
534
535 /* [ zzzz y x x ]
536 * xx == 00 :=> end of the block def, remove the two bits from the stream
537 * yxx == 111
538 * yxx == any other value
539 *
540 */
541 fill_nbits(pdec, 16);
542 htable_idx = look_nbits(pdec, 6);
543 op = hash_table_ops[htable_idx * 4];
544
545 if (op == 2) {
546 skip_nbits(pdec, 2);
547
548 } else if (op == 1) {
549 /* 15bits [ xxxx xxxx yyyy 111 ]
550 * yyy => offset in the table8004
551 * xxx => offset in the tabled004 (tree)
552 */
553 unsigned int mask, shift;
554 unsigned int nbits, col1;
555 unsigned int yyyy;
556
557 skip_nbits(pdec, 3);
558 /* offset1 += yyyy */
559 __get_nbits(pdec, 4, yyyy);
560 offset1 += 1 + yyyy;
561 offset1 &= 0x0F;
562 nbits = ptable8004[offset1 * 2];
563
564 /* col1 = xxxx xxxx */
565 __get_nbits(pdec, nbits+1, col1);
566
567 /* Bit mask table */
568 mask = pdec->table_bitpowermask[nbits][col1];
569 shift = ptable8004[offset1 * 2 + 1];
570 rows = ((mask << shift) + 0x80) & 0xFF;
571
572 block = pdec->table_subblock[rows];
573 for (i = 0; i < 16; i++)
574 pdec->temp_colors[i] += block[MulIdx[offset1][i]];
575
576 } else {
577 /* op == 0
578 * offset1 is coded on 3 bits
579 */
580 unsigned int shift;
581
582 offset1 += hash_table_ops [htable_idx * 4 + 2];
583 offset1 &= 0x0F;
584
585 rows = ptable0004[offset1 + hash_table_ops [htable_idx * 4 + 3]];
586 block = pdec->table_subblock[rows];
587 for (i = 0; i < 16; i++)
588 pdec->temp_colors[i] += block[MulIdx[offset1][i]];
589
590 shift = hash_table_ops[htable_idx * 4 + 1];
591 skip_nbits(pdec, shift);
592 }
593
594 } while (op != 2);
595
596 }
597
598 static void DecompressBand23(struct pwc_dec23_private *pdec,
599 const unsigned char *rawyuv,
600 unsigned char *planar_y,
601 unsigned char *planar_u,
602 unsigned char *planar_v,
603 unsigned int compressed_image_width,
604 unsigned int real_image_width)
605 {
606 int compression_index, nblocks;
607 const unsigned char *ptable0004;
608 const unsigned char *ptable8004;
609
610 pdec->reservoir = 0;
611 pdec->nbits_in_reservoir = 0;
612 pdec->stream = rawyuv + 1; /* The first byte of the stream is skipped */
613
614 get_nbits(pdec, 4, compression_index);
615
616 /* pass 1: uncompress Y component */
617 nblocks = compressed_image_width / 4;
618
619 ptable0004 = pdec->table_0004_pass1[compression_index];
620 ptable8004 = pdec->table_8004_pass1[compression_index];
621
622 /* Each block decode a square of 4x4 */
623 while (nblocks) {
624 decode_block(pdec, ptable0004, ptable8004);
625 copy_image_block_Y(pdec->temp_colors, planar_y, real_image_width, pdec->scalebits);
626 planar_y += 4;
627 nblocks--;
628 }
629
630 /* pass 2: uncompress UV component */
631 nblocks = compressed_image_width / 8;
632
633 ptable0004 = pdec->table_0004_pass2[compression_index];
634 ptable8004 = pdec->table_8004_pass2[compression_index];
635
636 /* Each block decode a square of 4x4 */
637 while (nblocks) {
638 decode_block(pdec, ptable0004, ptable8004);
639 copy_image_block_CrCb(pdec->temp_colors, planar_u, real_image_width/2, pdec->scalebits);
640
641 decode_block(pdec, ptable0004, ptable8004);
642 copy_image_block_CrCb(pdec->temp_colors, planar_v, real_image_width/2, pdec->scalebits);
643
644 planar_v += 8;
645 planar_u += 8;
646 nblocks -= 2;
647 }
648
649 }
650
651 /**
652 *
653 * Uncompress a pwc23 buffer.
654 *
655 * src: raw data
656 * dst: image output
657 */
658 void pwc_dec23_decompress(struct pwc_device *pdev,
659 const void *src,
660 void *dst)
661 {
662 int bandlines_left, bytes_per_block;
663 struct pwc_dec23_private *pdec = &pdev->dec23;
664
665 /* YUV420P image format */
666 unsigned char *pout_planar_y;
667 unsigned char *pout_planar_u;
668 unsigned char *pout_planar_v;
669 unsigned int plane_size;
670
671 mutex_lock(&pdec->lock);
672
673 bandlines_left = pdev->height / 4;
674 bytes_per_block = pdev->width * 4;
675 plane_size = pdev->height * pdev->width;
676
677 pout_planar_y = dst;
678 pout_planar_u = dst + plane_size;
679 pout_planar_v = dst + plane_size + plane_size / 4;
680
681 while (bandlines_left--) {
682 DecompressBand23(pdec, src,
683 pout_planar_y, pout_planar_u, pout_planar_v,
684 pdev->width, pdev->width);
685 src += pdev->vbandlength;
686 pout_planar_y += bytes_per_block;
687 pout_planar_u += pdev->width;
688 pout_planar_v += pdev->width;
689 }
690 mutex_unlock(&pdec->lock);
691 }