home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / flash078.zip / flashsource-r0_7_8.zip / FBitmap.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-30  |  6.3 KB  |  266 lines
  1. #include "FBitmap.h"
  2. #include "zlib/zlib.h"
  3. #include <sstream>
  4. std::ostream &operator << (std::ostream &out, FlashTagDefineBitsJPEG1 &data)
  5. {
  6.     out << FlashTagHeader(6, 2+data.len);
  7.     WRITE_UWORD(data.GetID());
  8.     for(UDWORD d=0; d < data.len; d++)
  9.     {
  10.         out.put((unsigned char)data.data[d]);
  11.     }
  12.     return out;
  13. }
  14.  
  15. std::istream &operator >> (std::istream &in,  FlashTagDefineBitsJPEG1 &data)
  16. {
  17.     
  18.     UWORD id;
  19.     READ_UWORD(id);
  20.     data.SetID(id);
  21.     
  22.     data.data = (unsigned char*)malloc(data.importsize - 2);
  23.     data.datagc.push_back(data.data);
  24.  
  25.     for(UDWORD d=0; d < data.importsize - 2; d++)
  26.     {
  27.         int i = in.get();        
  28.         data.data[d] = i;
  29.     }
  30.     
  31.     return in;
  32. }
  33.  
  34. std::ostream &operator << (std::ostream &out, FlashTagJPEGTables &data)
  35. {
  36.     out << FlashTagHeader(8,data.len);
  37.     for(UDWORD d=0; d < data.len; d++)
  38.     {
  39.         out.put((unsigned char)data.data[d]);
  40.     }
  41.     return out;
  42. }
  43.  
  44. std::istream &operator >> (std::istream &in,  FlashTagJPEGTables &data)
  45. {
  46.     data.data = (unsigned char*)malloc(data.importsize);
  47.     data.datagc.push_back(data.data);
  48.  
  49.     for(UDWORD d=0; d < data.importsize; d++)
  50.     {
  51.         int i = in.get();        
  52.         data.data[d] = i;
  53.     }
  54.     return in;
  55. }
  56.  
  57. std::ostream &operator << (std::ostream &out, FlashTagDefineBitsJPEG2 &data)
  58. {
  59.     out << FlashTagHeader(21, 2+data.len);
  60.     WRITE_UWORD(data.GetID());
  61.     {
  62.         for(UDWORD d=0; d < data.len; d++)
  63.         {
  64.             out.put((unsigned char)data.data[d]);
  65.         }
  66.     }
  67.     return out;
  68. }
  69.  
  70. std::istream &operator >> (std::istream &in,  FlashTagDefineBitsJPEG2 &data)
  71. {
  72.     UWORD id;
  73.     READ_UWORD(id);
  74.     data.SetID(id);    
  75.     {
  76.         data.data = (unsigned char *)malloc(data.importsize-2);
  77.         data.gc.push_back(data.data);
  78.         in.read((char *)data.data, data.importsize-2); //throw if not proper amount read
  79.         data.len = data.importsize-2;
  80.     }
  81.     return in;
  82. }
  83.  
  84. std::ostream &operator << (std::ostream &out, FlashTagDefineBitsJPEG3 &data)
  85. {
  86.     out << FlashTagHeader(35, 2+4+data.len+data.len2);
  87.     WRITE_UWORD(data.GetID());
  88.     WRITE_UDWORD(data.len);
  89.     {
  90.         for(UDWORD d=0; d < data.len; d++)
  91.         {
  92.             out.put((unsigned char)data.data[d]);        
  93.         }
  94.     }
  95.     {
  96.         for(UDWORD d=0; d < data.len2; d++)
  97.         {
  98.             out.put((unsigned char)data.data2[d]);
  99.         }
  100.     }
  101.     return out;
  102. }
  103.  
  104. std::istream &operator >> (std::istream &in,  FlashTagDefineBitsJPEG3 &data)
  105. {
  106.     UWORD id;
  107.     READ_UWORD(id);
  108.     READ_UDWORD(data.len);
  109.     data.SetID(id);    
  110.     {
  111.         data.data = (unsigned char *)malloc(data.len);
  112.         data.gc.push_back(data.data);
  113.         in.read((char *)data.data, data.len); //throw if not proper amount read
  114.     }
  115.  
  116.     {
  117.         data.data2 = (unsigned char *)malloc(data.importsize-data.len-6);
  118.         data.gc.push_back(data.data2);
  119.         in.read((char *)data.data2, data.importsize-data.len-6); //throw if not proper amount read
  120.         data.len2 = data.importsize-data.len-6;
  121.     }
  122.  
  123.     return in;
  124. }
  125.  
  126. void FlashZLibBitmapData::Write(std::ostream &out, char format)
  127. {
  128.     std::ostringstream tmp;
  129.  
  130.     for(std::vector<FlashRGB>::iterator i=colors.begin(); i != colors.end(); i++)
  131.     {
  132.         (*i).SetAlphaWriteMode(withalpha);
  133.         tmp << *i;        
  134.     }
  135.     tmp.write((const char *)data,len);
  136.  
  137.     unsigned long csize = tmp.str().size()+(UDWORD)(tmp.str().size()/100)+12;
  138.     unsigned char *compression_buffer = (unsigned char*)malloc(csize);
  139.     
  140.     if(compress2(compression_buffer, &csize, (const unsigned char*)tmp.str().c_str(), tmp.str().size(), Z_BEST_COMPRESSION) == Z_OK)
  141.     {
  142.         out.write((char*)compression_buffer,csize);
  143.     }
  144.     else
  145.     {        
  146.         //throw
  147.     }
  148.     free(compression_buffer);
  149. }
  150. void FlashZLibBitmapData::Read(std::istream &in, char format, UDWORD size, UDWORD size_buffer)
  151. {
  152.     int sizec = -1;
  153.     UDWORD len2 = size_buffer;
  154.     if(format==3)
  155.     {
  156.         sizec = in.get();
  157.         sizec++;
  158.         size_buffer +=sizec * 3;
  159.         if(GetAlpha()) size_buffer += sizec;
  160.     }
  161.     unsigned char *datatmp = (unsigned char *)malloc(size);
  162.     in.read((char *)datatmp,len);
  163.  
  164.     unsigned long csize = size_buffer;
  165.     unsigned char *compression_buffer = (unsigned char*)malloc(csize);
  166.     
  167.     gc.push_back(compression_buffer);
  168.  
  169.     if(uncompress(compression_buffer, &csize, datatmp, size) == Z_OK)
  170.     {
  171.         if(format == 3)
  172.         {
  173.             for(int it = 0; it < sizec; it++)
  174.             {            
  175.                 if(GetAlpha()) colors.push_back(FlashRGB(compression_buffer[it*4],compression_buffer[it*4]+1,compression_buffer[it*4]+2,compression_buffer[it*4]+3));
  176.                 else colors.push_back(FlashRGB(compression_buffer[it*3],compression_buffer[it*3]+1,compression_buffer[it*3]+2));
  177.             }
  178.             if(GetAlpha()) data = compression_buffer+sizec*4;
  179.             else          data = compression_buffer+sizec*3;            
  180.             len = len2;
  181.         }
  182.         else
  183.         {
  184.             data = compression_buffer;
  185.             len = len2;
  186.         }
  187.     }
  188.     else
  189.     {        
  190.         //throw
  191.     }
  192.     free(datatmp);
  193. }
  194.  
  195. std::ostream &operator << (std::ostream &out, FlashTagDefineBitsLossless &data)
  196. {
  197.     std::ostringstream tmp;
  198.     WRITE_UWORD2(data.GetID(),tmp);
  199.     tmp.put(data.format);
  200.     WRITE_UWORD2(data.width,tmp);
  201.     WRITE_UWORD2(data.height,tmp);
  202.     if(data.format==3) tmp.put((unsigned char)data.d.GetSize()-1);
  203.     data.d.SetAlpha(false);
  204.     data.d.Write(tmp,data.format);
  205.     out << FlashTagHeader(20, tmp.str().size());
  206.     out << tmp.str();
  207.     return out;
  208. }
  209.  
  210. std::istream &operator >> (std::istream &in,  FlashTagDefineBitsLossless &data)
  211. {
  212.     UWORD id;
  213.     READ_UWORD(id);
  214.     data.SetID(id);
  215.     data.format = in.get();
  216.     // if(data.format == EOF) throw;
  217.     READ_UWORD(data.width);
  218.     READ_UWORD(data.height);
  219.     data.d.SetAlpha(false);
  220.     int datasize = 0;
  221.     if(data.format == 3) datasize = data.width*data.height;
  222.     else if(data.format == 4) datasize = data.width*data.height*2;
  223.     else if(data.format == 5) datasize = data.width*data.height*4;
  224.     //else throw;
  225.     
  226.     data.d.Read(in,data.format,data.importsize - 7, datasize);
  227.  
  228.     return in;
  229. }
  230. std::ostream &operator << (std::ostream &out, FlashTagDefineBitsLossless2 &data)
  231. {
  232.     std::ostringstream tmp;
  233.     WRITE_UWORD2(data.GetID(),tmp);
  234.     tmp.put(data.format);
  235.     WRITE_UWORD2(data.width,tmp);
  236.     WRITE_UWORD2(data.height,tmp);
  237.     if(data.format==3) tmp.put((unsigned char)data.d.GetSize()-1);
  238.     data.d.SetAlpha(true);
  239.     data.d.Write(tmp,data.format);
  240.     out << FlashTagHeader(36, tmp.str().size());
  241.     out << tmp.str();
  242.  
  243.     return out;
  244. }
  245.  
  246. std::istream &operator >> (std::istream &in,  FlashTagDefineBitsLossless2 &data)
  247. {
  248.     UWORD id;
  249.     READ_UWORD(id);
  250.     data.SetID(id);
  251.     data.format = in.get();
  252.     // if(data.format == EOF) throw;
  253.     READ_UWORD(data.width);
  254.     READ_UWORD(data.height);
  255.     data.d.SetAlpha(true);
  256.     int datasize = 0;
  257.     if(data.format == 3) datasize = data.width*data.height;
  258.     else if(data.format == 4) datasize = data.width*data.height*2;
  259.     else if(data.format == 5) datasize = data.width*data.height*4;
  260.     //else throw;
  261.     
  262.     data.d.Read(in,data.format,data.importsize - 7, datasize);
  263.  
  264.     return in;
  265. }
  266.