drivers/media/video/pwc/pwc-dec23.c

   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 int pwc_dec23_init(struct pwc_device *pwc, int type, unsigned char *cmd)
 298 {
 299         int flags, version, shift, i;
 300         struct pwc_dec23_private *pdec;
 301
 302         if (pwc->decompress_data == NULL) {
 303                 pdec = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);
 304                 if (pdec == NULL)
 305                         return -ENOMEM;
 306                 pwc->decompress_data = pdec;
 307         }
 308         pdec = pwc->decompress_data;
 309
 310         mutex_init(&pdec->lock);
 311
 312         if (DEVICE_USE_CODEC3(type)) {
 313                 flags = cmd[2] & 0x18;
 314                 if (flags == 8)
 315                         pdec->nbits = 7;        /* More bits, mean more bits to encode the stream, but better quality */
 316                 else if (flags == 0x10)
 317                         pdec->nbits = 8;
 318                 else
 319                         pdec->nbits = 6;
 320
 321                 version = cmd[2] >> 5;
 322                 build_table_color(KiaraRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
 323                 build_table_color(KiaraRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
 324
 325         } else {
 326
 327                 flags = cmd[2] & 6;
 328                 if (flags == 2)
 329                         pdec->nbits = 7;
 330                 else if (flags == 4)
 331                         pdec->nbits = 8;
 332                 else
 333                         pdec->nbits = 6;
 334
 335                 version = cmd[2] >> 3;
 336                 build_table_color(TimonRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
 337                 build_table_color(TimonRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
 338         }
 339
 340         /* Informations can be coded on a variable number of bits but never less than 8 */
 341         shift = 8 - pdec->nbits;
 342         pdec->scalebits = SCALEBITS - shift;
 343         pdec->nbitsmask = 0xFF >> shift;
 344
 345         fill_table_dc00_d800(pdec);
 346         build_subblock_pattern(pdec);
 347         build_bit_powermask_table(pdec);
 348
 349 #if USE_LOOKUP_TABLE_TO_CLAMP
 350         /* Build the static table to clamp value [0-255] */
 351         for (i=0;i<MAX_OUTER_CROP_VALUE;i++)
 352                 pwc_crop_table[i] = 0;
 353         for (i=0; i<256; i++)
 354                 pwc_crop_table[MAX_OUTER_CROP_VALUE+i] = i;
 355         for (i=0; i<MAX_OUTER_CROP_VALUE; i++)
 356                 pwc_crop_table[MAX_OUTER_CROP_VALUE+256+i] = 255;
 357 #endif
 358
 359         return 0;
 360 }
 361
 362 /*
 363  * Copy the 4x4 image block to Y plane buffer
 364  */
 365 static void copy_image_block_Y(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
 366 {
 367 #if UNROLL_LOOP_FOR_COPY
 368         const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
 369         const int *c = src;
 370         unsigned char *d = dst;
 371
 372         *d++ = cm[c[0] >> scalebits];
 373         *d++ = cm[c[1] >> scalebits];
 374         *d++ = cm[c[2] >> scalebits];
 375         *d++ = cm[c[3] >> scalebits];
 376
 377         d = dst + bytes_per_line;
 378         *d++ = cm[c[4] >> scalebits];
 379         *d++ = cm[c[5] >> scalebits];
 380         *d++ = cm[c[6] >> scalebits];
 381         *d++ = cm[c[7] >> scalebits];
 382
 383         d = dst + bytes_per_line*2;
 384         *d++ = cm[c[8] >> scalebits];
 385         *d++ = cm[c[9] >> scalebits];
 386         *d++ = cm[c[10] >> scalebits];
 387         *d++ = cm[c[11] >> scalebits];
 388
 389         d = dst + bytes_per_line*3;
 390         *d++ = cm[c[12] >> scalebits];
 391         *d++ = cm[c[13] >> scalebits];
 392         *d++ = cm[c[14] >> scalebits];
 393         *d++ = cm[c[15] >> scalebits];
 394 #else
 395         int i;
 396         const int *c = src;
 397         unsigned char *d = dst;
 398         for (i = 0; i < 4; i++, c++)
 399                 *d++ = CLAMP((*c) >> scalebits);
 400
 401         d = dst + bytes_per_line;
 402         for (i = 0; i < 4; i++, c++)
 403                 *d++ = CLAMP((*c) >> scalebits);
 404
 405         d = dst + bytes_per_line*2;
 406         for (i = 0; i < 4; i++, c++)
 407                 *d++ = CLAMP((*c) >> scalebits);
 408
 409         d = dst + bytes_per_line*3;
 410         for (i = 0; i < 4; i++, c++)
 411                 *d++ = CLAMP((*c) >> scalebits);
 412 #endif
 413 }
 414
 415 /*
 416  * Copy the 4x4 image block to a CrCb plane buffer
 417  *
 418  */
 419 static void copy_image_block_CrCb(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
 420 {
 421 #if UNROLL_LOOP_FOR_COPY
 422         /* Unroll all loops */
 423         const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
 424         const int *c = src;
 425         unsigned char *d = dst;
 426
 427         *d++ = cm[c[0] >> scalebits];
 428         *d++ = cm[c[4] >> scalebits];
 429         *d++ = cm[c[1] >> scalebits];
 430         *d++ = cm[c[5] >> scalebits];
 431         *d++ = cm[c[2] >> scalebits];
 432         *d++ = cm[c[6] >> scalebits];
 433         *d++ = cm[c[3] >> scalebits];
 434         *d++ = cm[c[7] >> scalebits];
 435
 436         d = dst + bytes_per_line;
 437         *d++ = cm[c[12] >> scalebits];
 438         *d++ = cm[c[8] >> scalebits];
 439         *d++ = cm[c[13] >> scalebits];
 440         *d++ = cm[c[9] >> scalebits];
 441         *d++ = cm[c[14] >> scalebits];
 442         *d++ = cm[c[10] >> scalebits];
 443         *d++ = cm[c[15] >> scalebits];
 444         *d++ = cm[c[11] >> scalebits];
 445 #else
 446         int i;
 447         const int *c1 = src;
 448         const int *c2 = src + 4;
 449         unsigned char *d = dst;
 450
 451         for (i = 0; i < 4; i++, c1++, c2++) {
 452                 *d++ = CLAMP((*c1) >> scalebits);
 453                 *d++ = CLAMP((*c2) >> scalebits);
 454         }
 455         c1 = src + 12;
 456         d = dst + bytes_per_line;
 457         for (i = 0; i < 4; i++, c1++, c2++) {
 458                 *d++ = CLAMP((*c1) >> scalebits);
 459                 *d++ = CLAMP((*c2) >> scalebits);
 460         }
 461 #endif
 462 }
 463
 464 /*
 465  * To manage the stream, we keep bits in a 32 bits register.
 466  * fill_nbits(n): fill the reservoir with at least n bits
 467  * skip_bits(n): discard n bits from the reservoir
 468  * get_bits(n): fill the reservoir, returns the first n bits and discard the
 469  *              bits from the reservoir.
 470  * __get_nbits(n): faster version of get_bits(n), but asumes that the reservoir
 471  *                 contains at least n bits. bits returned is discarded.
 472  */
 473 #define fill_nbits(pdec, nbits_wanted) do { \
 474    while (pdec->nbits_in_reservoir<(nbits_wanted)) \
 475     { \
 476       pdec->reservoir |= (*(pdec->stream)++) << (pdec->nbits_in_reservoir); \
 477       pdec->nbits_in_reservoir += 8; \
 478     } \
 479 }  while(0);
 480
 481 #define skip_nbits(pdec, nbits_to_skip) do { \
 482    pdec->reservoir >>= (nbits_to_skip); \
 483    pdec->nbits_in_reservoir -= (nbits_to_skip); \
 484 }  while(0);
 485
 486 #define get_nbits(pdec, nbits_wanted, result) do { \
 487    fill_nbits(pdec, nbits_wanted); \
 488    result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
 489    skip_nbits(pdec, nbits_wanted); \
 490 }  while(0);
 491
 492 #define __get_nbits(pdec, nbits_wanted, result) do { \
 493    result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
 494    skip_nbits(pdec, nbits_wanted); \
 495 }  while(0);
 496
 497 #define look_nbits(pdec, nbits_wanted) \
 498    ((pdec->reservoir) & ((1U<<(nbits_wanted))-1))
 499
 500 /*
 501  * Decode a 4x4 pixel block
 502  */
 503 static void decode_block(struct pwc_dec23_private *pdec,
 504                          const unsigned char *ptable0004,
 505                          const unsigned char *ptable8004)
 506 {
 507         unsigned int primary_color;
 508         unsigned int channel_v, offset1, op;
 509         int i;
 510
 511         fill_nbits(pdec, 16);
 512         __get_nbits(pdec, pdec->nbits, primary_color);
 513
 514         if (look_nbits(pdec,2) == 0) {
 515                 skip_nbits(pdec, 2);
 516                 /* Very simple, the color is the same for all pixels of the square */
 517                 for (i = 0; i < 16; i++)
 518                         pdec->temp_colors[i] = pdec->table_dc00[primary_color];
 519
 520                 return;
 521         }
 522
 523         /* This block is encoded with small pattern */
 524         for (i = 0; i < 16; i++)
 525                 pdec->temp_colors[i] = pdec->table_d800[primary_color];
 526
 527         __get_nbits(pdec, 3, channel_v);
 528         channel_v = ((channel_v & 1) << 2) | (channel_v & 2) | ((channel_v & 4) >> 2);
 529
 530         ptable0004 += (channel_v * 128);
 531         ptable8004 += (channel_v * 32);
 532
 533         offset1 = 0;
 534         do
 535         {
 536                 unsigned int htable_idx, rows = 0;
 537                 const unsigned int *block;
 538
 539                 /* [  zzzz y x x ]
 540                  *     xx == 00 :=> end of the block def, remove the two bits from the stream
 541                  *    yxx == 111
 542                  *    yxx == any other value
 543                  *
 544                  */
 545                 fill_nbits(pdec, 16);
 546                 htable_idx = look_nbits(pdec, 6);
 547                 op = hash_table_ops[htable_idx * 4];
 548
 549                 if (op == 2) {
 550                         skip_nbits(pdec, 2);
 551
 552                 } else if (op == 1) {
 553                         /* 15bits [ xxxx xxxx yyyy 111 ]
 554                          * yyy => offset in the table8004
 555                          * xxx => offset in the tabled004 (tree)
 556                          */
 557                         unsigned int mask, shift;
 558                         unsigned int nbits, col1;
 559                         unsigned int yyyy;
 560
 561                         skip_nbits(pdec, 3);
 562                         /* offset1 += yyyy */
 563                         __get_nbits(pdec, 4, yyyy);
 564                         offset1 += 1 + yyyy;
 565                         offset1 &= 0x0F;
 566                         nbits = ptable8004[offset1 * 2];
 567
 568                         /* col1 = xxxx xxxx */
 569                         __get_nbits(pdec, nbits+1, col1);
 570
 571                         /* Bit mask table */
 572                         mask = pdec->table_bitpowermask[nbits][col1];
 573                         shift = ptable8004[offset1 * 2 + 1];
 574                         rows = ((mask << shift) + 0x80) & 0xFF;
 575
 576                         block = pdec->table_subblock[rows];
 577                         for (i = 0; i < 16; i++)
 578                                 pdec->temp_colors[i] += block[MulIdx[offset1][i]];
 579
 580                 } else {
 581                         /* op == 0
 582                          * offset1 is coded on 3 bits
 583                          */
 584                         unsigned int shift;
 585
 586                         offset1 += hash_table_ops [htable_idx * 4 + 2];
 587                         offset1 &= 0x0F;
 588
 589                         rows = ptable0004[offset1 + hash_table_ops [htable_idx * 4 + 3]];
 590                         block = pdec->table_subblock[rows];
 591                         for (i = 0; i < 16; i++)
 592                                 pdec->temp_colors[i] += block[MulIdx[offset1][i]];
 593
 594                         shift = hash_table_ops[htable_idx * 4 + 1];
 595                         skip_nbits(pdec, shift);
 596                 }
 597
 598         } while (op != 2);
 599
 600 }
 601
 602 static void DecompressBand23(struct pwc_dec23_private *pdec,
 603                              const unsigned char *rawyuv,
 604                              unsigned char *planar_y,
 605                              unsigned char *planar_u,
 606                              unsigned char *planar_v,
 607                              unsigned int   compressed_image_width,
 608                              unsigned int   real_image_width)
 609 {
 610         int compression_index, nblocks;
 611         const unsigned char *ptable0004;
 612         const unsigned char *ptable8004;
 613
 614         pdec->reservoir = 0;
 615         pdec->nbits_in_reservoir = 0;
 616         pdec->stream = rawyuv + 1;      /* The first byte of the stream is skipped */
 617
 618         get_nbits(pdec, 4, compression_index);
 619
 620         /* pass 1: uncompress Y component */
 621         nblocks = compressed_image_width / 4;
 622
 623         ptable0004 = pdec->table_0004_pass1[compression_index];
 624         ptable8004 = pdec->table_8004_pass1[compression_index];
 625
 626         /* Each block decode a square of 4x4 */
 627         while (nblocks) {
 628                 decode_block(pdec, ptable0004, ptable8004);
 629                 copy_image_block_Y(pdec->temp_colors, planar_y, real_image_width, pdec->scalebits);
 630                 planar_y += 4;
 631                 nblocks--;
 632         }
 633
 634         /* pass 2: uncompress UV component */
 635         nblocks = compressed_image_width / 8;
 636
 637         ptable0004 = pdec->table_0004_pass2[compression_index];
 638         ptable8004 = pdec->table_8004_pass2[compression_index];
 639
 640         /* Each block decode a square of 4x4 */
 641         while (nblocks) {
 642                 decode_block(pdec, ptable0004, ptable8004);
 643                 copy_image_block_CrCb(pdec->temp_colors, planar_u, real_image_width/2, pdec->scalebits);
 644
 645                 decode_block(pdec, ptable0004, ptable8004);
 646                 copy_image_block_CrCb(pdec->temp_colors, planar_v, real_image_width/2, pdec->scalebits);
 647
 648                 planar_v += 8;
 649                 planar_u += 8;
 650                 nblocks -= 2;
 651         }
 652
 653 }
 654
 655 /**
 656  *
 657  * Uncompress a pwc23 buffer.
 658  *
 659  * src: raw data
 660  * dst: image output
 661  */
 662 void pwc_dec23_decompress(const struct pwc_device *pwc,
 663                           const void *src,
 664                           void *dst)
 665 {
 666         int bandlines_left, bytes_per_block;
 667         struct pwc_dec23_private *pdec = pwc->decompress_data;
 668
 669         /* YUV420P image format */
 670         unsigned char *pout_planar_y;
 671         unsigned char *pout_planar_u;
 672         unsigned char *pout_planar_v;
 673         unsigned int   plane_size;
 674
 675         mutex_lock(&pdec->lock);
 676
 677         bandlines_left = pwc->height / 4;
 678         bytes_per_block = pwc->width * 4;
 679         plane_size = pwc->height * pwc->width;
 680
 681         pout_planar_y = dst;
 682         pout_planar_u = dst + plane_size;
 683         pout_planar_v = dst + plane_size + plane_size / 4;
 684
 685         while (bandlines_left--) {
 686                 DecompressBand23(pwc->decompress_data,
 687                                  src,
 688                                  pout_planar_y, pout_planar_u, pout_planar_v,
 689                                  pwc->width, pwc->width);
 690                 src += pwc->vbandlength;
 691                 pout_planar_y += bytes_per_block;
 692                 pout_planar_u += pwc->width;
 693                 pout_planar_v += pwc->width;
 694         }
 695         mutex_unlock(&pdec->lock);
 696 }