ximagif.h
上传用户:pass2008
上传日期:2021-07-05
资源大小:3299k
文件大小:8k
源码类别:

Internet/IE编程

开发平台:

Visual C++

  1. /*
  2.  * File: ximagif.h
  3.  * Purpose: GIF Image Class Loader and Writer
  4.  */
  5. /* ==========================================================
  6.  * CxImageGIF (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
  7.  * For conditions of distribution and use, see copyright notice in ximage.h
  8.  *
  9.  * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
  10.  *
  11.  * original CImageGIF  and CImageIterator implementation are:
  12.  * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
  13.  *
  14.  * 6/15/97 Randy Spann: Added GIF87a writing support
  15.  *         R.Spann@ConnRiver.net
  16.  *
  17.  * DECODE.C - An LZW decoder for GIF
  18.  * Copyright (C) 1987, by Steven A. Bennett
  19.  * Copyright (C) 1994, C++ version by Alejandro Aguilar Sierra
  20.  *
  21.  * In accordance with the above, I want to credit Steve Wilhite who wrote
  22.  * the code which this is heavily inspired by...
  23.  *
  24.  * GIF and 'Graphics Interchange Format' are trademarks (tm) of
  25.  * Compuserve, Incorporated, an H&R Block Company.
  26.  *
  27.  * Release Notes: This file contains a decoder routine for GIF images
  28.  * which is similar, structurally, to the original routine by Steve Wilhite.
  29.  * It is, however, somewhat noticably faster in most cases.
  30.  *
  31.  * ==========================================================
  32.  */
  33. #if !defined(__ximaGIF_h)
  34. #define __ximaGIF_h
  35. #include "ximage.h"
  36. #if CXIMAGE_SUPPORT_GIF
  37. typedef short int       code_int;   
  38. /* Various error codes used by decoder */
  39. #define OUT_OF_MEMORY -10
  40. #define BAD_CODE_SIZE -20
  41. #define READ_ERROR -1
  42. #define WRITE_ERROR -2
  43. #define OPEN_ERROR -3
  44. #define CREATE_ERROR -4
  45. #define MAX_CODES   4095
  46. #define GIFBUFTAM 16383
  47. #define TRANSPARENCY_CODE 0xF9
  48. //LZW GIF Image compression
  49. #define MAXBITSCODES    12
  50. #define HSIZE  5003     /* 80% occupancy */
  51. #define MAXCODE(n_bits) (((code_int) 1 << (n_bits)) - 1)
  52. #define HashTabOf(i)    htab[i]
  53. #define CodeTabOf(i)    codetab[i]
  54. class CImageIterator;
  55. class DLL_EXP CxImageGIF: public CxImage
  56. {
  57. #pragma pack(1)
  58. typedef struct tag_gifgce{
  59.   BYTE flags; /*res:3|dispmeth:3|userinputflag:1|transpcolflag:1*/
  60.   WORD delaytime;
  61.   BYTE transpcolindex;
  62. } struct_gifgce;
  63. typedef struct tag_dscgif{ /* Logic Screen Descriptor  */
  64.   char header[6]; /* Firma and version */
  65.   WORD scrwidth;
  66.   WORD scrheight;
  67.   char pflds;
  68.   char bcindx;
  69.   char pxasrat;
  70. } struct_dscgif;
  71. typedef struct tag_image{      /* Image Descriptor */
  72.   WORD l;
  73.   WORD t;
  74.   WORD w;
  75.   WORD h;
  76.   BYTE   pf;
  77. } struct_image;
  78. typedef struct tag_TabCol{ /* Tabla de colores */
  79.   short colres; /* color resolution */
  80.   short sogct; /* size of global color table */
  81.   rgb_color paleta[256]; /* paleta */
  82. } struct_TabCol;
  83. typedef struct tag_RLE{
  84. int rl_pixel;
  85. int rl_basecode;
  86. int rl_count;
  87. int rl_table_pixel;
  88. int rl_table_max;
  89. int just_cleared;
  90. int out_bits;
  91. int out_bits_init;
  92. int out_count;
  93. int out_bump;
  94. int out_bump_init;
  95. int out_clear;
  96. int out_clear_init;
  97. int max_ocodes;
  98. int code_clear;
  99. int code_eof;
  100. unsigned int obuf;
  101. int obits;
  102. unsigned char oblock[256];
  103. int oblen;
  104. } struct_RLE;
  105. #pragma pack()
  106. public:
  107. CxImageGIF(): CxImage(CXIMAGE_FORMAT_GIF) {m_loops=0; info.dispmeth=0; m_comment[0]='';}
  108. // bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_GIF);}
  109. // bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_GIF);}
  110. bool Decode(CxFile * fp);
  111. bool Decode(FILE *fp) { CxIOFile file(fp); return Decode(&file); }
  112. #if CXIMAGE_SUPPORT_ENCODE
  113. bool Encode(CxFile * fp);
  114. bool Encode(CxFile * fp, CxImage ** pImages, int pagecount, bool bLocalColorMap = false, bool bLocalDispMeth = false);
  115. bool Encode(FILE *fp) { CxIOFile file(fp); return Encode(&file); }
  116. bool Encode(FILE *fp, CxImage ** pImages, int pagecount, bool bLocalColorMap = false)
  117. { CxIOFile file(fp); return Encode(&file, pImages, pagecount, bLocalColorMap); }
  118. #endif // CXIMAGE_SUPPORT_ENCODE
  119. void SetLoops(int loops);
  120. long GetLoops();
  121. void SetComment(const char* sz_comment_in);
  122. void GetComment(char* sz_comment_out);
  123. protected:
  124. bool DecodeExtension(CxFile *fp);
  125. void EncodeHeader(CxFile *fp);
  126. void EncodeLoopExtension(CxFile *fp);
  127. void EncodeExtension(CxFile *fp);
  128. void EncodeBody(CxFile *fp, bool bLocalColorMap = false);
  129. void EncodeComment(CxFile *fp);
  130. bool EncodeRGB(CxFile *fp);
  131. void GifMix(CxImage & imgsrc2, struct_image & imgdesc);
  132. struct_gifgce gifgce;
  133. int             curx, cury;
  134. long             CountDown;
  135. unsigned long    cur_accum;
  136. int              cur_bits;
  137. int interlaced, iypos, istep, iheight, ipass;
  138. int ibf;
  139. int ibfmax;
  140. BYTE buf[GIFBUFTAM + 1];
  141. // Implementation
  142. int GifNextPixel ();
  143. void Putword (int w, CxFile* fp );
  144. void compressNONE (int init_bits, CxFile* outfile);
  145. void compressLZW (int init_bits, CxFile* outfile);
  146. void output (code_int code );
  147. void cl_hash (long hsize);
  148. void char_out (int c);
  149. void flush_char ();
  150. short init_exp(short size);
  151. short get_next_code(CxFile*);
  152. short decoder(CxFile*, CImageIterator* iter, short linewidth, int &bad_code_count);
  153. int get_byte(CxFile*);
  154. int out_line(CImageIterator* iter, unsigned char *pixels, int linelen);
  155. int get_num_frames(CxFile *f,struct_TabCol* TabColSrc,struct_dscgif* dscgif);
  156. long seek_next_image(CxFile* fp, long position);
  157. short curr_size;                     /* The current code size */
  158. short clear;                         /* Value for a clear code */
  159. short ending;                        /* Value for a ending code */
  160. short newcodes;                      /* First available code */
  161. short top_slot;                      /* Highest code for current size */
  162. short slot;                          /* Last read code */
  163. /* The following static variables are used
  164. * for seperating out codes */
  165. short navail_bytes;              /* # bytes left in block */
  166. short nbits_left;                /* # bits left in current BYTE */
  167. BYTE b1;                           /* Current BYTE */
  168. BYTE byte_buff[257];               /* Current block */
  169. BYTE *pbytes;                      /* Pointer to next BYTE in block */
  170. /* The reason we have these seperated like this instead of using
  171. * a structure like the original Wilhite code did, is because this
  172. * stuff generally produces significantly faster code when compiled...
  173. * This code is full of similar speedups...  (For a good book on writing
  174. * C for speed or for space optomisation, see Efficient C by Tom Plum,
  175. * published by Plum-Hall Associates...)
  176. */
  177. BYTE stack[MAX_CODES + 1];            /* Stack for storing pixels */
  178. BYTE suffix[MAX_CODES + 1];           /* Suffix table */
  179. WORD prefix[MAX_CODES + 1];           /* Prefix linked list */
  180. //LZW GIF Image compression routines
  181. long htab [HSIZE];
  182. unsigned short codetab [HSIZE];
  183. int n_bits; /* number of bits/code */
  184. code_int maxcode; /* maximum code, given n_bits */
  185. code_int free_ent; /* first unused entry */
  186. int clear_flg;
  187. int g_init_bits;
  188. CxFile* g_outfile;
  189. int ClearCode;
  190. int EOFCode;
  191. int a_count;
  192. char accum[256];
  193. char m_comment[256];
  194. int m_loops;
  195. //RLE compression routines
  196. void compressRLE( int init_bits, CxFile* outfile);
  197. void rle_clear(struct_RLE* rle);
  198. void rle_flush(struct_RLE* rle);
  199. void rle_flush_withtable(int count, struct_RLE* rle);
  200. void rle_flush_clearorrep(int count, struct_RLE* rle);
  201. void rle_flush_fromclear(int count,struct_RLE* rle);
  202. void rle_output_plain(int c,struct_RLE* rle);
  203. void rle_reset_out_clear(struct_RLE* rle);
  204. unsigned int rle_compute_triangle_count(unsigned int count, unsigned int nrepcodes);
  205. unsigned int rle_isqrt(unsigned int x);
  206. void rle_write_block(struct_RLE* rle);
  207. void rle_block_out(unsigned char c, struct_RLE* rle);
  208. void rle_block_flush(struct_RLE* rle);
  209. void rle_output(int val, struct_RLE* rle);
  210. void rle_output_flush(struct_RLE* rle);
  211. };
  212. #endif
  213. #endif