home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / util / unpack.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-11  |  8.1 KB  |  334 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from unpack.c
  3. */
  4. /*
  5.  *   Unpacks the raster data from the packed buffer.  This code was 
  6.  *   translated from pktopx.web using an automatic translator, then
  7.  *   converted for this purpose.  This little routine can be very useful
  8.  *   in other drivers as well.
  9.  */
  10.  
  11. #include "defines.h"
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <stddef.h>
  16. #include <string.h>
  17.  
  18. #include "globals.h"
  19. #include "textypes.h"
  20. #include "flmt.h"
  21. #include "new_font.h"
  22.  
  23. #include "globals.i"
  24. #include "unpack.i"
  25.  
  26.  
  27. /*
  28.  * Fuer die locale-Library:
  29.  *
  30.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  31.  * Achtung:
  32.  * Es muss/sollte 'multiple-include' erlaubt sein!
  33.  */
  34. #include "local.i"
  35.  
  36. #undef  CATCOMP_ARRAY
  37. #undef  CATCOMP_BLOCK
  38. #undef  CATCOMP_STRINGS
  39. #define CATCOMP_NUMBERS
  40. #include "localstr.h"
  41.  
  42.  
  43.  
  44. /*
  45.  * external procedures
  46.  */
  47. /* ?? */
  48.  
  49. extern struct FontMan    *FontRoot;    /* root structure    */
  50.  
  51.  
  52. /*
  53.  * internal procedures
  54.  */
  55. static shalfword getnyb        (void);
  56. static Boolean   getbit        (void);
  57. static long      pkpackednum    (void);
  58. #if 0
  59. static void      flip        (char *s, long howmany);
  60. #endif
  61. static long     getlong    (unsigned char *a);
  62. static void     unpack        (quarterword *pack, halfword *raster,
  63.                  halfword cwidth, halfword cheight,
  64.                  halfword cmd);
  65.  
  66.  
  67. /*
  68.  *   Some statics for use here.
  69.  */
  70. static halfword bitweight ; 
  71. static halfword dynf ;
  72. static halfword gpower[17] = { 0 , 1 , 3 , 7 , 15 , 31 , 63 , 127 ,
  73.      255 , 511 , 1023 , 2047 , 4095 , 8191 , 16383 , (halfword)32767 , (halfword)65535 } ; 
  74. static long repeatcount ;
  75. static quarterword *p ;
  76.  
  77. #if 0
  78. static halfword bftest = 1 ;
  79. #endif
  80.  
  81.  
  82. /*
  83.  *   We need procedures to get a nybble, bit, and packed word from the
  84.  *   packed data structure.
  85.  */
  86.  
  87. static shalfword __inline getnyb (void)
  88. {
  89.     if ( bitweight == 0 ) 
  90.     { bitweight = 16 ; 
  91.       return (shalfword)(*p++ & 15) ;
  92.     } else {
  93.       bitweight = 0 ;
  94.       return (shalfword)(*p >> 4) ;
  95.     }
  96. } 
  97.  
  98. static Boolean __inline getbit (void)
  99. {
  100.     bitweight >>= 1 ; 
  101.     if ( bitweight == 0 ) 
  102.     { p++ ;
  103.       bitweight = 128 ;
  104.     } 
  105.     return (Boolean)(*p & bitweight) ;
  106. } 
  107.  
  108. static long pkpackednum (void)
  109. {
  110.     register halfword i;
  111.     register long j ; 
  112.     i = getnyb () ; 
  113.     if ( i == 0 ) {
  114.        do { j = (long)getnyb () ; 
  115.           i++ ; 
  116.           } while ( j == 0L ) ; 
  117.        while ( i != 0 ) {
  118.           j = j * 16L + ((long) getnyb ()) ; 
  119.           i-- ; 
  120.           } 
  121.        return ( j - 15L + ( 13L - dynf ) * 16L + dynf ) ; 
  122.     }
  123.     else if ( i <= dynf ) return ( (long)i ) ; 
  124.     else if ( i < 14 ) return ( ( (long)i - (long)dynf - 1L )*16L + (long)getnyb() + (long)dynf + 1L ) ; 
  125.     else {
  126.        if (repeatcount != 0)
  127.           Fatal(10,MSG_UNPACK_RECURSIV);
  128.        repeatcount = 1L ;
  129.        if ( i == 14 ) repeatcount = pkpackednum () ; 
  130.        return ( pkpackednum() ) ;
  131.     } 
  132. } 
  133.  
  134. #if 0
  135. static void flip(char *s, long howmany)
  136. {
  137.    register char t ;
  138.  
  139.    while (howmany > 0) {
  140.       t = *s ;
  141.       *s = s[1] ;
  142.       s[1] = t ;
  143.       howmany-- ;
  144.       s += 2 ;
  145.    }
  146. }
  147. #endif
  148.  
  149.  
  150. /*
  151.  *   And now we have our main routine.
  152.  */
  153.  
  154. static void unpack(quarterword *pack, halfword *raster,
  155.             halfword cwidth, halfword cheight, halfword 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.   long count ; 
  164.  
  165. #if 0
  166.   halfword *oraster ;
  167.   oraster = raster ;
  168. #endif
  169.  
  170.   p = pack ;
  171.   dynf = cmd / 16 ; 
  172.   turnon = cmd & 8 ; 
  173.   wordwidth = (cwidth + 15)/16 ;
  174.   if ( dynf == 14 ) 
  175.   { bitweight = 256 ; 
  176.     for ( i = 1 ; i <= cheight ; i ++ ) 
  177.       { word = 0 ; 
  178.         wordweight = (halfword)32768 ; 
  179.         for ( j = 1 ; j <= cwidth ; j ++ ) 
  180.           { if ( getbit () ) word += wordweight ; 
  181.             wordweight >>= 1 ;
  182.             if ( wordweight == 0 ) 
  183.             { *raster++ = word ; 
  184.               word = 0 ;
  185.               wordweight = (halfword)32768 ; 
  186.               } 
  187.             } 
  188.           if ( wordweight != (halfword)32768 ) 
  189.              *raster++ = word ; 
  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 = pkpackednum() ; 
  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 <= wordweight ) ) 
  209.             { if ( turnon )
  210.                  word += gpower[wordweight] - gpower[wordweight-hbit] ; 
  211.               *raster++ = word ; 
  212.               for ( i = 1 ; i <= repeatcount ; i ++ ) {
  213.                 for ( j = 1 ; j <= wordwidth ; j ++ ) {
  214.                   *raster = *(raster - wordwidth) ;
  215.                   raster++ ;
  216.                 }
  217.               }
  218.               rowsleft -= repeatcount + 1 ; 
  219.               repeatcount = 0 ; 
  220.               word = 0 ; 
  221.               wordweight = 16 ; 
  222.               count -= hbit ; 
  223.               hbit = cwidth ; 
  224.               } 
  225.             else 
  226.             { if ( turnon ) word += gpower [ wordweight ] ; 
  227.               *raster++ = word ;
  228.               word = 0 ; 
  229.               count -= wordweight ; 
  230.               hbit -= wordweight ; 
  231.               wordweight = 16 ; 
  232.               } 
  233.             } 
  234.           turnon = ! turnon ; 
  235.         } 
  236.       if ( ( rowsleft != 0 ) || ( hbit != cwidth ) ) 
  237.     Fatal(10,MSG_UNPACK_MORE_BITS);
  238.     } 
  239. #if 0
  240.     if (*(char *)&bftest) /* is the hardware LittleEndian? */
  241.        flip((char *)oraster, ((cwidth + 15) >> 4) * (long)cheight) ;
  242. #endif
  243.    /** return(p-pack) ;  **/
  244. }
  245.  
  246.  
  247. static long getlong(quarterword *a)
  248. {
  249.   return ((((((a[0] << 8L) + a[1]) << 8L) + a[2]) << 8L) + a[3]) ;
  250. }
  251.  
  252.  
  253. /*
  254.  *  unpack one character
  255.  */
  256. void unpack_char(struct Font *fnt, short cc)
  257. {
  258.    long i;
  259.    halfword cheight, cwidth ;
  260.    quarterword *p ;
  261.    halfword cmd ;
  262.    shalfword xoff, yoff ;
  263.    halfword wwidth;
  264.    struct Char *unpacked_char;
  265.    halfword *bitmap;
  266.  
  267.    if (fnt->common->fnt_status != FNT_LOADED && 
  268.        fnt->common->fnt_status != FNT_DEFINED_OLOADED &&
  269.        fnt->common->fnt_status != FNT_OLD_LOADED) {
  270.      return;    /* do nothing     (should never occure) */
  271.      /* der Fall tritt zur Zeit nicht auf, waere aber zu ueberlegen, ob man    */
  272.      /* nicht zulassen koennte, einen Font zu verwenden, dessen pk-data nicht    */
  273.      /*    geladen (weil removed) ist. Man muesste den Font nur dann laden, wenn    */
  274.      /*    ein Char gebraucht wird, der noch nicht ausgepackt ist!            */
  275.    }
  276.  
  277.    p = (quarterword *)(fnt->common->ch_start_bm + fnt->common->ch[cc].packed_data);
  278.  
  279.    cmd = *p++ ;
  280.    if (cmd & 4) {
  281.       if ((cmd & 7) == 7) {
  282.          cwidth = getlong(p) ;
  283.          cheight = getlong(p + 4) ;
  284.          xoff = getlong(p + 8) ;
  285.          yoff = getlong(p + 12) ;
  286.          p += 16 ;
  287.       } else {
  288.          cwidth = p[0] * 256 + p[1] ;
  289.          cheight = p[2] * 256 + p[3] ;
  290.          xoff = p[4] * 256 + p[5] ; /* N.B.: xoff, yoff are signed halfwords */
  291.          yoff = p[6] * 256 + p[7] ;
  292.          p += 8 ;
  293.       }
  294.    } else {
  295.       cwidth = *p++ ;
  296.       cheight = *p++ ;
  297.       xoff = *p++ ;
  298.       yoff = *p++ ;
  299.       if (xoff > 127)
  300.          xoff -= 256 ;
  301.       if (yoff > 127)
  302.          yoff -= 256 ;
  303.    }
  304.  
  305.    wwidth = (cwidth + 15) / 16 ;
  306.    i = 2L * (long)cheight * (long)wwidth ;
  307.    if (i <= 0) i = 2;
  308.  
  309.    unpacked_char = xmalloc(i + sizeof(struct Char)) ;
  310.    bitmap = (halfword *)(unpacked_char + 1);    /* bitmap at the end of the structure */
  311.  
  312.    memset(bitmap, 0, i);    /* clear the buffer */
  313.    unpack(p, (halfword *)bitmap, cwidth, cheight, cmd) ;
  314.  
  315. /*
  316.    unpacked_char->bytes = i + sizeof(struct Char);
  317.    FontRoot->unpacked_mem += unpacked_char->bytes;
  318. */
  319.    FontRoot->unpacked_mem += i + sizeof(struct Char);
  320.  
  321.    if (cheight == 0 || cwidth == 0) {        /* noetig ?? */
  322.       cwidth  = 1 ;
  323.       cheight = 1 ;
  324.       bitmap[0] = 0;
  325.    }
  326.  
  327.    unpacked_char->width   = cwidth;
  328.    unpacked_char->height  = cheight;
  329.    unpacked_char->xOffset = xoff;
  330.    unpacked_char->yOffset = yoff;
  331.  
  332.    fnt->common->ch[cc].unpacked = unpacked_char;
  333. }
  334.