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

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