home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 10 / AU_CD10.iso / Archived / Updates / Flash / writeflash / !MakeFlash / c / cxform < prev    next >
Text File  |  2000-04-19  |  4KB  |  174 lines
  1. #include <stdio.h>
  2. //
  3. #include "proto.h"
  4. #include "bucket.h"
  5. #include "cxform.h"
  6. #include "bitcount.h"
  7.  
  8.  
  9. int cxform_write(CXFORM *cxform, int usealpha) {
  10.  
  11.   U32 bits, bits2, add, mul;
  12.   S16 addr, addg, addb, adda, mulr, mulg, mulb, mula;
  13.  
  14.   if (flush_bucket())                             return 1;
  15.  
  16.   addr = cxform->addr;
  17.   addg = cxform->addg;
  18.   addb = cxform->addb;
  19.   if (usealpha)
  20.     adda = cxform->adda;
  21.   else
  22.     adda  = 0;
  23.   mulr = cxform->mulr;
  24.   mulg = cxform->mulg;
  25.   mulb = cxform->mulb;
  26.   if (usealpha)
  27.     mula = cxform->mula;
  28.   else
  29.     mula = 255;
  30.  
  31.   if ((addr != 0) || (addg != 0) || (addb != 0) || (adda != 0))
  32.     add = 1;
  33.   else
  34.     add = 0;
  35.  
  36.   if ((mulr != 255) || (mulg != 255) || (mulb != 255) || (mula != 255))
  37.     mul = 1;
  38.   else
  39.     mul = 0;
  40.  
  41.   if (write_ubits(1, add))                        return 1;
  42.   if (write_ubits(1, mul))                        return 1;
  43.  
  44.   bits = bitcount_signed(addr, addg, addb, adda);
  45.   bits2 = bitcount_signed(mulr, mulg, mulb, mula);
  46.   if (bits2 > bits)   bits = bits2;
  47.   if (write_ubits(4, bits))                       return 1;
  48.  
  49.   if (mul) {
  50.     if (write_bits(bits, mulr))                   return 1;
  51.     if (write_bits(bits, mulg))                   return 1;
  52.     if (write_bits(bits, mulb))                   return 1;
  53.     if (usealpha)
  54.       if (write_bits(bits, mula))                 return 1;
  55.   }
  56.  
  57.   if (add) {
  58.     if (write_bits(bits, addr))                   return 1;
  59.     if (write_bits(bits, addg))                   return 1;
  60.     if (write_bits(bits, addb))                   return 1;
  61.     if (usealpha)
  62.       if (write_bits(bits, adda))                 return 1;
  63.   }
  64.  
  65.   return 0;
  66. }
  67.  
  68.  
  69. int cxform_read(CXFORM *cxform, int usealpha) {
  70.  
  71.   U32 mul, add, bits;
  72.   S32 value;
  73.  
  74.   cxform->mulr = cxform->mulg = cxform->mulb = cxform->mula = 255;
  75.   cxform->addr = cxform->addg = cxform->addb = cxform->adda = 0;
  76.  
  77.   if (read_ubits(1, &mul))                        return 1;
  78.   if (read_ubits(1, &add))                        return 1;
  79.   if (read_ubits(4, &bits))                       return 1;
  80.   if (mul) {
  81.     if (read_bits(bits, &value))                  return 1;
  82.     cxform->mulr = (S16)value;
  83.     if (read_bits(bits, &value))                  return 1;
  84.     cxform->mulg = (S16)value;
  85.     if (read_bits(bits, &value))                  return 1;
  86.     cxform->mulb = (S16)value;
  87.     if (usealpha) {
  88.       if (read_bits(bits, &value))                return 1;
  89.       cxform->mula = (S16)value;
  90.     }
  91.   }
  92.   if (add) {
  93.     if (read_bits(bits, &value))                  return 1;
  94.     cxform->addr = (S16)value;
  95.     if (read_bits(bits, &value))                  return 1;
  96.     cxform->addg = (S16)value;
  97.     if (read_bits(bits, &value))                  return 1;
  98.     cxform->addb = (S16)value;
  99.     if (usealpha) {
  100.       if (read_bits(bits, &value))                return 1;
  101.       cxform->adda = (S16)value;
  102.     }
  103.   }
  104.  
  105.   return 0;
  106. }
  107.  
  108.  
  109. int cxform_is_empty(CXFORM *cxform) {
  110.  
  111.   if ((cxform->mulr != 255)  ||
  112.       (cxform->mulg != 255)  ||
  113.       (cxform->mulb != 255)  ||
  114.       (cxform->mula != 255)  ||
  115.       (cxform->addr != 0)    ||
  116.       (cxform->addg != 0)    ||
  117.       (cxform->addb != 0)    ||
  118.       (cxform->addr != 0))              return 0;
  119.  
  120.   return 1;
  121. }
  122.  
  123.  
  124. U32 cxform_count_bits(CXFORM *cxform, int usealpha) {
  125.  
  126.   U32 max, bits;
  127.   S32 r, g, b, a;
  128.  
  129.   bits = 6;
  130.  
  131.   if (usealpha) {
  132.     r = cxform->mulr;
  133.     g = cxform->mulg;
  134.     b = cxform->mulb;
  135.     a = cxform->mula;
  136.     if ((r != 255) || (g != 255) || (b != 255) || (a != 255)) {
  137.       max = bitcount_signed(r, g, b, a);
  138.       bits += 4*max;
  139.     }
  140.     r = cxform->addr;
  141.     g = cxform->addg;
  142.     b = cxform->addb;
  143.     a = cxform->adda;
  144.     if ((r != 0) || (g != 0) || (b != 0) && (a != 0)) {
  145.       max = bitcount_signed(r, g, b, a);
  146.       bits += 4*max;
  147.     }
  148.   } else {
  149.     r = cxform->mulr;
  150.     g = cxform->mulg;
  151.     b = cxform->mulb;
  152.     if ((r != 255) || (g != 255) || (b != 255)) {
  153.       max = bitcount_signed(r, g, b, 0);
  154.       bits += 3*max;
  155.     }
  156.     r = cxform->addr;
  157.     g = cxform->addg;
  158.     b = cxform->addb;
  159.     if ((r != 0) || (g != 0) || (b != 0)) {
  160.       max = bitcount_signed(r, g, b, 0);
  161.       bits += 3*max;
  162.     }
  163.   }
  164.  
  165.   return bits;
  166. }
  167.  
  168.  
  169. void cxform_reset(CXFORM *cxform) {
  170.  
  171.   cxform->mulr = cxform->mulg = cxform->mulb = cxform->mula = 255;
  172.   cxform->addr = cxform->addg = cxform->addb = cxform->adda = 0;
  173. }
  174.