home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.3.4.17 [SPARC, PA-RISC] / nextstep33_risc.iso / NextLibrary / TeX / tex / src / texview / unpack.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-28  |  6.6 KB  |  246 lines
  1. /*
  2.  *   This is dvips, a freely redistributable PostScript driver
  3.  *   for dvi files.  It is (C) Copyright 1987 by Tomas Rokicki.
  4.  *   You may modify and use this program to your heart's content,
  5.  *   so long as you send modifications to Tomas Rokicki.  It can
  6.  *   be included in any distribution, commercial or otherwise, so
  7.  *   long as the banner string defined in structures.h is not
  8.  *   modified (except for the version number) and this banner is
  9.  *   printed on program invocation, or can be printed on program
  10.  *   invocation with the -? option.
  11.  */
  12. /*
  13.  *   unpack.c of dvisw software package.  This code is copyright (C) 1986
  14.  *   by Radical Eye Software.
  15.  *
  16.  *   unpacks the raster data from the packed buffer.  This code was 
  17.  *   translated from pktopx.web using an automatic translator, then
  18.  *   converted for this purpose.  This little routine can be very useful
  19.  *   in other drivers as well.
  20.  */
  21. #include "structures.h"
  22.  
  23. /*
  24.  * external procedures
  25.  */
  26. extern void error();
  27.  
  28. /*
  29.  *   Some statics for use here.
  30.  */
  31. static halfword bitweight ; 
  32. static halfword dynf ;
  33. static halfword gpower[17] = { 0 , 1 , 3 , 7 , 15 , 31 , 63 , 127 ,
  34.      255 , 511 , 1023 , 2047 , 4095 , 8191 , 16383 , 32767 , 65535 } ; 
  35. static halfword repeatcount ;
  36. static quarterword *p ;
  37.  
  38. /*
  39.  *   We need procedures to get a nybble, bit, and packed word from the
  40.  *   packed data structure.
  41.  */
  42.  
  43. shalfword
  44. getnyb ()
  45. {
  46.     if ( bitweight == 0 ) 
  47.     { bitweight = 16 ; 
  48.       return(*p++ & 15) ;
  49.     } else {
  50.       bitweight = 0 ;
  51.       return(*p >> 4) ;
  52.     }
  53. } 
  54.  
  55. Boolean
  56. getbit ()
  57. {
  58.     bitweight >>= 1 ; 
  59.     if ( bitweight == 0 ) 
  60.     { p++ ;
  61.       bitweight = 128 ;
  62.     } 
  63.     return(*p & bitweight) ;
  64. } 
  65. static halfword (*realfunc)() ;
  66. long remainder ;
  67. halfword handlehuge() ;
  68. halfword pkpackednum () {
  69. register halfword i, j ; 
  70.     i = getnyb () ; 
  71.     if ( i == 0 ) 
  72.     { do { j = getnyb () ; 
  73.         i++ ; 
  74.         } while ( ! ( j != 0 ) ) ; 
  75.       if ( i > 3 ) {
  76. /*
  77.  *   Damn, we got a huge count!  We *fake* it by giving an artificially
  78.  *   large repeat count.
  79.  */
  80.          return( handlehuge ( i , j ) ) ;
  81.       } else {
  82.          while ( i > 0 ) 
  83.            { j = j * 16 + getnyb () ; 
  84.              i-- ; 
  85.              } 
  86.            return ( j - 15 + ( 13 - dynf ) * 16 + dynf ) ; 
  87.          } 
  88.       }
  89.     else if ( i <= dynf ) return ( i ) ; 
  90.     else if ( i < 14 ) return ( ( i - dynf - 1 ) * 16 + getnyb () + dynf + 1 
  91.     ) ; 
  92.     else 
  93.     { if ( i == 14 ) repeatcount = pkpackednum () ; 
  94.       else repeatcount = 1 ; 
  95.       return ( (*realfunc)() ) ;
  96.       } 
  97.     } 
  98. halfword rest ()
  99. {
  100.    halfword i ;
  101.  
  102.    if (remainder < 0) {
  103.       remainder = - remainder ;
  104.       return ( 0 ) ;
  105.    } else if (remainder > 0) {
  106.       if (remainder > 4000) {
  107.          remainder = 4000 - remainder ;
  108.          return ( 4000 ) ;
  109.       } else {
  110.          i = remainder ;
  111.          remainder = 0 ;
  112.          realfunc = pkpackednum ;
  113.          return ( i ) ;
  114.       }
  115.    } else {
  116.       error("! shouldn't happen") ;
  117.    }
  118.    return 0 ;
  119. }
  120. halfword handlehuge ( i , k )
  121. halfword i , k ;
  122. {
  123.    register long j = k ;
  124.  
  125.    while (i) {
  126.       j = (j << 4L) + getnyb() ;
  127.       i-- ;
  128.    }
  129.    remainder = j - 15 + ( 13 - dynf ) * 16 + dynf ;
  130.    realfunc = rest ;
  131.    return ( rest() ) ;
  132. }
  133. void flip(p, howmany)
  134. register char *p ;
  135. register long howmany ;
  136. {
  137.    register char t ;
  138.  
  139.    while (howmany > 0) {
  140.       t = *p ;
  141.       *p = p[1] ;
  142.       p[1] = t ;
  143.       howmany-- ;
  144.       p += 2 ;
  145.    }
  146. }
  147. /*
  148.  *   And now we have our main routine.
  149.  */
  150. static halfword bftest = 1 ;
  151. long
  152. unpack(pack, raster, cwidth, cheight, cmd)
  153.     quarterword *pack ;
  154.     halfword *raster ;
  155.     halfword cwidth, cheight, cmd ;
  156. { 
  157.   register integer i, j ; 
  158.   shalfword wordwidth ; 
  159.   register halfword word, wordweight ;
  160.   shalfword rowsleft ; 
  161.   Boolean turnon ; 
  162.   shalfword hbit ; 
  163.   int count ; 
  164.   halfword *oraster ;
  165.  
  166.       oraster = raster ;
  167.       realfunc = pkpackednum ;
  168.       p = pack ;
  169.       dynf = cmd / 16 ; 
  170.       turnon = cmd & 8 ; 
  171.       wordwidth = (cwidth + 15)/16 ;
  172.       raster += (cheight - 1) * (long)wordwidth ;
  173.       if ( dynf == 14 ) 
  174.       { bitweight = 256 ; 
  175.         for ( i = 1 ; i <= cheight ; i ++ ) 
  176.           { word = 0 ; 
  177.             wordweight = 32768 ; 
  178.             for ( j = 1 ; j <= cwidth ; j ++ ) 
  179.               { if ( getbit () ) word += wordweight ; 
  180.                 wordweight >>= 1 ;
  181.                 if ( wordweight == 0 ) 
  182.                 { *raster++ = word ; 
  183.                   word = 0 ;
  184.                   wordweight = 32768 ; 
  185.                   } 
  186.                 } 
  187.               if ( wordweight != 32768 ) 
  188.                  *raster++ = word ; 
  189.               raster -= 2 * wordwidth ;
  190.             } 
  191.       } else {
  192.         rowsleft = cheight ; 
  193.         hbit = cwidth ; 
  194.         repeatcount = 0 ; 
  195.         wordweight = 16 ; 
  196.         word = 0 ; 
  197.         bitweight = 16 ;
  198.         while ( rowsleft > 0 ) 
  199.           { count = (*realfunc)() ; 
  200.             while ( count != 0 ) 
  201.               { if ( ( count < wordweight ) && ( count < hbit ) ) 
  202.                 { if ( turnon ) word += gpower [ wordweight ] - gpower 
  203.                   [ wordweight - count ] ; 
  204.                   hbit -= count ; 
  205.                   wordweight -= count ; 
  206.                   count = 0 ; 
  207.                   } 
  208.                 else if ( ( count >= hbit ) && ( hbit <= (int)wordweight ) ) 
  209.                 { if ( turnon )
  210.                      word += gpower [ wordweight ] - gpower 
  211.                   [ wordweight - hbit ] ; 
  212.                   *raster++ = word ; 
  213.                   raster -= 2 * wordwidth ;
  214.                   for ( i = 1 ; i <= repeatcount ; i ++ ) {
  215.                     for ( j = 1 ; j <= wordwidth ; j ++ ) {
  216.                       *raster = *(raster + wordwidth) ;
  217.                       raster++ ;
  218.                     }
  219.                     raster -= 2 * wordwidth ;
  220.                   }
  221.                   rowsleft -= repeatcount + 1 ; 
  222.                   repeatcount = 0 ; 
  223.                   word = 0 ; 
  224.                   wordweight = 16 ; 
  225.                   count -= hbit ; 
  226.                   hbit = cwidth ; 
  227.                   } 
  228.                 else 
  229.                 { if ( turnon ) word += gpower [ wordweight ] ; 
  230.                   *raster++ = word ;
  231.                   word = 0 ; 
  232.                   count -= wordweight ; 
  233.                   hbit -= wordweight ; 
  234.                   wordweight = 16 ; 
  235.                   } 
  236.                 } 
  237.               turnon = ! turnon ; 
  238.             } 
  239.           if ( ( rowsleft != 0 ) || ( hbit != (int)cwidth ) ) 
  240.           error ( "! error while unpacking; more bits than required" ) ; 
  241.         } 
  242.     if (*(char *)&bftest)
  243.        flip(oraster, ((cwidth + 15) >> 4) * (long)cheight) ;
  244.    return(p-pack) ;
  245. }
  246.