Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #include "layer3.h"
  2. #include "l3huff.h"
  3.  
  4. //#ifdef _MSC_VER
  5. //#pragma warning(disable: 4505)
  6. //#endif
  7.  
  8. /*===============================================================*/
  9.  
  10. /* max bits required for any lookup - change if htable changes */
  11. /* quad required 10 bit w/signs  must have (MAXBITS+2) >= 10   */
  12. #define MAXBITS 9
  13.  
  14. static HUFF_ELEMENT huff_table_0[] =
  15. {0, 0, 0, 64};                  /* dummy must not use */
  16.  
  17. /*-- 6 bit lookup (purgebits, value) --*/
  18. static unsigned char quad_table_a[][2] =
  19. {
  20.    6, 11, 6, 15, 6, 13, 6, 14, 6, 7, 6, 5, 5, 9,
  21.    5, 9, 5, 6, 5, 6, 5, 3, 5, 3, 5, 10, 5, 10,
  22.    5, 12, 5, 12, 4, 2, 4, 2, 4, 2, 4, 2, 4, 1,
  23.    4, 1, 4, 1, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4,
  24.    4, 8, 4, 8, 4, 8, 4, 8, 1, 0, 1, 0, 1, 0,
  25.    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
  26.    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
  27.    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
  28.    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
  29.    1, 0,
  30. };
  31.  
  32.  
  33. typedef struct
  34. {
  35.    HUFF_ELEMENT *table;
  36.    int linbits;
  37.    int ncase;
  38. }
  39. HUFF_SETUP;
  40.  
  41. #define no_bits       0
  42. #define one_shot      1
  43. #define no_linbits    2
  44. #define have_linbits  3
  45. #define quad_a        4
  46. #define quad_b        5
  47.  
  48.  
  49. static HUFF_SETUP table_look[] =
  50. {
  51.    huff_table_0, 0, no_bits,
  52.    huff_table_1, 0, one_shot,
  53.    huff_table_2, 0, one_shot,
  54.    huff_table_3, 0, one_shot,
  55.    huff_table_0, 0, no_bits,
  56.    huff_table_5, 0, one_shot,
  57.    huff_table_6, 0, one_shot,
  58.    huff_table_7, 0, no_linbits,
  59.    huff_table_8, 0, no_linbits,
  60.    huff_table_9, 0, no_linbits,
  61.    huff_table_10, 0, no_linbits,
  62.    huff_table_11, 0, no_linbits,
  63.    huff_table_12, 0, no_linbits,
  64.    huff_table_13, 0, no_linbits,
  65.    huff_table_0, 0, no_bits,
  66.    huff_table_15, 0, no_linbits,
  67.    huff_table_16, 1, have_linbits,
  68.    huff_table_16, 2, have_linbits,
  69.    huff_table_16, 3, have_linbits,
  70.    huff_table_16, 4, have_linbits,
  71.    huff_table_16, 6, have_linbits,
  72.    huff_table_16, 8, have_linbits,
  73.    huff_table_16, 10, have_linbits,
  74.    huff_table_16, 13, have_linbits,
  75.    huff_table_24, 4, have_linbits,
  76.    huff_table_24, 5, have_linbits,
  77.    huff_table_24, 6, have_linbits,
  78.    huff_table_24, 7, have_linbits,
  79.    huff_table_24, 8, have_linbits,
  80.    huff_table_24, 9, have_linbits,
  81.    huff_table_24, 11, have_linbits,
  82.    huff_table_24, 13, have_linbits,
  83.    huff_table_0, 0, quad_a,
  84.    huff_table_0, 0, quad_b,
  85. };
  86.  
  87. /*========================================================*/
  88. void huffman(int xy[][2], int n, int ntable)
  89. {
  90.    int i;
  91.    HUFF_ELEMENT *t;
  92.    HUFF_ELEMENT *t0;
  93.    int linbits;
  94.    int bits;
  95.    int code;
  96.    int x, y;
  97.  
  98.    if (n <= 0)
  99.       return;
  100.    n = n >> 1;                  /* huff in pairs */
  101. /*-------------*/
  102.    t0 = table_look[ntable].table;
  103.    linbits = table_look[ntable].linbits;
  104.    switch (table_look[ntable].ncase)
  105.    {
  106.       default:
  107. /*------------------------------------------*/
  108.       case no_bits:
  109. /*- table 0, no data, x=y=0--*/
  110.          for (i = 0; i < n; i++)
  111.          {
  112.             xy[i][0] = 0;
  113.             xy[i][1] = 0;
  114.          }
  115.          return;
  116. /*------------------------------------------*/
  117.       case one_shot:
  118. /*- single lookup, no escapes -*/
  119.          for (i = 0; i < n; i++)
  120.          {
  121.             mac_bitget_check((MAXBITS + 2));
  122.             bits = t0[0].b.signbits;
  123.             code = mac_bitget2(bits);
  124.             mac_bitget_purge(t0[1 + code].b.purgebits);
  125.             x = t0[1 + code].b.x;
  126.             y = t0[1 + code].b.y;
  127.             if (x)
  128.                if (mac_bitget_1bit())
  129.                   x = -x;
  130.             if (y)
  131.                if (mac_bitget_1bit())
  132.                   y = -y;
  133.             xy[i][0] = x;
  134.             xy[i][1] = y;
  135.             if (bitget_overrun())
  136.                break;           // bad data protect
  137.  
  138.          }
  139.          return;
  140. /*------------------------------------------*/
  141.       case no_linbits:
  142.          for (i = 0; i < n; i++)
  143.          {
  144.             t = t0;
  145.             for (;;)
  146.             {
  147.                mac_bitget_check((MAXBITS + 2));
  148.                bits = t[0].b.signbits;
  149.                code = mac_bitget2(bits);
  150.                if (t[1 + code].b.purgebits)
  151.                   break;
  152.                t += t[1 + code].ptr;    /* ptr include 1+code */
  153.                mac_bitget_purge(bits);
  154.             }
  155.             mac_bitget_purge(t[1 + code].b.purgebits);
  156.             x = t[1 + code].b.x;
  157.             y = t[1 + code].b.y;
  158.             if (x)
  159.                if (mac_bitget_1bit())
  160.                   x = -x;
  161.             if (y)
  162.                if (mac_bitget_1bit())
  163.                   y = -y;
  164.             xy[i][0] = x;
  165.             xy[i][1] = y;
  166.             if (bitget_overrun())
  167.                break;           // bad data protect
  168.  
  169.          }
  170.          return;
  171. /*------------------------------------------*/
  172.       case have_linbits:
  173.          for (i = 0; i < n; i++)
  174.          {
  175.             t = t0;
  176.             for (;;)
  177.             {
  178.                bits = t[0].b.signbits;
  179.                code = bitget2(bits);
  180.                if (t[1 + code].b.purgebits)
  181.                   break;
  182.                t += t[1 + code].ptr;    /* ptr includes 1+code */
  183.                mac_bitget_purge(bits);
  184.             }
  185.             mac_bitget_purge(t[1 + code].b.purgebits);
  186.             x = t[1 + code].b.x;
  187.             y = t[1 + code].b.y;
  188.             if (x == 15)
  189.                x += bitget_lb(linbits);
  190.             if (x)
  191.                if (mac_bitget_1bit())
  192.                   x = -x;
  193.             if (y == 15)
  194.                y += bitget_lb(linbits);
  195.             if (y)
  196.                if (mac_bitget_1bit())
  197.                   y = -y;
  198.             xy[i][0] = x;
  199.             xy[i][1] = y;
  200.             if (bitget_overrun())
  201.                break;           // bad data protect
  202.  
  203.          }
  204.          return;
  205.    }
  206. /*--- end switch ---*/
  207.  
  208. }
  209.  
  210. int huffman_quad(int vwxy[][4], int n, int nbits, int ntable)
  211. {
  212.    int i;
  213.    int code;
  214.    int x, y, v, w;
  215.    int tmp;
  216.    int i_non_zero, tmp_nz;
  217.  
  218.    tmp_nz = 15;
  219.    i_non_zero = -1;
  220.  
  221.    n = n >> 2;                  /* huff in quads */
  222.  
  223.    if (ntable)
  224.       goto case_quad_b;
  225.  
  226. /* case_quad_a: */
  227.    for (i = 0; i < n; i++)
  228.    {
  229.       if (nbits <= 0)
  230.          break;
  231.       mac_bitget_check(10);
  232.       code = mac_bitget2(6);
  233.       nbits -= quad_table_a[code][0];
  234.       mac_bitget_purge(quad_table_a[code][0]);
  235.       tmp = quad_table_a[code][1];
  236.       if (tmp)
  237.       {
  238.          i_non_zero = i;
  239.          tmp_nz = tmp;
  240.       }
  241.       v = (tmp >> 3) & 1;
  242.       w = (tmp >> 2) & 1;
  243.       x = (tmp >> 1) & 1;
  244.       y = tmp & 1;
  245.       if (v)
  246.       {
  247.          if (mac_bitget_1bit())
  248.             v = -v;
  249.          nbits--;
  250.       }
  251.       if (w)
  252.       {
  253.          if (mac_bitget_1bit())
  254.             w = -w;
  255.          nbits--;
  256.       }
  257.       if (x)
  258.       {
  259.          if (mac_bitget_1bit())
  260.             x = -x;
  261.          nbits--;
  262.       }
  263.       if (y)
  264.       {
  265.          if (mac_bitget_1bit())
  266.             y = -y;
  267.          nbits--;
  268.       }
  269.       vwxy[i][0] = v;
  270.       vwxy[i][1] = w;
  271.       vwxy[i][2] = x;
  272.       vwxy[i][3] = y;
  273.       if (bitget_overrun())
  274.          break;                 // bad data protect
  275.  
  276.    }
  277.    if (nbits < 0)
  278.    {
  279.       i--;
  280.       vwxy[i][0] = 0;
  281.       vwxy[i][1] = 0;
  282.       vwxy[i][2] = 0;
  283.       vwxy[i][3] = 0;
  284.    }
  285.  
  286.    i_non_zero = (i_non_zero + 1) << 2;
  287.  
  288.    if ((tmp_nz & 3) == 0)
  289.       i_non_zero -= 2;
  290.  
  291.    return i_non_zero;
  292.  
  293. /*--------------------*/
  294.  case_quad_b:
  295.    for (i = 0; i < n; i++)
  296.    {
  297.       if (nbits < 4)
  298.          break;
  299.       nbits -= 4;
  300.       mac_bitget_check(8);
  301.       tmp = mac_bitget(4) ^ 15; /* one's complement of bitstream */
  302.       if (tmp)
  303.       {
  304.          i_non_zero = i;
  305.          tmp_nz = tmp;
  306.       }
  307.       v = (tmp >> 3) & 1;
  308.       w = (tmp >> 2) & 1;
  309.       x = (tmp >> 1) & 1;
  310.       y = tmp & 1;
  311.       if (v)
  312.       {
  313.          if (mac_bitget_1bit())
  314.             v = -v;
  315.          nbits--;
  316.       }
  317.       if (w)
  318.       {
  319.          if (mac_bitget_1bit())
  320.             w = -w;
  321.          nbits--;
  322.       }
  323.       if (x)
  324.       {
  325.          if (mac_bitget_1bit())
  326.             x = -x;
  327.          nbits--;
  328.       }
  329.       if (y)
  330.       {
  331.          if (mac_bitget_1bit())
  332.             y = -y;
  333.          nbits--;
  334.       }
  335.       vwxy[i][0] = v;
  336.       vwxy[i][1] = w;
  337.       vwxy[i][2] = x;
  338.       vwxy[i][3] = y;
  339.       if (bitget_overrun())
  340.          break;                 // bad data protect
  341.  
  342.    }
  343.    if (nbits < 0)
  344.    {
  345.       i--;
  346.       vwxy[i][0] = 0;
  347.       vwxy[i][1] = 0;
  348.       vwxy[i][2] = 0;
  349.       vwxy[i][3] = 0;
  350.    }
  351.  
  352.    i_non_zero = (i_non_zero + 1) << 2;
  353.  
  354.    if ((tmp_nz & 3) == 0)
  355.       i_non_zero -= 2;
  356.  
  357.    return i_non_zero;           /* return non-zero sample (to nearest pair) */
  358.  
  359. }
  360.