开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
ximagif.h
资源名称：Client_win_src.rar　[点击查看]
上传用户：gnaf34
上传日期：2022-04-22
资源大小：1657k
文件大小：9k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

ximagif.h：源码内容
  1. /*
  2.  * File: ximagif.h
  3.  * Purpose: GIF Image Class Loader and Writer
  4.  */
  5. /* === C R E D I T S  &  D I S C L A I M E R S ==============
  6.  * CxImageICO (c) 07/Aug/2001 <ing.davide.pizzolato@libero.it>
  7.  * Permission is given by the author to freely redistribute and include
  8.  * this code in any program as long as this credit is given where due.
  9.  *
  10.  * CxImage version 5.00 23/Aug/2002
  11.  * See the file history.htm for the complete bugfix and news report.
  12.  *
  13.  * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
  14.  *
  15.  * original CImageGIF  and CImageIterator implementation are:
  16.  * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
  17.  *
  18.  * 6/15/97 Randy Spann: Added GIF87a writing support
  19.  *         R.Spann@ConnRiver.net
  20.  *
  21.  * DECODE.C - An LZW decoder for GIF
  22.  * Copyright (C) 1987, by Steven A. Bennett
  23.  * Copyright (C) 1994, C++ version by Alejandro Aguilar Sierra
  24.  *
  25.  * In accordance with the above, I want to credit Steve Wilhite who wrote
  26.  * the code which this is heavily inspired by...
  27.  *
  28.  * GIF and 'Graphics Interchange Format' are trademarks (tm) of
  29.  * Compuserve, Incorporated, an H&R Block Company.
  30.  *
  31.  * Release Notes: This file contains a decoder routine for GIF images
  32.  * which is similar, structurally, to the original routine by Steve Wilhite.
  33.  * It is, however, somewhat noticably faster in most cases.
  34.  *
  35.  * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
  36.  * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
  37.  * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
  38.  * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
  39.  * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
  40.  * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
  41.  * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
  42.  * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  43.  * THIS DISCLAIMER.
  44.  *
  45.  * Use at your own risk!
  46.  * ==========================================================
  47.  */
  49. #if !defined(__ximaGIF_h)
  50. #define __ximaGIF_h
  52. #include "ximage.h"
  54. #if CXIMAGE_SUPPORT_GIF
  56. #define CXIMAGE_GIF_COMPRESSION 1 //(0=NONE 1=RLE 2=LZW)
  58. typedef short int       code_int;   
  60. /* Various error codes used by decoder */
  61. #define OUT_OF_MEMORY -10
  62. #define BAD_CODE_SIZE -20
  63. #define READ_ERROR -1
  64. #define WRITE_ERROR -2
  65. #define OPEN_ERROR -3
  66. #define CREATE_ERROR -4
  67. #define MAX_CODES   4095
  68. #define GIFBUFTAM 16384
  69. #define TRANSPARENCY_CODE 0xF9
  71. //LZW GIF Image compression
  72. #define MAXBITSCODES    12
  73. #define HSIZE  5003     /* 80% occupancy */
  74. #define MAXCODE(n_bits) (((code_int) 1 << (n_bits)) - 1)
  75. #define HashTabOf(i)    htab[i]
  76. #define CodeTabOf(i)    codetab[i]
  79. class CImageIterator;
  80. class CxImageGIF: public CxImage
  81. {
  82. #pragma pack(1)
  84. typedef struct tag_gifgce{
  85.   BYTE transpcolflag:1;
  86.   BYTE userinputflag:1;
  87.   BYTE dispmeth:3;
  88.   BYTE res:3;
  89.   WORD delaytime;
  90.   BYTE transpcolindex;
  91. } struct_gifgce;
  93. typedef struct tag_dscgif{ /* Logic Screen Descriptor  */
  94.   char header[6]; /* Firma and version */
  95.   USHORT scrwidth;
  96.   USHORT scrheight;
  97.   char pflds;
  98.   char bcindx;
  99.   char pxasrat;
  100. } struct_dscgif;
  102. typedef struct tag_image{      /* Image Descriptor */
  103.   USHORT l;
  104.   USHORT t;
  105.   USHORT w;
  106.   USHORT h;
  107.   BYTE   pf;
  108. } struct_image;
  110. typedef struct tag_TabCol{ /* Tabla de colores */
  111.   short colres; /* color resolution */
  112.   short sogct; /* size of global color table */
  113.   rgb_color paleta[256]; /* paleta */
  114. } struct_TabCol;
  116. typedef struct tag_RLE{
  117. int rl_pixel;
  118. int rl_basecode;
  119. int rl_count;
  120. int rl_table_pixel;
  121. int rl_table_max;
  122. int just_cleared;
  123. int out_bits;
  124. int out_bits_init;
  125. int out_count;
  126. int out_bump;
  127. int out_bump_init;
  128. int out_clear;
  129. int out_clear_init;
  130. int max_ocodes;
  131. int code_clear;
  132. int code_eof;
  133. unsigned int obuf;
  134. int obits;
  135. unsigned char oblock[256];
  136. int oblen;
  137. } struct_RLE;
  138. #pragma pack()
  140. public:
  141. CxImageGIF(): CxImage(CXIMAGE_FORMAT_GIF) {m_loops=0; m_dispmeth=0; m_comment[0]='';}
  143. // bool Load(const char * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_GIF);}
  144. // bool Save(const char * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_GIF);}
  146. bool Decode(CxFile * fp);
  147. bool Encode(CxFile * fp);
  148. bool Encode(CxFile * fp, CxImage ** pImages, int pagecount);
  150. bool Decode(FILE *fp) { CxIOFile file(fp); return Decode(&file); }
  151. bool Encode(FILE *fp) { CxIOFile file(fp); return Encode(&file); }
  152. bool Encode(FILE *fp, CxImage ** pImages, int pagecount)
  153. { CxIOFile file(fp); return Encode(&file, pImages, pagecount); }
  155. void SetLoops(int loops);
  156. long GetLoops();
  157. void SetComment(const char* sz_comment_in);
  158. void GetComment(char* sz_comment_out);
  159. void SetDisposalMethod(int dm);
  160. long GetDisposalMethod();
  162. protected:
  163. bool DecodeExtension(CxFile *fp);
  164. void EncodeHeader(CxFile *fp);
  165. void EncodeLoopExtension(CxFile *fp);
  166. void EncodeExtension(CxFile *fp);
  167. void EncodeBody(CxFile *fp, bool bLocalColorMap = false);
  168. void EncodeComment(CxFile *fp);
  169. bool EncodeRGB(CxFile *fp);
  170. void GifMix(CxImage & imgsrc2, long lxOffset, long lyOffset);
  172. struct_gifgce gifgce;
  174. int             curx, cury;
  175. long             CountDown;
  176. unsigned long    cur_accum;
  177. int              cur_bits;
  178. int interlaced, iypos, istep, iheight, ipass;
  179. int ibf;
  180. int ibfmax;
  181. BYTE buf[GIFBUFTAM + 1];
  182. // Implementation
  183. int GifNextPixel ();
  184. void Putword (int w, CxFile* fp );
  185. void compressNONE (int init_bits, CxFile* outfile);
  186. void compressLZW (int init_bits, CxFile* outfile);
  187. void output (code_int code );
  188. void cl_hash (long hsize);
  189. void char_out (int c);
  190. void flush_char ();
  191. short init_exp(short size);
  192. short get_next_code(CxFile*);
  193. short decoder(CxFile*, CImageIterator* iter, short linewidth, int &bad_code_count);
  194. int get_byte(CxFile*);
  195. int out_line(CImageIterator* iter, unsigned char *pixels, int linelen);
  196. int get_num_frames(CxFile *f);
  198. short curr_size;                     /* The current code size */
  199. short clear;                         /* Value for a clear code */
  200. short ending;                        /* Value for a ending code */
  201. short newcodes;                      /* First available code */
  202. short top_slot;                      /* Highest code for current size */
  203. short slot;                          /* Last read code */
  205. /* The following static variables are used
  206. * for seperating out codes */
  207. short navail_bytes;              /* # bytes left in block */
  208. short nbits_left;                /* # bits left in current BYTE */
  209. BYTE b1;                           /* Current BYTE */
  210. BYTE byte_buff[257];               /* Current block */
  211. BYTE *pbytes;                      /* Pointer to next BYTE in block */
  212. /* The reason we have these seperated like this instead of using
  213. * a structure like the original Wilhite code did, is because this
  214. * stuff generally produces significantly faster code when compiled...
  215. * This code is full of similar speedups...  (For a good book on writing
  216. * C for speed or for space optomisation, see Efficient C by Tom Plum,
  217. * published by Plum-Hall Associates...)
  218. */
  219. BYTE stack[MAX_CODES + 1];            /* Stack for storing pixels */
  220. BYTE suffix[MAX_CODES + 1];           /* Suffix table */
  221. USHORT prefix[MAX_CODES + 1];           /* Prefix linked list */
  223. //LZW GIF Image compression routines
  224. long htab [HSIZE];
  225. unsigned short codetab [HSIZE];
  226. int n_bits; /* number of bits/code */
  227. code_int maxcode; /* maximum code, given n_bits */
  228. code_int free_ent; /* first unused entry */
  229. int clear_flg;
  230. int g_init_bits;
  231. CxFile* g_outfile;
  232. int ClearCode;
  233. int EOFCode;
  235. int a_count;
  236. char accum[256];
  238. char m_comment[256];
  239. int m_loops;
  240. int m_dispmeth;
  242. //RLE compression routines
  243. void compressRLE( int init_bits, CxFile* outfile);
  244. void rle_clear(struct_RLE* rle);
  245. void rle_flush(struct_RLE* rle);
  246. void rle_flush_withtable(int count, struct_RLE* rle);
  247. void rle_flush_clearorrep(int count, struct_RLE* rle);
  248. void rle_flush_fromclear(int count,struct_RLE* rle);
  249. void rle_output_plain(int c,struct_RLE* rle);
  250. void rle_reset_out_clear(struct_RLE* rle);
  251. unsigned int rle_compute_triangle_count(unsigned int count, unsigned int nrepcodes);
  252. unsigned int rle_isqrt(unsigned int x);
  253. void rle_write_block(struct_RLE* rle);
  254. void rle_block_out(unsigned char c, struct_RLE* rle);
  255. void rle_block_flush(struct_RLE* rle);
  256. void rle_output(int val, struct_RLE* rle);
  257. void rle_output_flush(struct_RLE* rle);
  258. };
  260. #endif
  262. #endif