home *** CD-ROM | disk | FTP | other *** search
/ hobbes.nmsu.edu 2008 / 2008-06-02_hobbes.nmsu.edu.zip / new / scummc-0.2.0-os2.zip / ScummC / src / decode.c < prev    next >
Encoding:
C/C++ Source or Header  |  2007-12-18  |  10.7 KB  |  514 lines
  1. /* ScummC
  2.  * Copyright (C) 2004-2006  Alban Bedel
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17.  *
  18.  */
  19.  
  20. /**
  21.  * @file decode.c
  22.  * @ingroup scumm
  23.  * @brief SCUMM image decoders
  24.  */
  25.  
  26. #include "config.h"
  27.  
  28. #include <inttypes.h>
  29. #include <stdlib.h>
  30. #include <unistd.h>
  31. #include <stdio.h>
  32. #include <errno.h>
  33. #include <string.h>
  34.  
  35. #include "scc_fd.h"
  36. #include "scc_util.h"
  37.  
  38. #define READ_BIT (cl--, bit = bits&1, bits>>=1, bit)
  39. #define FILL_BITS if(cl < 8) { \
  40.   bits |= (*src++) << cl; \
  41.   cl += 8; \
  42. } 
  43.  
  44.  
  45. static void unkDecodeA(uint8_t *dst, int dst_stride,
  46.                uint8_t *src, int height,
  47.                uint32_t palette_mod,
  48.                uint32_t decomp_mask,uint32_t decomp_shr) {
  49.   uint8_t color = *src++;
  50.   uint32_t bits = *src++;
  51.   uint8_t cl = 8;
  52.   uint8_t bit;
  53.   int16_t incm, reps;
  54.  
  55.   //  printf("Start data: %x %x %x %x\n",color,bits,src[0],src[1]);
  56.   
  57.   do {
  58.     int x = 8;
  59.     do {
  60.       FILL_BITS;
  61.       *dst++ = color + palette_mod;
  62.       
  63.     againPos:
  64.       if (!READ_BIT) {
  65.       } else if (!READ_BIT) {
  66.     FILL_BITS;
  67.     color = bits & decomp_mask;
  68.     bits >>= decomp_shr;
  69.     cl -= decomp_shr;
  70.       } else {
  71.     incm = (bits & 7) - 4;
  72.     cl -= 3;
  73.     bits >>= 3;
  74.     if (incm) {
  75.       color += incm;
  76.     } else {
  77.       FILL_BITS;
  78.       reps = bits & 0xFF;
  79.       do {
  80.         if (!--x) {
  81.           x = 8;
  82.           dst += dst_stride - 8;
  83.           if (!--height)
  84.         return;
  85.         }
  86.         *dst++ = color + palette_mod;
  87.       } while (--reps);
  88.       bits >>= 8;
  89.       bits |= (*src++) << (cl - 8);
  90.       goto againPos;
  91.     }
  92.       }
  93.       x--;
  94.     } while (x);
  95.     dst += dst_stride - 8;
  96.     height--;
  97.   } while (height);
  98. }
  99.  
  100.  
  101. static void unkDecodeA_trans(uint8_t *dst, int dst_stride,
  102.                  uint8_t *src, int height,
  103.                  uint32_t palette_mod,uint8_t transparentColor,
  104.                  uint32_t decomp_mask,uint32_t decomp_shr) {
  105.   uint8_t color = *src++;
  106.   uint32_t bits = *src++;
  107.   uint8_t cl = 8;
  108.   uint8_t bit;
  109.   uint8_t incm, reps;
  110.  
  111.   do {
  112.     int x = 8;
  113.     do {
  114.       FILL_BITS;
  115.       if (color != transparentColor)
  116.     *dst = color + palette_mod;
  117.       dst++;
  118.       
  119.     againPos:
  120.       if (!READ_BIT) {
  121.       } else if (!READ_BIT) {
  122.     FILL_BITS;
  123.     color = bits & decomp_mask;
  124.     bits >>= decomp_shr;
  125.     cl -= decomp_shr;
  126.       } else {
  127.     incm = (bits & 7) - 4;
  128.     cl -= 3;
  129.     bits >>= 3;
  130.     if (incm) {
  131.       color += incm;
  132.     } else {
  133.       FILL_BITS;
  134.       reps = bits & 0xFF;
  135.       do {
  136.         if (!--x) {
  137.           x = 8;
  138.           dst += dst_stride - 8;
  139.           if (!--height)
  140.         return;
  141.         }
  142.         if (color != transparentColor)
  143.           *dst = color + palette_mod;
  144.         dst++;
  145.       } while (--reps);
  146.       bits >>= 8;
  147.       bits |= (*src++) << (cl - 8);
  148.       goto againPos;
  149.     }
  150.       }
  151.     } while (--x);
  152.     dst += dst_stride - 8;
  153.   } while (--height);
  154. }
  155.  
  156. void unkDecodeB(uint8_t *dst, int dst_stride,
  157.         uint8_t *src, int height,
  158.         uint32_t palette_mod,
  159.         uint32_t decomp_mask,uint32_t decomp_shr) {
  160.   uint8_t color = *src++;
  161.   uint32_t bits = *src++;
  162.   uint8_t cl = 8;
  163.   uint8_t bit;
  164.   int8_t inc = -1;
  165.   
  166.   do {
  167.     int x = 8;
  168.     do {
  169.       FILL_BITS;
  170.       *dst++ = color + palette_mod;
  171.       if (!READ_BIT) {
  172.       } else if (!READ_BIT) {
  173.     FILL_BITS;
  174.     color = bits & decomp_mask;
  175.     bits >>= decomp_shr;
  176.     cl -= decomp_shr;
  177.     inc = -1;
  178.       } else if (!READ_BIT) {
  179.     color += inc;
  180.       } else {
  181.     inc = -inc;
  182.     color += inc;
  183.       }
  184.     } while (--x);
  185.     dst += dst_stride - 8;
  186.   } while (--height);
  187. }
  188.  
  189. void unkDecodeB_trans(uint8_t *dst, int dst_stride,
  190.               uint8_t *src, int height,
  191.               uint32_t palette_mod,uint8_t transparentColor,
  192.               uint32_t decomp_mask,uint32_t decomp_shr) {
  193.   uint8_t color = *src++;
  194.   uint32_t bits = *src++;
  195.   uint8_t cl = 8;
  196.   uint8_t bit;
  197.   int8_t inc = -1;
  198.  
  199.   do {
  200.     int x = 8;
  201.     do {
  202.       FILL_BITS;
  203.       if (color != transparentColor)
  204.     *dst = color + palette_mod;
  205.       dst++;
  206.       if (!READ_BIT) {
  207.       } else if (!READ_BIT) {
  208.     FILL_BITS;
  209.     color = bits & decomp_mask;
  210.     bits >>= decomp_shr;
  211.     cl -= decomp_shr;
  212.     inc = -1;
  213.       } else if (!READ_BIT) {
  214.     color += inc;
  215.       } else {
  216.     inc = -inc;
  217.     color += inc;
  218.       }
  219.     } while (--x);
  220.     dst += dst_stride - 8;
  221.   } while (--height);
  222. }
  223.  
  224. void unkDecodeC(uint8_t *dst, int dst_stride,
  225.         uint8_t *src, int height,
  226.         uint32_t palette_mod,
  227.         uint32_t decomp_mask,uint32_t decomp_shr) {
  228.   uint8_t color = *src++;
  229.   uint32_t bits = *src++;
  230.   uint8_t cl = 8;
  231.   uint8_t bit;
  232.   int8_t inc = -1;
  233.   
  234.   int x = 8;
  235.   do {
  236.     int h = height;
  237.     do {
  238.       FILL_BITS;
  239.       *dst = color + palette_mod;
  240.       dst += dst_stride;
  241.       if (!READ_BIT) {
  242.       } else if (!READ_BIT) {
  243.     FILL_BITS;
  244.     color = bits & decomp_mask;
  245.     bits >>= decomp_shr;
  246.     cl -= decomp_shr;
  247.     inc = -1;
  248.       } else if (!READ_BIT) {
  249.     color += inc;
  250.       } else {
  251.     inc = -inc;
  252.     color += inc;
  253.       }
  254.     } while (--h);
  255.     dst -= height*dst_stride - 1;
  256.   } while (--x);
  257. }
  258.  
  259. void unkDecodeC_trans(uint8_t *dst, int dst_stride,
  260.                  uint8_t *src, int height,
  261.                  uint32_t palette_mod,uint8_t transparentColor,
  262.                  uint32_t decomp_mask,uint32_t decomp_shr) {
  263.   uint8_t color = *src++;
  264.   uint32_t bits = *src++;
  265.   uint8_t cl = 8;
  266.   uint8_t bit;
  267.   int8_t inc = -1;
  268.  
  269.   int x = 8;
  270.   do {
  271.     int h = height;
  272.     do {
  273.       FILL_BITS;
  274.       if (color != transparentColor)
  275.     *dst = color + palette_mod;
  276.       dst += dst_stride;
  277.       if (!READ_BIT) {
  278.       } else if (!READ_BIT) {
  279.     FILL_BITS;
  280.     color = bits & decomp_mask;
  281.     bits >>= decomp_shr;
  282.     cl -= decomp_shr;
  283.     inc = -1;
  284.       } else if (!READ_BIT) {
  285.     color += inc;
  286.       } else {
  287.     inc = -inc;
  288.     color += inc;
  289.       }
  290.     } while (--h);
  291.     dst -= height*dst_stride - 1;
  292.   } while (--x);
  293. }
  294.  
  295.  
  296. int scc_decode_image(uint8_t* dst, int dst_stride,
  297.              int width,int height,
  298.              uint8_t* smap,uint32_t smap_size,
  299.              int transparentColor) {
  300.   int i,offs = (width/8);
  301.   uint8_t type;
  302.   uint32_t decomp_shr,decomp_mask;
  303.   int stripe_size;
  304.   int have_trans = 0;
  305.  
  306.   scc_log(LOG_V,"\nDecode image: %dx%d smap: %d\n",width,height,smap_size);
  307.  
  308.   for(i = 0 ; i < offs ; i++) {
  309.     int o = ((uint32_t*)smap)[i]-8;
  310.     if(i+1 < offs)
  311.       stripe_size = ((uint32_t*)smap)[i+1] - ((uint32_t*)smap)[i];
  312.     else
  313.       stripe_size = smap_size-o;
  314.     stripe_size -= 1;
  315.     //scc_log(LOG_V,"Stripe %d: 0x%x\n",i,o);
  316.     type = smap[o];
  317.     scc_log(LOG_V,"SMAP type: %d (0x%x)\n",type,type);
  318.     decomp_shr = type % 10;
  319.     decomp_mask = 0xFF >> (8 - decomp_shr);
  320.  
  321.     scc_log(LOG_V,"Decomp_shr: %d (0x%x)\n",decomp_shr,decomp_mask);
  322.  
  323.     switch(type) {
  324.     case 14:
  325.     case 15:
  326.     case 16:
  327.     case 17:
  328.     case 18:
  329.       unkDecodeC(dst + i*8,dst_stride,&smap[o+1],
  330.          height,0,
  331.          decomp_mask,decomp_shr);
  332.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeC,unkDecodeC);
  333.       break;
  334.  
  335.     case 24:
  336.     case 25:
  337.     case 26:
  338.     case 27:
  339.     case 28:
  340.       unkDecodeB(dst + i*8,dst_stride,&smap[o+1],
  341.          height,0,
  342.          decomp_mask,decomp_shr);
  343.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeB,unkDecodeB);
  344.       break;
  345.  
  346.     case 34:
  347.     case 35:
  348.     case 36:
  349.     case 37:
  350.     case 38:
  351.       have_trans = 1;
  352.       if(transparentColor < 0)
  353.     unkDecodeC(dst + i*8,dst_stride,&smap[o+1],
  354.            height,0,
  355.            decomp_mask,decomp_shr);
  356.       else
  357.     unkDecodeC_trans(dst + i*8,dst_stride,&smap[o+1],
  358.              height,0,transparentColor,
  359.              decomp_mask,decomp_shr);
  360.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeC,unkDecodeC);
  361.       break;
  362.  
  363.     case 44:
  364.     case 45:
  365.     case 46:
  366.     case 47:
  367.     case 48:
  368.       have_trans = 1;
  369.       if(transparentColor < 0)
  370.     unkDecodeB(dst + i*8,dst_stride,&smap[o+1],
  371.            height,0,
  372.            decomp_mask,decomp_shr);
  373.       else
  374.     unkDecodeB_trans(dst + i*8,dst_stride,&smap[o+1],
  375.              height,0,transparentColor,
  376.              decomp_mask,decomp_shr);
  377.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeB,unkDecodeB);
  378.       break;
  379.     case 64:
  380.     case 65:
  381.     case 66:
  382.     case 67:
  383.     case 68:
  384.       unkDecodeA(dst + i*8,dst_stride,&smap[o+1],
  385.          height,0,
  386.          decomp_mask,decomp_shr);
  387.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeA6,unkDecodeA);
  388.       break;
  389.     case 104:
  390.     case 105:
  391.     case 106:
  392.     case 107:
  393.     case 108:
  394.       unkDecodeA(dst + i*8,dst_stride,&smap[o+1],
  395.          height,0,
  396.          decomp_mask,decomp_shr);
  397.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeA,unkDecodeA);
  398.       break;
  399.     case 84:
  400.     case 85:
  401.     case 86:
  402.     case 87:
  403.     case 88:
  404.     case 124:
  405.     case 125:
  406.     case 126:
  407.     case 127:
  408.     case 128:
  409.       have_trans = 1;
  410.       if(transparentColor < 0)
  411.     unkDecodeA(dst + i*8,dst_stride,&smap[o+1],
  412.            height,0,
  413.            decomp_mask,decomp_shr);
  414.       else
  415.     unkDecodeA_trans(dst + i*8,dst_stride,&smap[o+1],
  416.              height,0,transparentColor,
  417.              decomp_mask,decomp_shr);
  418.  
  419.       //check_coder(dst + i*8,dst_stride,&smap[o+1],stripe_size,height,unkCodeA,unkDecodeA);
  420.       break;
  421.     default:
  422.       scc_log(LOG_ERR,"Unknown image coding: %d\n",type);
  423.       break;
  424.     }
  425.   }
  426.  
  427.   return 1+have_trans;
  428. }
  429.  
  430. static void decompMask(uint8_t *dst, int dst_stride,
  431.                uint8_t *src, int height) {
  432.  
  433.   uint8_t b, c;
  434.  
  435.   while (height) {
  436.     b = *src++;
  437.     
  438.     if (b & 0x80) {
  439.       b &= 0x7F;
  440.       c = *src++;
  441.  
  442.       do {
  443.     *dst = c;
  444.     dst += dst_stride;
  445.     --height;
  446.       } while (--b && height);
  447.     } else {
  448.       do {
  449.     *dst = *src++;
  450.     dst += dst_stride;
  451.     --height;
  452.       } while (--b && height);
  453.     }
  454.   }
  455. }
  456.  
  457. static void decompMaskOr(uint8_t *dst, int dst_stride,
  458.              uint8_t *src, int height) {
  459.  
  460.   uint8_t b, c;
  461.  
  462.   while (height) {
  463.     b = *src++;
  464.     
  465.     if (b & 0x80) {
  466.       b &= 0x7F;
  467.       c = *src++;
  468.  
  469.       do {
  470.     *dst |= c;
  471.     dst += dst_stride;
  472.     --height;
  473.       } while (--b && height);
  474.     } else {
  475.       do {
  476.     *dst |= *src++;
  477.     dst += dst_stride;
  478.     --height;
  479.       } while (--b && height);
  480.     }
  481.   }
  482. }
  483.  
  484. int scc_decode_zbuf(uint8_t* dst, int dst_stride,
  485.             int width,int height,
  486.             uint8_t* zmap,uint32_t zmap_size,int or) {
  487.   int stripes = width/8;
  488.   int i;
  489.  
  490.   if(width != stripes*8) {
  491.     scc_log(LOG_V,"Can't decode zbuf if width %% 8 != 0 !!\n");
  492.     return 0;
  493.   }
  494.  
  495.   for(i = 0 ; i < stripes ; i++) {
  496.     int o = ((uint16_t*)zmap)[i];
  497.     
  498.     if(o) {
  499.       o -= 8;
  500.       if(or)
  501.     decompMaskOr(&dst[i],dst_stride,
  502.              &zmap[o],height);
  503.       else
  504.     decompMask(&dst[i],dst_stride,
  505.            &zmap[o],height);
  506.     } else {
  507.       int j;
  508.       for(j = 0 ; j < height ; j++)
  509.     dst[i+j*dst_stride] = 0;
  510.     }
  511.   }
  512.   return 1;
  513. }
  514.