source: liacs/MIR2010/SourceCode/cximage/ximagif.cpp@ 232

Last change on this file since 232 was 95, checked in by Rick van der Zwet, 15 years ago

Bad boy, improper move of directory
File size: 47.9 KB
RevLine 
[95]1/*
2 * File: ximagif.cpp
3 * Purpose: Platform Independent GIF Image Class Loader and Writer
4 * 07/Aug/2001 Davide Pizzolato - www.xdp.it
5 * CxImage version 6.0.0 02/Feb/2008
6 */
7
8#include "ximagif.h"
9
10#if CXIMAGE_SUPPORT_GIF
11
12#include "ximaiter.h"
13
14#if defined (_WIN32_WCE)
15 #define assert(s)
16#else
17 #include <assert.h>
18#endif
19
20////////////////////////////////////////////////////////////////////////////////
21#if CXIMAGE_SUPPORT_DECODE
22////////////////////////////////////////////////////////////////////////////////
23bool CxImageGIF::Decode(CxFile *fp)
24{
25 /* AD - for transparency */
26 struct_dscgif dscgif;
27 struct_image image;
28 struct_TabCol TabCol;
29
30 if (fp == NULL) return false;
31
32 fp->Read(&dscgif,/*sizeof(dscgif)*/13,1);
33 //if (strncmp(dscgif.header,"GIF8",3)!=0) {
34 if (strncmp(dscgif.header,"GIF8",4)!=0) return FALSE;
35
36 // Avoid Byte order problem with Mac <AMSN>
37 dscgif.scrheight = ntohs(dscgif.scrheight);
38 dscgif.scrwidth = ntohs(dscgif.scrwidth);
39
40 if (info.nEscape == -1) {
41 // Return output dimensions only
42 head.biWidth = dscgif.scrwidth;
43 head.biHeight = dscgif.scrheight;
44 info.dwType = CXIMAGE_FORMAT_GIF;
45 return true;
46 }
47
48 /* AD - for interlace */
49 TabCol.sogct = (short)(1 << ((dscgif.pflds & 0x07)+1));
50 TabCol.colres = (short)(((dscgif.pflds & 0x70) >> 4) + 1);
51
52 // assume that the image is a truecolor-gif if
53 // 1) no global color map found
54 // 2) (image.w, image.h) of the 1st image != (dscgif.scrwidth, dscgif.scrheight)
55 long bTrueColor=0;
56 CxImage* imaRGB=NULL;
57
58 // Global colour map?
59 if (dscgif.pflds & 0x80)
60 fp->Read(TabCol.paleta,sizeof(struct rgb_color)*TabCol.sogct,1);
61 else
62 bTrueColor++; //first chance for a truecolor gif
63
64 long first_transparent_index = 0;
65
66 int iImage = 0;
67 info.nNumFrames=get_num_frames(fp,&TabCol,&dscgif);
68
69 if ((info.nFrame<0)||(info.nFrame>=info.nNumFrames)) return false;
70
71 //it cannot be a true color GIF with only one frame
72 if (info.nNumFrames == 1)
73 bTrueColor=0;
74
75 char ch;
76 bool bPreviousWasNull = true;
77 int prevdispmeth = 0;
78 CxImage *previousFrame = NULL;
79
80 for (BOOL bContinue = TRUE; bContinue; )
81 {
82 if (fp->Read(&ch, sizeof(ch), 1) != 1) {break;}
83
84 if (info.nEscape > 0) return false; // <vho> - cancel decoding
85 if (bPreviousWasNull || ch==0)
86 {
87 switch (ch)
88 {
89 case '!': // extension
90 {
91 bContinue = DecodeExtension(fp);
92 break;
93 }
94 case ',': // image
95 {
96 assert(sizeof(image) == 9);
97 fp->Read(&image,sizeof(image),1);
98 //avoid byte order problems with Solaris <candan> <AMSN>
99 image.l = ntohs(image.l);
100 image.t = ntohs(image.t);
101 image.w = ntohs(image.w);
102 image.h = ntohs(image.h);
103
104 if (((image.l + image.w) > dscgif.scrwidth)||((image.t + image.h) > dscgif.scrheight))
105 break;
106
107 // check if it could be a truecolor gif
108 if ((iImage==0) && (image.w != dscgif.scrwidth) && (image.h != dscgif.scrheight))
109 bTrueColor++;
110
111 rgb_color locpal[256]; //Local Palette
112 rgb_color* pcurpal = TabCol.paleta; //Current Palette
113 short palcount = TabCol.sogct; //Current Palette color count
114
115 // Local colour map?
116 if (image.pf & 0x80) {
117 palcount = (short)(1 << ((image.pf & 0x07) +1));
118 assert(3 == sizeof(struct rgb_color));
119 fp->Read(locpal,sizeof(struct rgb_color)*palcount,1);
120 pcurpal = locpal;
121 }
122
123 int bpp; //<DP> select the correct bit per pixel value
124 if (palcount <= 2) bpp = 1;
125 else if (palcount <= 16) bpp = 4;
126 else bpp = 8;
127
128 CxImageGIF backimage;
129 backimage.CopyInfo(*this);
130 if (iImage==0){
131 //first frame: build image background
132 backimage.Create(dscgif.scrwidth, dscgif.scrheight, bpp, CXIMAGE_FORMAT_GIF);
133 first_transparent_index = info.nBkgndIndex;
134 backimage.Clear((BYTE)gifgce.transpcolindex);
135 previousFrame = new CxImage(backimage);
136 previousFrame->SetRetreiveAllFrames(false);
137 } else {
138 //generic frame: handle disposal method from previous one
139 /*Values : 0 - No disposal specified. The decoder is
140 not required to take any action.
141 1 - Do not dispose. The graphic is to be left
142 in place.
143 2 - Restore to background color. The area used by the
144 graphic must be restored to the background color.
145 3 - Restore to previous. The decoder is required to
146 restore the area overwritten by the graphic with
147 what was there prior to rendering the graphic.
148 */
149 /* backimage.Copy(*this);
150 if (prevdispmeth==2){
151 backimage.Clear((BYTE)first_transparent_index);
152 }*/
153 if (prevdispmeth==2){
154 backimage.Copy(*this,false,false,false);
155 backimage.Clear((BYTE)first_transparent_index);
156 } else if (prevdispmeth==3) {
157 backimage.Copy(*this,false,false,false);
158 backimage.Create(previousFrame->GetWidth(),
159 previousFrame->GetHeight(),
160 previousFrame->GetBpp(),CXIMAGE_FORMAT_GIF);
161 memcpy(backimage.GetDIB(),previousFrame->GetDIB(),
162 backimage.GetSize());
163 backimage.AlphaSet(*previousFrame);
164 } else {
165 backimage.Copy(*this);
166 }
167 }
168
169 //active frame
170 Create(image.w, image.h, bpp, CXIMAGE_FORMAT_GIF);
171
172 if ((image.pf & 0x80) || (dscgif.pflds & 0x80)) {
173 unsigned char r[256], g[256], b[256];
174 int i, has_white = 0;
175
176 for (i=0; i < palcount; i++) {
177 r[i] = pcurpal[i].r;
178 g[i] = pcurpal[i].g;
179 b[i] = pcurpal[i].b;
180 if (RGB(r[i],g[i],b[i]) == 0xFFFFFF) has_white = 1;
181 }
182
183 // Force transparency colour white...
184 //if (0) if (info.nBkgndIndex >= 0)
185 // r[info.nBkgndIndex] = g[info.nBkgndIndex] = b[info.nBkgndIndex] = 255;
186 // Fill in with white // AD
187 if (info.nBkgndIndex >= 0) {
188 while (i < 256) {
189 has_white = 1;
190 r[i] = g[i] = b[i] = 255;
191 i++;
192 }
193 }
194
195 // Force last colour to white... // AD
196 //if ((info.nBkgndIndex >= 0) && !has_white) {
197 // r[255] = g[255] = b[255] = 255;
198 //}
199
200 SetPalette((info.nBkgndIndex >= 0 ? 256 : palcount), r, g, b);
201 }
202
203 CImageIterator* iter = new CImageIterator(this);
204 iter->Upset();
205 int badcode=0;
206 ibf = GIFBUFTAM+1;
207
208 interlaced = image.pf & 0x40;
209 iheight = image.h;
210 istep = 8;
211 iypos = 0;
212 ipass = 0;
213
214 long pos_start = fp->Tell();
215 //if (interlaced) log << "Interlaced" << endl;
216 decoder(fp, iter, image.w, badcode);
217 delete iter;
218
219 if (info.nEscape) return false; // <vho> - cancel decoding
220
221 if (bTrueColor<2 ){ //standard GIF: mix frame with background
222 backimage.GifMix(*this,image);
223 backimage.SetTransIndex(first_transparent_index);
224 backimage.SetPalette(GetPalette());
225 Transfer(backimage,false);
226 } else { //it's a truecolor gif!
227 //force full image decoding
228 info.nFrame=info.nNumFrames-1;
229 //build the RGB image
230 if (imaRGB==NULL) imaRGB = new CxImage(dscgif.scrwidth,dscgif.scrheight,24,CXIMAGE_FORMAT_GIF);
231 //copy the partial image into the full RGB image
232 for(long y=0;y<image.h;y++){
233 for (long x=0;x<image.w;x++){
234 imaRGB->SetPixelColor(x+image.l,dscgif.scrheight-1-image.t-y,GetPixelColor(x,image.h-y-1));
235 }
236 }
237 }
238
239 prevdispmeth = (gifgce.flags >> 2) & 0x7;
240
241 //restore the correct position in the file for the next image
242 if (badcode){
243 seek_next_image(fp,pos_start);
244 } else {
245 fp->Seek(-(ibfmax - ibf - 1), SEEK_CUR);
246 }
247
248 if (info.bGetAllFrames && imaRGB == NULL) {
249 if (iImage == 0) {
250 DestroyFrames();
251 ppFrames = new CxImage*[info.nNumFrames];
252 for(int frameIdx = 0; frameIdx < info.nNumFrames; frameIdx++){
253 ppFrames[frameIdx] = NULL;
254 }
255 }
256 ppFrames[iImage] = new CxImage(*this);
257 ppFrames[iImage]->SetRetreiveAllFrames(false);
258 }
259 if (prevdispmeth <= 1) {
260 delete previousFrame;
261 previousFrame = new CxImage(*this);
262 previousFrame->SetRetreiveAllFrames(false);
263 }
264
265 if (info.nFrame==iImage) bContinue=false; else iImage++;
266
267 break;
268 }
269 case ';': //terminator
270 bContinue=false;
271 break;
272 default:
273 bPreviousWasNull = (ch==0);
274 break;
275 }
276 }
277 }
278
279 if (bTrueColor>=2 && imaRGB){
280 if (gifgce.flags & 0x1){
281 imaRGB->SetTransColor(GetPaletteColor((BYTE)info.nBkgndIndex));
282 imaRGB->SetTransIndex(0);
283 }
284 Transfer(*imaRGB);
285 }
286 delete imaRGB;
287
288 delete previousFrame;
289
290 return true;
291
292}
293////////////////////////////////////////////////////////////////////////////////
294bool CxImageGIF::DecodeExtension(CxFile *fp)
295{
296 bool bContinue;
297 unsigned char count;
298 unsigned char fc;
299
300 bContinue = (1 == fp->Read(&fc, sizeof(fc), 1));
301 if (bContinue) {
302 /* AD - for transparency */
303 if (fc == 0xF9) {
304 bContinue = (1 == fp->Read(&count, sizeof(count), 1));
305 if (bContinue) {
306 assert(sizeof(gifgce) == 4);
307 bContinue = (count == fp->Read(&gifgce, 1, sizeof(gifgce)));
308 gifgce.delaytime = ntohs(gifgce.delaytime); // Avoid Byte order problem with Mac <AMSN>
309 if (bContinue) {
310 info.nBkgndIndex = (gifgce.flags & 0x1) ? gifgce.transpcolindex : -1;
311 info.dwFrameDelay = gifgce.delaytime;
312 SetDisposalMethod((gifgce.flags >> 2) & 0x7);
313 } } }
314
315 if (fc == 0xFE) { //<DP> Comment block
316 bContinue = (1 == fp->Read(&count, sizeof(count), 1));
317 if (bContinue) {
318 bContinue = (1 == fp->Read(m_comment, count, 1));
319 m_comment[count]='\0';
320 } }
321
322 if (fc == 0xFF) { //<DP> Application Extension block
323 bContinue = (1 == fp->Read(&count, sizeof(count), 1));
324 if (bContinue) {
325 bContinue = (count==11);
326 if (bContinue){
327 char AppID[11];
328 bContinue = (1 == fp->Read(AppID, count, 1));
329 if (bContinue) {
330 bContinue = (1 == fp->Read(&count, sizeof(count), 1));
331 if (bContinue) {
332 BYTE* dati = (BYTE*)malloc(count);
333 bContinue = (dati!=NULL);
334 if (bContinue){
335 bContinue = (1 == fp->Read(dati, count, 1));
336 if (count>2){
337 m_loops = dati[1]+256*dati[2];
338 }
339 }
340 free(dati);
341 } } } } }
342
343 while (bContinue && fp->Read(&count, sizeof(count), 1) && count) {
344 //log << "Skipping " << count << " bytes" << endl;
345 fp->Seek(count, SEEK_CUR);
346 }
347 }
348 return bContinue;
349
350}
351////////////////////////////////////////////////////////////////////////////////
352#endif //CXIMAGE_SUPPORT_DECODE
353////////////////////////////////////////////////////////////////////////////////
354
355// - This external (machine specific) function is expected to return
356// either the next BYTE from the GIF file, or a negative error number.
357int CxImageGIF::get_byte(CxFile* file)
358{
359 if (ibf>=GIFBUFTAM){
360 // FW 06/02/98 >>>
361 ibfmax = (int)file->Read( buf , 1 , GIFBUFTAM) ;
362 if( ibfmax < GIFBUFTAM ) buf[ ibfmax ] = 255 ;
363 // FW 06/02/98 <<<
364 ibf = 0;
365 }
366 if (ibf>=ibfmax) return -1; //<DP> avoid overflows
367 return buf[ibf++];
368}
369////////////////////////////////////////////////////////////////////////////////
370/* - This function takes a full line of pixels (one BYTE per pixel) and
371 * displays them (or does whatever your program wants with them...). It
372 * should return zero, or negative if an error or some other event occurs
373 * which would require aborting the decode process... Note that the length
374 * passed will almost always be equal to the line length passed to the
375 * decoder function, with the sole exception occurring when an ending code
376 * occurs in an odd place in the GIF file... In any case, linelen will be
377 * equal to the number of pixels passed...
378*/
379int CxImageGIF::out_line(CImageIterator* iter, unsigned char *pixels, int linelen)
380{
381 if (iter == NULL || pixels == NULL)
382 return -1;
383
384 //<DP> for 1 & 4 bpp images, the pixels are compressed
385 if (head.biBitCount < 8){
386 for(long x=0;x<head.biWidth;x++){
387 BYTE pos;
388 BYTE* iDst= pixels + (x*head.biBitCount >> 3);
389 if (head.biBitCount==4){
390 pos = (BYTE)(4*(1-x%2));
391 *iDst &= ~(0x0F<<pos);
392 *iDst |= ((pixels[x] & 0x0F)<<pos);
393 } else if (head.biBitCount==1){
394 pos = (BYTE)(7-x%8);
395 *iDst &= ~(0x01<<pos);
396 *iDst |= ((pixels[x] & 0x01)<<pos);
397 }
398 }
399 }
400
401 /* AD - for interlace */
402 if (interlaced) {
403 iter->SetY(iheight-iypos-1);
404 iter->SetRow(pixels, linelen);
405
406 if ((iypos += istep) >= iheight) {
407 do {
408 if (ipass++ > 0) istep /= 2;
409 iypos = istep / 2;
410 }
411 while (iypos > iheight);
412 }
413 return 0;
414 } else {
415 if (iter->ItOK()) {
416 iter->SetRow(pixels, linelen);
417 (void)iter->PrevRow();
418 return 0;
419 } else {
420 // puts("chafeo");
421 return -1;
422 }
423 }
424}
425////////////////////////////////////////////////////////////////////////////////
426#if CXIMAGE_SUPPORT_ENCODE
427////////////////////////////////////////////////////////////////////////////////
428// SaveFile - writes GIF87a gif file
429// Randy Spann 6/15/97
430// R.Spann@ConnRiver.net
431bool CxImageGIF::Encode(CxFile * fp)
432{
433 if (EncodeSafeCheck(fp)) return false;
434
435 if(head.biBitCount > 8) {
436 //strcpy(info.szLastError,"GIF Images must be 8 bit or less");
437 //return FALSE;
438 return EncodeRGB(fp);
439 }
440
441 if ( GetNumFrames()>1 && ppFrames ) {
442 return Encode(fp, ppFrames, GetNumFrames() );
443 }
444
445 EncodeHeader(fp);
446
447 EncodeExtension(fp);
448
449 EncodeComment(fp);
450
451 EncodeBody(fp);
452
453 fp->PutC(';'); // Write the GIF file terminator
454
455 return true; // done!
456}
457////////////////////////////////////////////////////////////////////////////////
458bool CxImageGIF::Encode(CxFile * fp, CxImage ** pImages, int pagecount, bool bLocalColorMap, bool bLocalDispMeth)
459{
460 cx_try {
461 if (fp==NULL) cx_throw("invalid file pointer");
462 if (pImages==NULL || pagecount<=0 || pImages[0]==NULL) cx_throw("multipage GIF, no images!");
463
464 int i;
465 for (i=0; i<pagecount; i++){
466 if (pImages[i]==NULL)
467 cx_throw("Bad image pointer");
468 if (!(pImages[i]->IsValid()))
469 cx_throw("Empty image");
470 if (pImages[i]->GetNumColors()==0)
471 cx_throw("CxImageGIF::Encode cannot create animated GIFs with a true color frame. Use DecreaseBpp before");
472 }
473
474 CxImageGIF ghost;
475
476 //write the first image
477 ghost.Ghost(pImages[0]);
478 ghost.EncodeHeader(fp);
479
480 if (m_loops!=1){
481 ghost.SetLoops(max(0,m_loops-1));
482 ghost.EncodeLoopExtension(fp);
483 }
484
485 if (bLocalDispMeth) {
486 ghost.EncodeExtension(fp);
487 } else {
488 BYTE dm = ghost.GetDisposalMethod();
489 ghost.SetDisposalMethod(GetDisposalMethod());
490 ghost.EncodeExtension(fp);
491 ghost.SetDisposalMethod(dm);
492 }
493
494 EncodeComment(fp);
495
496 ghost.EncodeBody(fp);
497
498 for (i=1; i<pagecount; i++){
499 ghost.Ghost(pImages[i]);
500
501 if (bLocalDispMeth) {
502 ghost.EncodeExtension(fp);
503 } else {
504 BYTE dm = ghost.GetDisposalMethod();
505 ghost.SetDisposalMethod(GetDisposalMethod());
506 ghost.EncodeExtension(fp);
507 ghost.SetDisposalMethod(dm);
508 }
509
510 ghost.EncodeBody(fp,bLocalColorMap);
511 }
512
513 fp->PutC(';'); // Write the GIF file terminator
514
515 } cx_catch {
516 if (strcmp(message,"")) strncpy(info.szLastError,message,255);
517 return false;
518 }
519 return true;
520}
521////////////////////////////////////////////////////////////////////////////////
522void CxImageGIF::EncodeHeader(CxFile *fp)
523{
524 fp->Write("GIF89a",1,6); //GIF Header
525
526 Putword(head.biWidth,fp); //Logical screen descriptor
527 Putword(head.biHeight,fp);
528
529 BYTE Flags;
530 if (head.biClrUsed==0){
531 Flags=0x11;
532 } else {
533 Flags = 0x80;
534 Flags |=(head.biBitCount - 1) << 5;
535 Flags |=(head.biBitCount - 1);
536 }
537
538 fp->PutC(Flags); //GIF "packed fields"
539 fp->PutC(0); //GIF "BackGround"
540 fp->PutC(0); //GIF "pixel aspect ratio"
541
542 if (head.biClrUsed!=0){
543 RGBQUAD* pPal = GetPalette();
544 for(DWORD i=0; i<head.biClrUsed; ++i)
545 {
546 fp->PutC(pPal[i].rgbRed);
547 fp->PutC(pPal[i].rgbGreen);
548 fp->PutC(pPal[i].rgbBlue);
549 }
550 }
551}
552////////////////////////////////////////////////////////////////////////////////
553void CxImageGIF::EncodeExtension(CxFile *fp)
554{
555 // TRK BEGIN : transparency
556 fp->PutC('!');
557 fp->PutC(TRANSPARENCY_CODE);
558
559 gifgce.flags = 0;
560 gifgce.flags |= ((info.nBkgndIndex != -1) ? 1 : 0);
561 gifgce.flags |= ((GetDisposalMethod() & 0x7) << 2);
562 gifgce.delaytime = (WORD)info.dwFrameDelay;
563 gifgce.transpcolindex = (BYTE)info.nBkgndIndex;
564
565 //Invert byte order in case we use a byte order arch, then set it back <AMSN>
566 gifgce.delaytime = ntohs(gifgce.delaytime);
567 fp->PutC(sizeof(gifgce));
568 fp->Write(&gifgce, sizeof(gifgce), 1);
569 gifgce.delaytime = ntohs(gifgce.delaytime);
570
571 fp->PutC(0);
572 // TRK END
573}
574////////////////////////////////////////////////////////////////////////////////
575void CxImageGIF::EncodeLoopExtension(CxFile *fp)
576{
577 fp->PutC('!'); //byte 1 : 33 (hex 0x21) GIF Extension code
578 fp->PutC(255); //byte 2 : 255 (hex 0xFF) Application Extension Label
579 fp->PutC(11); //byte 3 : 11 (hex (0x0B) Length of Application Block (eleven bytes of data to follow)
580 fp->Write("NETSCAPE2.0",11,1);
581 fp->PutC(3); //byte 15 : 3 (hex 0x03) Length of Data Sub-Block (three bytes of data to follow)
582 fp->PutC(1); //byte 16 : 1 (hex 0x01)
583 Putword(m_loops,fp); //bytes 17 to 18 : 0 to 65535, an unsigned integer in lo-hi byte format.
584 //This indicate the number of iterations the loop should be executed.
585 fp->PutC(0); //bytes 19 : 0 (hex 0x00) a Data Sub-block Terminator.
586}
587////////////////////////////////////////////////////////////////////////////////
588void CxImageGIF::EncodeBody(CxFile *fp, bool bLocalColorMap)
589{
590 curx = 0;
591 cury = head.biHeight - 1; //because we read the image bottom to top
592 CountDown = (long)head.biWidth * (long)head.biHeight;
593
594 fp->PutC(',');
595
596 Putword(info.xOffset,fp);
597 Putword(info.yOffset,fp);
598 Putword(head.biWidth,fp);
599 Putword(head.biHeight,fp);
600
601 BYTE Flags=0x00; //non-interlaced (0x40 = interlaced) (0x80 = LocalColorMap)
602 if (bLocalColorMap) { Flags|=0x80; Flags|=head.biBitCount-1; }
603 fp->PutC(Flags);
604
605 if (bLocalColorMap){
606 Flags|=0x87;
607 RGBQUAD* pPal = GetPalette();
608 for(DWORD i=0; i<head.biClrUsed; ++i)
609 {
610 fp->PutC(pPal[i].rgbRed);
611 fp->PutC(pPal[i].rgbGreen);
612 fp->PutC(pPal[i].rgbBlue);
613 }
614 }
615
616 int InitCodeSize = head.biBitCount <=1 ? 2 : head.biBitCount;
617 // Write out the initial code size
618 fp->PutC((BYTE)InitCodeSize);
619
620 // Go and actually compress the data
621 switch (GetCodecOption(CXIMAGE_FORMAT_GIF))
622 {
623 case 1: //uncompressed
624 compressNONE(InitCodeSize+1, fp);
625 break;
626 case 2: //RLE
627 compressRLE(InitCodeSize+1, fp);
628 break;
629 default: //LZW
630 compressLZW(InitCodeSize+1, fp);
631 }
632
633 // Write out a Zero-length packet (to end the series)
634 fp->PutC(0);
635}
636////////////////////////////////////////////////////////////////////////////////
637void CxImageGIF::EncodeComment(CxFile *fp)
638{
639 unsigned long n = (unsigned long) strlen(m_comment);
640 if (n>255) n=255;
641 if (n) {
642 fp->PutC('!'); //extension code:
643 fp->PutC(254); //comment extension
644 fp->PutC((BYTE)n); //size of comment
645 fp->Write(m_comment,n,1);
646 fp->PutC(0); //block terminator
647 }
648}
649////////////////////////////////////////////////////////////////////////////////
650bool CxImageGIF::EncodeRGB(CxFile *fp)
651{
652 EncodeHeader(fp);
653
654// EncodeLoopExtension(fp);
655
656 EncodeComment(fp);
657
658 unsigned long w,h;
659 w=h=0;
660 const long cellw = 17;
661 const long cellh = 15;
662 CxImageGIF tmp;
663 for (long y=0;y<head.biHeight;y+=cellh){
664 for (long x=0;x<head.biWidth;x+=cellw){
665 if ((head.biWidth -x)<cellw) w=head.biWidth -x; else w=cellw;
666 if ((head.biHeight-y)<cellh) h=head.biHeight-y; else h=cellh;
667
668 if (w!=tmp.GetWidth() || h!=tmp.GetHeight()) tmp.Create(w,h,8);
669
670 if (IsTransparent()){
671 tmp.SetTransIndex(0);
672 tmp.SetPaletteColor(0,GetTransColor());
673 }
674
675 BYTE i;
676 for (unsigned long j=0;j<h;j++){
677 for (unsigned long k=0;k<w;k++){
678 i=(BYTE)(1+k+cellw*j);
679 tmp.SetPaletteColor(i,GetPixelColor(x+k,head.biHeight-y-h+j));
680 tmp.SetPixelIndex(k,j,tmp.GetNearestIndex(tmp.GetPaletteColor(i)));
681 }
682 }
683
684 tmp.SetOffset(x,y);
685 tmp.EncodeExtension(fp);
686 tmp.EncodeBody(fp,true);
687 }
688 }
689
690 fp->PutC(';'); // Write the GIF file terminator
691
692 return true; // done!
693}
694////////////////////////////////////////////////////////////////////////////////
695#endif // CXIMAGE_SUPPORT_ENCODE
696////////////////////////////////////////////////////////////////////////////////
697// Return the next pixel from the image
698// <DP> fix for 1 & 4 bpp images
699int CxImageGIF::GifNextPixel( )
700{
701 if( CountDown == 0 ) return EOF;
702 --CountDown;
703 int r = GetPixelIndex(curx,cury);
704 // Bump the current X position
705 ++curx;
706 if( curx == head.biWidth ){
707 curx = 0;
708 cury--; //bottom to top
709 }
710 return r;
711}
712////////////////////////////////////////////////////////////////////////////////
713void CxImageGIF::Putword(int w, CxFile *fp )
714{
715 fp->PutC((BYTE)(w & 0xff));
716 fp->PutC((BYTE)((w >> 8) & 0xff));
717}
718////////////////////////////////////////////////////////////////////////////////
719void CxImageGIF::compressNONE( int init_bits, CxFile* outfile)
720{
721 register long c;
722 register long ent;
723
724 // g_init_bits - initial number of bits
725 // g_outfile - pointer to output file
726 g_init_bits = init_bits;
727 g_outfile = outfile;
728
729 // Set up the necessary values
730 cur_accum = cur_bits = clear_flg = 0;
731 maxcode = (short)MAXCODE(n_bits = g_init_bits);
732 code_int maxmaxcode = (code_int)1 << MAXBITSCODES;
733
734 ClearCode = (1 << (init_bits - 1));
735 EOFCode = ClearCode + 1;
736 free_ent = (short)(ClearCode + 2);
737
738 a_count=0;
739 ent = GifNextPixel( );
740
741 output( (code_int)ClearCode );
742
743 while ( ent != EOF ) {
744 c = GifNextPixel();
745
746 output ( (code_int) ent );
747 ent = c;
748 if ( free_ent < maxmaxcode ) {
749 free_ent++;
750 } else {
751 free_ent=(short)(ClearCode+2);
752 clear_flg=1;
753 output((code_int)ClearCode);
754 }
755 }
756 // Put out the final code.
757 output( (code_int) EOFCode );
758}
759////////////////////////////////////////////////////////////////////////////////
760
761/***************************************************************************
762 *
763 * GIFCOMPR.C - LZW GIF Image compression routines
764 *
765 ***************************************************************************/
766
767void CxImageGIF::compressLZW( int init_bits, CxFile* outfile)
768{
769 register long fcode;
770 register long c;
771 register long ent;
772 register long hshift;
773 register long disp;
774 register long i;
775
776 // g_init_bits - initial number of bits
777 // g_outfile - pointer to output file
778 g_init_bits = init_bits;
779 g_outfile = outfile;
780
781 // Set up the necessary values
782 cur_accum = cur_bits = clear_flg = 0;
783 maxcode = (short)MAXCODE(n_bits = g_init_bits);
784 code_int maxmaxcode = (code_int)1 << MAXBITSCODES;
785
786 ClearCode = (1 << (init_bits - 1));
787 EOFCode = ClearCode + 1;
788 free_ent = (short)(ClearCode + 2);
789
790 a_count=0;
791 ent = GifNextPixel( );
792
793 hshift = 0;
794 for ( fcode = (long) HSIZE; fcode < 65536L; fcode *= 2L ) ++hshift;
795 hshift = 8 - hshift; /* set hash code range bound */
796 cl_hash((long)HSIZE); /* clear hash table */
797 output( (code_int)ClearCode );
798
799 while ( (c = GifNextPixel( )) != EOF ) {
800
801 fcode = (long) (((long) c << MAXBITSCODES) + ent);
802 i = (((code_int)c << hshift) ^ ent); /* xor hashing */
803
804 if ( HashTabOf (i) == fcode ) {
805 ent = CodeTabOf (i);
806 continue;
807 } else if ( (long)HashTabOf (i) < 0 ) /* empty slot */
808 goto nomatch;
809 disp = HSIZE - i; /* secondary hash (after G. Knott) */
810 if ( i == 0 ) disp = 1;
811probe:
812 if ( (i -= disp) < 0 ) i += HSIZE;
813 if ( HashTabOf (i) == fcode ) { ent = CodeTabOf (i); continue; }
814 if ( (long)HashTabOf (i) > 0 ) goto probe;
815nomatch:
816 output ( (code_int) ent );
817 ent = c;
818 if ( free_ent < maxmaxcode ) {
819 CodeTabOf (i) = free_ent++; /* code -> hashtable */
820 HashTabOf (i) = fcode;
821 } else {
822 cl_hash((long)HSIZE);
823 free_ent=(short)(ClearCode+2);
824 clear_flg=1;
825 output((code_int)ClearCode);
826 }
827 }
828 // Put out the final code.
829 output( (code_int)ent );
830 output( (code_int) EOFCode );
831}
832////////////////////////////////////////////////////////////////////////////////
833
834static const unsigned long code_mask[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
835 0x001F, 0x003F, 0x007F, 0x00FF,
836 0x01FF, 0x03FF, 0x07FF, 0x0FFF,
837 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
838
839////////////////////////////////////////////////////////////////////////////////
840void CxImageGIF::output( code_int code)
841{
842 cur_accum &= code_mask[ cur_bits ];
843
844 if( cur_bits > 0 )
845 cur_accum |= ((long)code << cur_bits);
846 else
847 cur_accum = code;
848
849 cur_bits += n_bits;
850
851 while( cur_bits >= 8 ) {
852 char_out( (unsigned int)(cur_accum & 0xff) );
853 cur_accum >>= 8;
854 cur_bits -= 8;
855 }
856
857 /*
858 * If the next entry is going to be too big for the code size,
859 * then increase it, if possible.
860 */
861
862 if ( free_ent > maxcode || clear_flg ) {
863 if( clear_flg ) {
864 maxcode = (short)MAXCODE(n_bits = g_init_bits);
865 clear_flg = 0;
866 } else {
867 ++n_bits;
868 if ( n_bits == MAXBITSCODES )
869 maxcode = (code_int)1 << MAXBITSCODES; /* should NEVER generate this code */
870 else
871 maxcode = (short)MAXCODE(n_bits);
872 }
873 }
874
875 if( code == EOFCode ) {
876 // At EOF, write the rest of the buffer.
877 while( cur_bits > 0 ) {
878 char_out( (unsigned int)(cur_accum & 0xff) );
879 cur_accum >>= 8;
880 cur_bits -= 8;
881 }
882
883 flush_char();
884 g_outfile->Flush();
885
886 if(g_outfile->Error()) strcpy(info.szLastError,"Write Error in GIF file");
887 }
888}
889////////////////////////////////////////////////////////////////////////////////
890
891void CxImageGIF::cl_hash(long hsize)
892
893{
894 register long *htab_p = htab+hsize;
895
896 register long i;
897 register long m1 = -1L;
898
899 i = hsize - 16;
900
901 do {
902 *(htab_p-16)=m1;
903 *(htab_p-15)=m1;
904 *(htab_p-14)=m1;
905 *(htab_p-13)=m1;
906 *(htab_p-12)=m1;
907 *(htab_p-11)=m1;
908 *(htab_p-10)=m1;
909 *(htab_p-9)=m1;
910 *(htab_p-8)=m1;
911 *(htab_p-7)=m1;
912 *(htab_p-6)=m1;
913 *(htab_p-5)=m1;
914 *(htab_p-4)=m1;
915 *(htab_p-3)=m1;
916 *(htab_p-2)=m1;
917 *(htab_p-1)=m1;
918
919 htab_p-=16;
920 } while ((i-=16) >=0);
921
922 for (i+=16;i>0;--i)
923 *--htab_p=m1;
924}
925
926/*******************************************************************************
927* GIF specific
928*******************************************************************************/
929
930void CxImageGIF::char_out(int c)
931{
932 accum[a_count++]=(char)c;
933 if (a_count >=254)
934 flush_char();
935}
936
937void CxImageGIF::flush_char()
938{
939 if (a_count > 0) {
940 g_outfile->PutC((BYTE)a_count);
941 g_outfile->Write(accum,1,a_count);
942 a_count=0;
943 }
944}
945
946/*******************************************************************************
947* GIF decoder
948*******************************************************************************/
949/* DECODE.C - An LZW decoder for GIF
950 * Copyright (C) 1987, by Steven A. Bennett
951 * Copyright (C) 1994, C++ version by Alejandro Aguilar Sierra
952*
953 * Permission is given by the author to freely redistribute and include
954 * this code in any program as long as this credit is given where due.
955 *
956 * In accordance with the above, I want to credit Steve Wilhite who wrote
957 * the code which this is heavily inspired by...
958 *
959 * GIF and 'Graphics Interchange Format' are trademarks (tm) of
960 * Compuserve, Incorporated, an H&R Block Company.
961 *
962 * Release Notes: This file contains a decoder routine for GIF images
963 * which is similar, structurally, to the original routine by Steve Wilhite.
964 * It is, however, somewhat noticably faster in most cases.
965 *
966 */
967
968////////////////////////////////////////////////////////////////////////////////
969
970short CxImageGIF::init_exp(short size)
971{
972 curr_size = (short)(size + 1);
973 top_slot = (short)(1 << curr_size);
974 clear = (short)(1 << size);
975 ending = (short)(clear + 1);
976 slot = newcodes = (short)(ending + 1);
977 navail_bytes = nbits_left = 0;
978
979 memset(stack,0,MAX_CODES + 1);
980 memset(prefix,0,MAX_CODES + 1);
981 memset(suffix,0,MAX_CODES + 1);
982 return(0);
983}
984////////////////////////////////////////////////////////////////////////////////
985
986/* get_next_code()
987 * - gets the next code from the GIF file. Returns the code, or else
988 * a negative number in case of file errors...
989 */
990short CxImageGIF::get_next_code(CxFile* file)
991{
992 short i, x;
993 DWORD ret;
994
995 if (nbits_left == 0) {
996 if (navail_bytes <= 0) {
997 /* Out of bytes in current block, so read next block */
998 pbytes = byte_buff;
999 if ((navail_bytes = (short)get_byte(file)) < 0)
1000 return(navail_bytes);
1001 else if (navail_bytes) {
1002 for (i = 0; i < navail_bytes; ++i) {
1003 if ((x = (short)get_byte(file)) < 0) return(x);
1004 byte_buff[i] = (BYTE)x;
1005 }
1006 }
1007 }
1008 b1 = *pbytes++;
1009 nbits_left = 8;
1010 --navail_bytes;
1011 }
1012
1013 if (navail_bytes<0) return ending; // prevent deadlocks (thanks to Mike Melnikov)
1014
1015 ret = b1 >> (8 - nbits_left);
1016 while (curr_size > nbits_left){
1017 if (navail_bytes <= 0){
1018 /* Out of bytes in current block, so read next block*/
1019 pbytes = byte_buff;
1020 if ((navail_bytes = (short)get_byte(file)) < 0)
1021 return(navail_bytes);
1022 else if (navail_bytes){
1023 for (i = 0; i < navail_bytes; ++i){
1024 if ((x = (short)get_byte(file)) < 0) return(x);
1025 byte_buff[i] = (BYTE)x;
1026 }
1027 }
1028 }
1029 b1 = *pbytes++;
1030 ret |= b1 << nbits_left;
1031 nbits_left += 8;
1032 --navail_bytes;
1033 }
1034 nbits_left = (short)(nbits_left-curr_size);
1035 ret &= code_mask[curr_size];
1036 return((short)(ret));
1037}
1038////////////////////////////////////////////////////////////////////////////////
1039
1040/* short decoder(linewidth)
1041 * short linewidth; * Pixels per line of image *
1042 *
1043 * - This function decodes an LZW image, according to the method used
1044 * in the GIF spec. Every *linewidth* "characters" (ie. pixels) decoded
1045 * will generate a call to out_line(), which is a user specific function
1046 * to display a line of pixels. The function gets it's codes from
1047 * get_next_code() which is responsible for reading blocks of data and
1048 * seperating them into the proper size codes. Finally, get_byte() is
1049 * the global routine to read the next BYTE from the GIF file.
1050 *
1051 * It is generally a good idea to have linewidth correspond to the actual
1052 * width of a line (as specified in the Image header) to make your own
1053 * code a bit simpler, but it isn't absolutely necessary.
1054 *
1055 * Returns: 0 if successful, else negative. (See ERRS.H)
1056 *
1057 */
1058/* bad_code_count is incremented each time an out of range code is read.
1059 * When this value is non-zero after a decode, your GIF file is probably
1060 * corrupt in some way...
1061 */
1062short CxImageGIF::decoder(CxFile* file, CImageIterator* iter, short linewidth, int &bad_code_count)
1063{
1064 register BYTE *sp, *bufptr;
1065 BYTE *buf;
1066 register short code, fc, oc, bufcnt;
1067 short c, size, ret;
1068
1069 /* Initialize for decoding a new image... */
1070 bad_code_count = 0;
1071 if ((size = (short)get_byte(file)) < 0) return(size);
1072 if (size < 2 || 9 < size) return(BAD_CODE_SIZE);
1073 // out_line = outline;
1074 init_exp(size);
1075 //printf("L %d %x\n",linewidth,size);
1076
1077 /* Initialize in case they forgot to put in a clear code.
1078 * (This shouldn't happen, but we'll try and decode it anyway...)
1079 */
1080 oc = fc = 0;
1081
1082 /* Allocate space for the decode buffer */
1083 if ((buf = new BYTE[linewidth + 1]) == NULL) return(OUT_OF_MEMORY);
1084
1085 /* Set up the stack pointer and decode buffer pointer */
1086 sp = stack;
1087 bufptr = buf;
1088 bufcnt = linewidth;
1089
1090 /* This is the main loop. For each code we get we pass through the
1091 * linked list of prefix codes, pushing the corresponding "character" for
1092 * each code onto the stack. When the list reaches a single "character"
1093 * we push that on the stack too, and then start unstacking each
1094 * character for output in the correct order. Special handling is
1095 * included for the clear code, and the whole thing ends when we get
1096 * an ending code.
1097 */
1098 while ((c = get_next_code(file)) != ending) {
1099 /* If we had a file error, return without completing the decode*/
1100 if (c < 0){
1101 delete [] buf;
1102 return(0);
1103 }
1104 /* If the code is a clear code, reinitialize all necessary items.*/
1105 if (c == clear){
1106 curr_size = (short)(size + 1);
1107 slot = newcodes;
1108 top_slot = (short)(1 << curr_size);
1109
1110 /* Continue reading codes until we get a non-clear code
1111 * (Another unlikely, but possible case...)
1112 */
1113 while ((c = get_next_code(file)) == clear);
1114
1115 /* If we get an ending code immediately after a clear code
1116 * (Yet another unlikely case), then break out of the loop.
1117 */
1118 if (c == ending) break;
1119
1120 /* Finally, if the code is beyond the range of already set codes,
1121 * (This one had better NOT happen... I have no idea what will
1122 * result from this, but I doubt it will look good...) then set it
1123 * to color zero.
1124 */
1125 if (c >= slot) c = 0;
1126 oc = fc = c;
1127
1128 /* And let us not forget to put the char into the buffer... And
1129 * if, on the off chance, we were exactly one pixel from the end
1130 * of the line, we have to send the buffer to the out_line()
1131 * routine...
1132 */
1133 *bufptr++ = (BYTE)c;
1134 if (--bufcnt == 0) {
1135 if (iter) {
1136 if ((ret = (short)out_line(iter, buf, linewidth)) < 0) {
1137 delete [] buf;
1138 return(ret);
1139 }
1140 }
1141 bufptr = buf;
1142 bufcnt = linewidth;
1143 }
1144 } else {
1145 /* In this case, it's not a clear code or an ending code, so
1146 * it must be a code code... So we can now decode the code into
1147 * a stack of character codes. (Clear as mud, right?)
1148 */
1149 code = c;
1150
1151 /* Here we go again with one of those off chances... If, on the
1152 * off chance, the code we got is beyond the range of those already
1153 * set up (Another thing which had better NOT happen...) we trick
1154 * the decoder into thinking it actually got the last code read.
1155 * (Hmmn... I'm not sure why this works... But it does...)
1156 */
1157 if (code >= slot && sp<(stack+MAX_CODES-1)) {
1158 if (code > slot)
1159 ++bad_code_count;
1160 code = oc;
1161 *sp++ = (BYTE)fc;
1162 }
1163
1164 /* Here we scan back along the linked list of prefixes, pushing
1165 * helpless characters (ie. suffixes) onto the stack as we do so.
1166 */
1167 while (code >= newcodes && sp<(stack+MAX_CODES-1)) {
1168 *sp++ = suffix[code];
1169 code = prefix[code];
1170 }
1171
1172 /* Push the last character on the stack, and set up the new
1173 * prefix and suffix, and if the required slot number is greater
1174 * than that allowed by the current bit size, increase the bit
1175 * size. (NOTE - If we are all full, we *don't* save the new
1176 * suffix and prefix... I'm not certain if this is correct...
1177 * it might be more proper to overwrite the last code...
1178 */
1179 *sp++ = (BYTE)code;
1180 if (slot < top_slot){
1181 suffix[slot] = (BYTE)(fc = (BYTE)code);
1182 prefix[slot++] = oc;
1183 oc = c;
1184 }
1185 if (slot >= top_slot){
1186 if (curr_size < 12) {
1187 top_slot <<= 1;
1188 ++curr_size;
1189 }
1190 }
1191
1192 /* Now that we've pushed the decoded string (in reverse order)
1193 * onto the stack, lets pop it off and put it into our decode
1194 * buffer... And when the decode buffer is full, write another
1195 * line...
1196 */
1197 while (sp > stack) {
1198 *bufptr++ = *(--sp);
1199 if (--bufcnt == 0) {
1200 if (iter) {
1201 if ((ret = (short)out_line(iter, buf, linewidth)) < 0) {
1202 delete [] buf;
1203 return(ret);
1204 }
1205 }
1206 bufptr = buf;
1207 bufcnt = linewidth;
1208 }
1209 }
1210 }
1211 }
1212 ret = 0;
1213 if (bufcnt != linewidth && iter)
1214 ret = (short)out_line(iter, buf, (linewidth - bufcnt));
1215 delete [] buf;
1216 return(ret);
1217}
1218////////////////////////////////////////////////////////////////////////////////
1219int CxImageGIF::get_num_frames(CxFile *fp,struct_TabCol* TabColSrc,struct_dscgif* dscgif)
1220{
1221 struct_image image;
1222
1223 long pos=fp->Tell();
1224 int nframes=0;
1225
1226 struct_TabCol TempTabCol;
1227 memcpy(&TempTabCol,TabColSrc,sizeof(struct_TabCol));
1228
1229 char ch;
1230 bool bPreviousWasNull = true;
1231
1232 for (BOOL bContinue = TRUE; bContinue; )
1233 {
1234 if (fp->Read(&ch, sizeof(ch), 1) != 1) {break;}
1235
1236 if (bPreviousWasNull || ch==0)
1237 {
1238 switch (ch)
1239 {
1240 case '!': // extension
1241 {
1242 DecodeExtension(fp);
1243 break;
1244 }
1245 case ',': // image
1246 {
1247
1248 assert(sizeof(image) == 9);
1249 //log << "Image header" << endl;
1250 fp->Read(&image,sizeof(image),1);
1251
1252 //avoid byte order problems with Solaris <candan> <AMSN>
1253 image.l = ntohs(image.l);
1254 image.t = ntohs(image.t);
1255 image.w = ntohs(image.w);
1256 image.h = ntohs(image.h);
1257
1258 // in case of images with empty screen descriptor, give a last chance
1259 if (dscgif->scrwidth==0 && dscgif->scrheight==0){
1260 dscgif->scrwidth = image.w;
1261 dscgif->scrheight = image.h;
1262 }
1263
1264 if (((image.l + image.w) > dscgif->scrwidth)||((image.t + image.h) > dscgif->scrheight))
1265 break;
1266
1267 nframes++;
1268
1269 // Local colour map?
1270 if (image.pf & 0x80) {
1271 TempTabCol.sogct = (short)(1 << ((image.pf & 0x07) +1));
1272 assert(3 == sizeof(struct rgb_color));
1273 fp->Read(TempTabCol.paleta,sizeof(struct rgb_color)*TempTabCol.sogct,1);
1274 //log << "Local colour map" << endl;
1275 }
1276
1277 int badcode=0;
1278 ibf = GIFBUFTAM+1;
1279
1280 interlaced = image.pf & 0x40;
1281 iheight = image.h;
1282 istep = 8;
1283 iypos = 0;
1284 ipass = 0;
1285
1286 long pos_start = fp->Tell();
1287
1288 //if (interlaced) log << "Interlaced" << endl;
1289 decoder(fp, 0, image.w, badcode);
1290
1291 if (badcode){
1292 seek_next_image(fp,pos_start);
1293 } else {
1294 fp->Seek(-(ibfmax - ibf - 1), SEEK_CUR);
1295 }
1296
1297 break;
1298 }
1299 case ';': //terminator
1300 bContinue=false;
1301 break;
1302 default:
1303 bPreviousWasNull = (ch==0);
1304 break;
1305 }
1306 }
1307 }
1308
1309 fp->Seek(pos,SEEK_SET);
1310 return nframes;
1311}
1312////////////////////////////////////////////////////////////////////////////////
1313long CxImageGIF::seek_next_image(CxFile* fp, long position)
1314{
1315 fp->Seek(position, SEEK_SET);
1316 char ch1,ch2;
1317 ch1=ch2=0;
1318 while(fp->Read(&ch2,sizeof(char),1)>0){
1319 if (ch1 == 0 && ch2 == ','){
1320 fp->Seek(-1,SEEK_CUR);
1321 return fp->Tell();
1322 } else {
1323 ch1 = ch2;
1324 }
1325 }
1326 return -1;
1327}
1328////////////////////////////////////////////////////////////////////////////////
1329void CxImageGIF::SetLoops(int loops)
1330{ m_loops=loops; }
1331////////////////////////////////////////////////////////////////////////////////
1332long CxImageGIF::GetLoops()
1333{ return m_loops; }
1334////////////////////////////////////////////////////////////////////////////////
1335void CxImageGIF::SetComment(const char* sz_comment_in)
1336{ if (sz_comment_in) strncpy(m_comment,sz_comment_in,255); }
1337////////////////////////////////////////////////////////////////////////////////
1338void CxImageGIF::GetComment(char* sz_comment_out)
1339{ if (sz_comment_out) strncpy(sz_comment_out,m_comment,255); }
1340////////////////////////////////////////////////////////////////////////////////
1341void CxImageGIF::GifMix(CxImage & imgsrc2, struct_image & imgdesc)
1342{
1343 long ymin = max(0,(long)(GetHeight()-imgdesc.t - imgdesc.h));
1344 long ymax = GetHeight()-imgdesc.t;
1345 long xmin = imgdesc.l;
1346 long xmax = min(GetWidth(), (DWORD)(imgdesc.l + imgdesc.w));
1347
1348 long ibg2= imgsrc2.GetTransIndex();
1349 BYTE i2;
1350
1351 for(long y = ymin; y < ymax; y++){
1352 for(long x = xmin; x < xmax; x++){
1353 i2 = imgsrc2.GetPixelIndex(x-xmin,y-ymin);
1354 if(i2!=ibg2) SetPixelIndex(x,y,i2);
1355 }
1356 }
1357}
1358////////////////////////////////////////////////////////////////////////////////
1359/*-----------------------------------------------------------------------
1360 *
1361 * miGIF Compression - mouse and ivo's GIF-compatible compression
1362 *
1363 * -run length encoding compression routines-
1364 *
1365 * Copyright (C) 1998 Hutchison Avenue Software Corporation
1366 * http://www.hasc.com
1367 * info@hasc.com
1368 *
1369 * Permission to use, copy, modify, and distribute this software and its
1370 * documentation for any purpose and without fee is hereby granted, provided
1371 * that the above copyright notice appear in all copies and that both that
1372 * copyright notice and this permission notice appear in supporting
1373 * documentation. This software is provided "AS IS." The Hutchison Avenue
1374 * Software Corporation disclaims all warranties, either express or implied,
1375 * including but not limited to implied warranties of merchantability and
1376 * fitness for a particular purpose, with respect to this code and accompanying
1377 * documentation.
1378 *
1379 * The miGIF compression routines do not, strictly speaking, generate files
1380 * conforming to the GIF spec, since the image data is not LZW-compressed
1381 * (this is the point: in order to avoid transgression of the Unisys patent
1382 * on the LZW algorithm.) However, miGIF generates data streams that any
1383 * reasonably sane LZW decompresser will decompress to what we want.
1384 *
1385 * miGIF compression uses run length encoding. It compresses horizontal runs
1386 * of pixels of the same color. This type of compression gives good results
1387 * on images with many runs, for example images with lines, text and solid
1388 * shapes on a solid-colored background. It gives little or no compression
1389 * on images with few runs, for example digital or scanned photos.
1390 *
1391 * der Mouse
1392 * mouse@rodents.montreal.qc.ca
1393 * 7D C8 61 52 5D E7 2D 39 4E F1 31 3E E8 B3 27 4B
1394 *
1395 * ivo@hasc.com
1396 *
1397 * The Graphics Interchange Format(c) is the Copyright property of
1398 * CompuServe Incorporated. GIF(sm) is a Service Mark property of
1399 * CompuServe Incorporated.
1400 *
1401 */
1402////////////////////////////////////////////////////////////////////////////////
1403void CxImageGIF::rle_clear(struct_RLE* rle)
1404{
1405 rle->out_bits = rle->out_bits_init;
1406 rle->out_bump = rle->out_bump_init;
1407 rle->out_clear = rle->out_clear_init;
1408 rle->out_count = 0;
1409 rle->rl_table_max = 0;
1410 rle->just_cleared = 1;
1411}
1412////////////////////////////////////////////////////////////////////////////////
1413void CxImageGIF::rle_flush(struct_RLE* rle)
1414{
1415 if (rle->rl_count == 1){
1416 rle_output_plain(rle->rl_pixel,rle);
1417 rle->rl_count = 0;
1418 return;
1419 }
1420 if (rle->just_cleared){
1421 rle_flush_fromclear(rle->rl_count,rle);
1422 } else if ((rle->rl_table_max < 2) || (rle->rl_table_pixel != rle->rl_pixel)) {
1423 rle_flush_clearorrep(rle->rl_count,rle);
1424 } else {
1425 rle_flush_withtable(rle->rl_count,rle);
1426 }
1427 rle->rl_count = 0;
1428}
1429////////////////////////////////////////////////////////////////////////////////
1430void CxImageGIF::rle_output_plain(int c,struct_RLE* rle)
1431{
1432 rle->just_cleared = 0;
1433 rle_output(c,rle);
1434 rle->out_count++;
1435 if (rle->out_count >= rle->out_bump){
1436 rle->out_bits ++;
1437 rle->out_bump += 1 << (rle->out_bits - 1);
1438 }
1439 if (rle->out_count >= rle->out_clear){
1440 rle_output(rle->code_clear,rle);
1441 rle_clear(rle);
1442 }
1443}
1444////////////////////////////////////////////////////////////////////////////////
1445void CxImageGIF::rle_flush_fromclear(int count,struct_RLE* rle)
1446{
1447 int n;
1448
1449 rle->out_clear = rle->max_ocodes;
1450 rle->rl_table_pixel = rle->rl_pixel;
1451 n = 1;
1452 while (count > 0){
1453 if (n == 1){
1454 rle->rl_table_max = 1;
1455 rle_output_plain(rle->rl_pixel,rle);
1456 count --;
1457 } else if (count >= n){
1458 rle->rl_table_max = n;
1459 rle_output_plain(rle->rl_basecode+n-2,rle);
1460 count -= n;
1461 } else if (count == 1){
1462 rle->rl_table_max ++;
1463 rle_output_plain(rle->rl_pixel,rle);
1464 count = 0;
1465 } else {
1466 rle->rl_table_max ++;
1467 rle_output_plain(rle->rl_basecode+count-2,rle);
1468 count = 0;
1469 }
1470 if (rle->out_count == 0) n = 1; else n ++;
1471 }
1472 rle_reset_out_clear(rle);
1473}
1474////////////////////////////////////////////////////////////////////////////////
1475void CxImageGIF::rle_reset_out_clear(struct_RLE* rle)
1476{
1477 rle->out_clear = rle->out_clear_init;
1478 if (rle->out_count >= rle->out_clear){
1479 rle_output(rle->code_clear,rle);
1480 rle_clear(rle);
1481 }
1482}
1483////////////////////////////////////////////////////////////////////////////////
1484void CxImageGIF::rle_flush_withtable(int count, struct_RLE* rle)
1485{
1486 int repmax;
1487 int repleft;
1488 int leftover;
1489
1490 repmax = count / rle->rl_table_max;
1491 leftover = count % rle->rl_table_max;
1492 repleft = (leftover ? 1 : 0);
1493 if (rle->out_count+repmax+repleft > rle->max_ocodes){
1494 repmax = rle->max_ocodes - rle->out_count;
1495 leftover = count - (repmax * rle->rl_table_max);
1496 repleft = 1 + rle_compute_triangle_count(leftover,rle->max_ocodes);
1497 }
1498 if (1+rle_compute_triangle_count(count,rle->max_ocodes) < (unsigned int)(repmax+repleft)){
1499 rle_output(rle->code_clear,rle);
1500 rle_clear(rle);
1501 rle_flush_fromclear(count,rle);
1502 return;
1503 }
1504 rle->out_clear = rle->max_ocodes;
1505 for (;repmax>0;repmax--) rle_output_plain(rle->rl_basecode+rle->rl_table_max-2,rle);
1506 if (leftover){
1507 if (rle->just_cleared){
1508 rle_flush_fromclear(leftover,rle);
1509 } else if (leftover == 1){
1510 rle_output_plain(rle->rl_pixel,rle);
1511 } else {
1512 rle_output_plain(rle->rl_basecode+leftover-2,rle);
1513 }
1514 }
1515 rle_reset_out_clear(rle);
1516}
1517////////////////////////////////////////////////////////////////////////////////
1518unsigned int CxImageGIF::rle_compute_triangle_count(unsigned int count, unsigned int nrepcodes)
1519{
1520 unsigned int perrep;
1521 unsigned int cost;
1522
1523 cost = 0;
1524 perrep = (nrepcodes * (nrepcodes+1)) / 2;
1525 while (count >= perrep){
1526 cost += nrepcodes;
1527 count -= perrep;
1528 }
1529 if (count > 0){
1530 unsigned int n;
1531 n = rle_isqrt(count);
1532 while ((n*(n+1)) >= 2*count) n --;
1533 while ((n*(n+1)) < 2*count) n ++;
1534 cost += n;
1535 }
1536 return(cost);
1537}
1538////////////////////////////////////////////////////////////////////////////////
1539unsigned int CxImageGIF::rle_isqrt(unsigned int x)
1540{
1541 unsigned int r;
1542 unsigned int v;
1543
1544 if (x < 2) return(x);
1545 for (v=x,r=1;v;v>>=2,r<<=1) ;
1546 for( ;; )
1547 {
1548 v = ((x / r) + r) / 2;
1549 if ((v == r) || (v == r+1)) return(r);
1550 r = v;
1551 }
1552}
1553////////////////////////////////////////////////////////////////////////////////
1554void CxImageGIF::rle_flush_clearorrep(int count, struct_RLE* rle)
1555{
1556 int withclr;
1557 withclr = 1 + rle_compute_triangle_count(count,rle->max_ocodes);
1558 if (withclr < count) {
1559 rle_output(rle->code_clear,rle);
1560 rle_clear(rle);
1561 rle_flush_fromclear(count,rle);
1562 } else {
1563 for (;count>0;count--) rle_output_plain(rle->rl_pixel,rle);
1564 }
1565}
1566////////////////////////////////////////////////////////////////////////////////
1567void CxImageGIF::rle_write_block(struct_RLE* rle)
1568{
1569 g_outfile->PutC((BYTE)rle->oblen);
1570 g_outfile->Write(rle->oblock,1,rle->oblen);
1571 rle->oblen = 0;
1572}
1573////////////////////////////////////////////////////////////////////////////////
1574void CxImageGIF::rle_block_out(unsigned char c, struct_RLE* rle)
1575{
1576 rle->oblock[rle->oblen++] = c;
1577 if (rle->oblen >= 255) rle_write_block(rle);
1578}
1579////////////////////////////////////////////////////////////////////////////////
1580void CxImageGIF::rle_block_flush(struct_RLE* rle)
1581{
1582 if (rle->oblen > 0) rle_write_block(rle);
1583}
1584////////////////////////////////////////////////////////////////////////////////
1585void CxImageGIF::rle_output(int val, struct_RLE* rle)
1586{
1587 rle->obuf |= val << rle->obits;
1588 rle->obits += rle->out_bits;
1589 while (rle->obits >= 8){
1590 rle_block_out((unsigned char)(rle->obuf&0xff),rle);
1591 rle->obuf >>= 8;
1592 rle->obits -= 8;
1593 }
1594}
1595////////////////////////////////////////////////////////////////////////////////
1596void CxImageGIF::rle_output_flush(struct_RLE* rle)
1597{
1598 if (rle->obits > 0) rle_block_out((unsigned char)(rle->obuf),rle);
1599 rle_block_flush(rle);
1600}
1601////////////////////////////////////////////////////////////////////////////////
1602void CxImageGIF::compressRLE( int init_bits, CxFile* outfile)
1603{
1604 g_init_bits = init_bits;
1605 g_outfile = outfile;
1606
1607 struct_RLE rle;
1608 rle.code_clear = 1 << (init_bits - 1);
1609 rle.code_eof = rle.code_clear + 1;
1610 rle.rl_basecode = rle.code_eof + 1;
1611 rle.out_bump_init = (1 << (init_bits - 1)) - 1;
1612 rle.out_clear_init = (init_bits <= 3) ? 9 : (rle.out_bump_init-1);
1613 rle.out_bits_init = init_bits;
1614 rle.max_ocodes = (1 << MAXBITSCODES) - ((1 << (rle.out_bits_init - 1)) + 3);
1615 rle.rl_count = 0;
1616 rle_clear(&rle);
1617 rle.obuf = 0;
1618 rle.obits = 0;
1619 rle.oblen = 0;
1620
1621 rle_output(rle.code_clear,&rle);
1622
1623 int c;
1624 for( ;; )
1625 {
1626 c = GifNextPixel();
1627 if ((rle.rl_count > 0) && (c != rle.rl_pixel)) rle_flush(&rle);
1628 if (c == EOF) break;
1629 if (rle.rl_pixel == c){
1630 rle.rl_count++;
1631 } else {
1632 rle.rl_pixel = c;
1633 rle.rl_count = 1;
1634 }
1635 }
1636 rle_output(rle.code_eof,&rle);
1637 rle_output_flush(&rle);
1638}
1639////////////////////////////////////////////////////////////////////////////////
1640#endif // CXIMAGE_SUPPORT_GIF
Note: See TracBrowser for help on using the repository browser.