home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_iff.c < prev    next >
C/C++ Source or Header  |  1997-01-26  |  87KB  |  2,845 lines
  1.  
  2. /*
  3.  * xa_iff.c
  4.  *
  5.  * Copyright (C) 1990,1991,1992,1993,1994,1995,1996,1997 by Mark Podlipec. 
  6.  * All rights reserved.
  7.  *
  8.  * This software may be freely copied, modified and redistributed without
  9.  * fee for non-commerical purposes provided that this copyright notice is
  10.  * preserved intact on all copies and modified copies.
  11.  * 
  12.  * There is no warranty or other guarantee of fitness of this software.
  13.  * It is provided solely "as is". The author(s) disclaim(s) all
  14.  * responsibility and liability with respect to this software's usage
  15.  * or its effect upon hardware or computer systems.
  16.  *
  17.  */
  18. #include "xanim.h"
  19. #include "xa_iff.h"
  20.  
  21. xaULONG IFF_Read_File();
  22. void IFF_Adjust_For_EHB();
  23. void IFF_Read_BODY();
  24. void IFF_Print_ID();
  25. xaULONG IFF_Delta_Body();
  26. xaULONG IFF_Delta_l();
  27. xaULONG IFF_Delta_3();
  28. xaULONG IFF_Delta_5();
  29. xaULONG IFF_Delta_7();
  30. xaULONG IFF_Delta_8();
  31. xaULONG IFF_Delta_J();
  32. void IFF_Long_Mod();
  33. void IFF_Buffer_Action();
  34. void IFF_Buffer_HAM6();
  35. void IFF_Buffer_HAM8();
  36. void IFF_Setup_HMAP();
  37. void IFF_Setup_CMAP();
  38. IFF_ACT_LST *IFF_Add_Frame();
  39. void IFF_Image_To_Bufferable();
  40. void IFF_Read_BMHD();
  41. void IFF_Read_ANHD();
  42. void IFF_Read_ANSQ();
  43. void IFF_Register_CRNGs();
  44. void IFF_Read_CRNG();
  45. void IFF_Read_CMAP_0();
  46. void IFF_Read_CMAP_1();
  47. void IFF_Init_DLTA_HDR();
  48. void IFF_Update_DLTA_HDR();
  49. void IFF_Free_Stuff();
  50. void IFF_Shift_CMAP();
  51. void IFF_HAM6_As_True();
  52. void IFF_HAM8_As_True();
  53. void IFF_Hash_CleanUp();
  54. void IFF_Hash_Init();
  55. void IFF_Hash_Add();
  56. XA_ACTION *IFF_Hash_Get();
  57. xaULONG IFF_Check_Same();
  58.  
  59.  
  60. xaULONG CMAP_Get_Or_Mask();
  61. XA_CHDR *CMAP_Create_332();
  62. XA_CHDR *CMAP_Create_Gray();
  63. XA_CHDR *CMAP_Create_CHDR_From_True();
  64. void ACT_Add_CHDR_To_Action();
  65. void ACT_Del_CHDR_From_Action();
  66. void UTIL_Mapped_To_Bitmap();
  67. void UTIL_Mapped_To_Mapped();
  68. xaUBYTE *UTIL_RGB_To_Map();
  69. xaUBYTE *UTIL_RGB_To_FS_Map();
  70. void ACT_Free_Act();
  71. xaULONG UTIL_Get_Buffer_Scale();
  72. void UTIL_Scale_Pos_Size();
  73.  
  74. extern xaLONG xa_anim_cycling;
  75.  
  76. XA_ACTION *ACT_Get_Action();
  77. void ACT_Setup_Mapped();
  78. void UTIL_Sub_Image();
  79. XA_CHDR *ACT_Get_CMAP();
  80.  
  81. #define IFF_SPEED_DEFAULT 3
  82. #define IFF_MS_PER_60HZ  17
  83. #define ACT_IFF_HMAP6 0x2000
  84. #define ACT_IFF_HMAP8 0x2001
  85.  
  86. typedef struct
  87. {
  88.   xaULONG flag;
  89.   XA_ACTION *dlta;
  90.   XA_ACTION *src;
  91.   XA_ACTION *dst;
  92.   XA_ACTION *nxtdlta;
  93. } IFF_HASH;
  94.  
  95. IFF_HASH *iff_hash_tbl;
  96. xaULONG iff_hash_cur = 0;
  97.  
  98.  
  99. static IFF_ANSQ *iff_ansq;
  100. static xaULONG iff_ansq_cnt;
  101. static IFF_DLTA_TABLE *iff_dlta_acts;
  102.  
  103. static xaLONG  iff_allow_cycling;
  104. static xaULONG iff_time;
  105. static xaULONG iff_anim_flags;
  106. static xaULONG iff_cmap_bits;
  107. static ColorReg iff_hmap[XA_HMAP_SIZE];
  108. static ColorReg *iff_cur_hmap;
  109. static ColorReg iff_cmap[256];
  110. static XA_CHDR *iff_chdr;
  111.  
  112. static xaLONG mask[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
  113.  
  114. static IFF_ACT_LST *iff_act_start,*iff_act_cur;
  115. static xaULONG iff_act_cnt;
  116. static xaULONG iff_dlta_cnt;
  117. static xaULONG iff_dlta_compression,iff_dlta_bits;
  118.  
  119. static xaULONG iff_imagex,iff_imagey,iff_imagec,iff_imaged;
  120. static xaULONG iff_max_imagex,iff_max_imagey,iff_max_imagec,iff_max_imaged;
  121. static xaULONG iff_or_mask;
  122. static xaULONG iff_max_fvid_size;
  123.  
  124. extern xaULONG xa_ham_map_size;
  125. extern xaULONG *xa_ham_map;
  126. extern XA_CHDR *xa_ham_chdr;
  127. extern xaULONG xa_ham_init;
  128.  
  129. /*
  130.  * NOTES: the iff_cmap is read in as 8 bits. It's shifted down to 4 bits
  131.  * before ACT_GET_CMAP is called(unless there are 8 bit planes)
  132.  * How does one know whether is 4 bits or 8 bits per color component?
  133.  */
  134.  
  135. void
  136. IFF_TheEnd()
  137. {
  138.   IFF_Free_Stuff();
  139.   TheEnd();
  140. }
  141.  
  142. void
  143. IFF_TheEnd1(p)
  144. char *p;
  145. {
  146.   IFF_Free_Stuff();
  147.   TheEnd1(p);
  148. }
  149.  
  150. IFF_ACT_LST *IFF_Add_Frame(type,act)
  151. xaULONG type;
  152. XA_ACTION *act;
  153. {
  154.   IFF_ACT_LST *iframe;
  155.  
  156.   iframe = (IFF_ACT_LST *) malloc(sizeof(IFF_ACT_LST));
  157.   if (iframe == 0) IFF_TheEnd1("IFF_Add_Frame: malloc err");
  158.  
  159.   if (type == 1) iff_dlta_cnt++;
  160.   iframe->type = type;
  161.   iframe->act = act;
  162.   iframe->next = 0;
  163.  
  164.   if (iff_act_start == 0) iff_act_start = iframe;
  165.   else iff_act_cur->next = iframe;
  166.  
  167.   iff_act_cur = iframe;
  168.   iff_act_cnt++;
  169.   return(iframe);
  170. }
  171.  
  172. void
  173. IFF_Free_Stuff()
  174. {
  175.   IFF_ACT_LST *itmp;
  176.  
  177.   if (iff_ansq) FREE(iff_ansq,0x1000);
  178.   if (iff_dlta_acts) FREE(iff_dlta_acts,0x1001); 
  179.   iff_ansq = 0; iff_dlta_acts = 0;
  180.   while(iff_act_start != 0)
  181.   {
  182.     itmp = iff_act_start;
  183.     iff_act_start = iff_act_start->next;
  184.     FREE(itmp,0x1003);
  185.   }
  186.   iff_ansq = 0;
  187.   iff_dlta_acts = 0;
  188.   iff_act_start = 0;
  189. }
  190.  
  191.  
  192. /*
  193.  *
  194.  */
  195. xaULONG IFF_Read_File(fname,anim_hdr)
  196. xaBYTE *fname;
  197. XA_ANIM_HDR *anim_hdr;
  198. { XA_INPUT *xin = anim_hdr->xin;
  199.   xaLONG camg_flag,cmap_flag,chdr_flag,ret;
  200.   xaLONG crng_flag,formtype;
  201.   xaLONG ansq_flag;
  202.   xaLONG face_flag,bmhd_flag,file_size,file_read;
  203.   Bit_Map_Header bmhd;
  204.   Chunk_Header  chunk;
  205.   xaLONG prop_flag;
  206.   xaLONG exit_flag;
  207.  
  208.  
  209.   iff_allow_cycling = (anim_hdr->anim_flags & ANIM_CYCLE)?(xaTRUE):(xaFALSE);
  210.   iff_act_start    = 0;
  211.   iff_act_cur    = 0;
  212.   iff_act_cnt    = 0;
  213.   iff_dlta_compression = 0xffff;
  214.   iff_dlta_bits = 0;
  215.   iff_anim_flags = anim_hdr->anim_flags & ~(ANIM_LACE | ANIM_HAM | ANIM_CYCLE);
  216.   file_size    = 0;
  217.   file_read    = 0;
  218.   iff_imagex = iff_max_imagex = 0;
  219.   iff_imagey = iff_max_imagey = 0;
  220.   iff_imagec = iff_max_imagec = 0;
  221.   iff_imaged = iff_max_imaged = 0;
  222.   iff_or_mask = 0;
  223.   iff_max_fvid_size = 0;
  224.   prop_flag    = 0;
  225.   bmhd_flag    = 0;
  226.   face_flag    = 0;
  227.   crng_flag    = 0;
  228.   camg_flag    = 0;
  229.   cmap_flag    = xaFALSE;
  230.   chdr_flag    = xaFALSE;
  231.   ansq_flag    = 0;
  232.   iff_ansq    = 0;
  233.   iff_ansq_cnt    = 0;
  234.   iff_dlta_acts    = 0;
  235.   iff_dlta_cnt    = 0;
  236.   iff_chdr    = 0;
  237.   iff_cmap_bits = 4;
  238.   iff_cur_hmap  = 0;
  239.  
  240.   exit_flag = 0; 
  241.   while( !xin->At_EOF(xin,-1) && !exit_flag)
  242.   {
  243.     /* read Chunk_Header 
  244.     */
  245.     chunk.id   = xin->Read_MSB_U32(xin);
  246.     chunk.size = xin->Read_MSB_U32(xin);
  247.  
  248.     if ( xin->At_EOF(xin,-1) ) break;    
  249.     if (chunk.size == -1) ret = -1;
  250.     else ret = 0;
  251.  
  252.     DEBUG_LEVEL1
  253.     {
  254.       fprintf(stderr,"Chunk.ID = ");
  255.       IFF_Print_ID(stderr,chunk.id);
  256.       fprintf(stderr,"  chunksize=%x\n",chunk.size);
  257.     }
  258.     if (chunk.size & 1) chunk.size += 1; /* halfword pad it */
  259.     if (ret==0)
  260.     {
  261.       switch(chunk.id)
  262.       {
  263.         case PROP: 
  264.                 prop_flag=1;
  265.         case LIST: 
  266.         case FORM: 
  267.                 formtype = xin->Read_MSB_U32(xin);
  268.         file_size = chunk.size;
  269.         if (file_size & 0x01) file_size++;
  270.  
  271.         if (   (formtype != 0x494C424D)   /* ILBM 0x494C424D */
  272.             && (formtype != 0x414E494D) ) /* ANIM 0x414E494D */
  273.         {
  274.           fprintf(stderr,"IFF: unsupported FORM Type: ");
  275.           IFF_Print_ID(stderr,formtype);
  276.                   fprintf(stderr,"\n");
  277.           xin->Seek_FPos(xin,file_size,1);
  278.           file_read = 0;
  279.         }
  280.         else    file_read = -1;
  281.  
  282.                 DEBUG_LEVEL2
  283.                 {
  284.                   fprintf(stderr,"  IFF ");
  285.                   IFF_Print_ID(stderr,chunk.id);
  286.                   fprintf(stderr," = ");
  287.                   IFF_Print_ID(stderr,formtype);
  288.                   fprintf(stderr,"\n");
  289.                 }
  290.                 break;
  291.         case BMHD:
  292.         IFF_Read_BMHD(xin,&bmhd);
  293.                 if (xa_verbose)
  294.                 { fprintf(stderr,"     Size %dx%dx%d comp=%d masking=%d\n",
  295.                                 bmhd.width,bmhd.height,bmhd.depth,
  296.                                 bmhd.compression,bmhd.masking);
  297.                 }
  298.                 iff_imagex = bmhd.width;
  299.                 iff_imagey = bmhd.height;
  300.                 iff_imaged = bmhd.depth;
  301.         if (iff_imaged == 8) iff_cmap_bits = 8;
  302.         else iff_cmap_bits = 4;
  303.                 if (iff_imagex > iff_max_imagex) iff_max_imagex = iff_imagex;
  304.                 if (iff_imagey > iff_max_imagey) iff_max_imagey = iff_imagey;
  305.                 if (iff_imaged > iff_max_imaged) iff_max_imaged = iff_imaged;
  306.         /* or_mask is used to move pixels to upper reaches of cmap
  307.          */
  308.         iff_or_mask = CMAP_Get_Or_Mask(1 << iff_imaged);
  309.                 bmhd_flag = 1;
  310.                 break;
  311.  
  312.     case FACE: /* used in MovieSetter anims */
  313.           {
  314.         xaULONG garb;
  315.         bmhd.pageWidth  = bmhd.width  = xin->Read_MSB_U16(xin);
  316.         bmhd.pageHeight = bmhd.height = xin->Read_MSB_U16(xin);
  317.         garb = xin->Read_MSB_U32(xin); /* read x, y */
  318.         garb = xin->Read_MSB_U32(xin); /* read xoff, yoff */
  319.         bmhd.depth = 5;
  320.         bmhd.compression = BMHD_COMP_BYTERUN;
  321.         bmhd.x = bmhd.y = bmhd.masking = 0;
  322.         bmhd.transparentColor = 0;
  323.         bmhd.xAspect = bmhd.yAspect = 0;
  324.                 face_flag = bmhd_flag = 1;
  325.                 iff_imagex = bmhd.width;
  326.                 iff_imagey = bmhd.height;
  327.                 iff_imaged = bmhd.depth;
  328.                 if (iff_imagex > iff_max_imagex) iff_max_imagex = iff_imagex;
  329.                 if (iff_imagey > iff_max_imagey) iff_max_imagey = iff_imagey;
  330.                 if (iff_imaged > iff_max_imaged) iff_max_imaged = iff_imaged;
  331.         iff_or_mask = CMAP_Get_Or_Mask(1 << iff_imaged);
  332.                 if (xa_verbose)
  333.                 {
  334.                  fprintf(stderr,"     Size %dx%dx%d comp=%d masking=%d\n",
  335.                                 bmhd.width,bmhd.height,bmhd.depth,
  336.                                 bmhd.compression,bmhd.masking);
  337.                 }
  338.           }
  339.               break;
  340.  
  341.         case CAMG:
  342.                 {
  343.                   DEBUG_LEVEL2 fprintf(stderr,"IFF CAMG\n");
  344.                   if (chunk.size != 4) 
  345.                   { 
  346.             xin->Seek_FPos(xin,chunk.size,1);
  347.                     break;
  348.                   }
  349.  
  350.                   camg_flag = xin->Read_MSB_U32(xin) | IFF_CAMG_NOP;
  351.  
  352.                   if ((camg_flag & IFF_CAMG_EHB) && (cmap_flag == xaTRUE))  
  353.                   {
  354.                     IFF_Adjust_For_EHB(iff_cmap,iff_cmap_bits);
  355.             iff_chdr = 
  356.             ACT_Get_CMAP(iff_cmap,iff_imagec,iff_or_mask,
  357.                 iff_imagec,iff_or_mask,
  358.                 iff_cmap_bits,iff_cmap_bits,iff_cmap_bits);
  359.             chdr_flag = xaTRUE;
  360.                     break;
  361.                   }
  362.                   if (camg_flag & IFF_CAMG_LACE) iff_anim_flags |= ANIM_LACE;
  363.  
  364.                   if ((camg_flag & IFF_CAMG_HAM) && (cmap_flag == xaTRUE)) 
  365.                   {
  366.                     XA_ACTION *act;
  367.  
  368.                         /* CREATE ACT_IFF_HMAP chunk */
  369.                     if (iff_cmap_bits == 8)
  370.                     {
  371.                       act = ACT_Get_Action(anim_hdr,ACT_IFF_HMAP8);
  372.                       iff_anim_flags |= ANIM_HAM8;
  373.                     }
  374.                     else
  375.                     {
  376.                       act = ACT_Get_Action(anim_hdr,ACT_IFF_HMAP6);
  377.                       iff_anim_flags |= ANIM_HAM6;
  378.                     }
  379.                     IFF_Setup_HMAP(act,iff_hmap,iff_cmap,iff_cmap_bits);
  380.                     iff_cur_hmap = (ColorReg *)act->data;
  381.  
  382.                     if (cmap_true_to_332 == xaTRUE)
  383.                     {
  384.                       iff_chdr = CMAP_Create_332(iff_cmap,&iff_imagec);
  385.               iff_or_mask = 0;
  386.                     }
  387.                     else /* if (cmap_true_to_gray == xaTRUE) */
  388.                     {
  389.                       iff_chdr = CMAP_Create_Gray(iff_cmap,&iff_imagec);
  390.               iff_or_mask = 0;
  391.                     }
  392.                     chdr_flag = xaTRUE;
  393.                   }
  394.                 }
  395.                 break;
  396.  
  397.         case CMAP:
  398.                 {
  399.           xaULONG tmp;
  400.                   DEBUG_LEVEL2 fprintf(stderr,"IFF CMAP\n");
  401.  
  402.                   if (chunk.size == 0x40) 
  403.           {
  404.             iff_imagec = chunk.size / 2; /* xR+GB */
  405.             IFF_Read_CMAP_1(iff_cmap,iff_imagec,xin);
  406.           }
  407.                   else
  408.           {
  409.             iff_imagec = chunk.size / 3;  /* Rx+Gx+Bx 1 byte each */
  410.             IFF_Read_CMAP_0(iff_cmap,iff_imagec,xin);
  411.           }
  412.  
  413.                   /* Typically iff_imaged matches iff_imagec but not always 
  414.                    * HAM and EHB are frequent examples
  415.            */
  416.                   if (bmhd_flag)
  417.           {
  418.             tmp = 0x01 << iff_imaged;
  419.             if (tmp < iff_imagec) iff_imagec = tmp;
  420.           }
  421.  
  422.                   if (camg_flag & IFF_CAMG_HAM) 
  423.                   {
  424.                     XA_ACTION *act;
  425.                     if (iff_cmap_bits == 8)
  426.             {
  427.                       act = ACT_Get_Action(anim_hdr,ACT_IFF_HMAP8);
  428.               iff_anim_flags |= ANIM_HAM8;
  429.             }
  430.                     else
  431.             {
  432.                       act = ACT_Get_Action(anim_hdr,ACT_IFF_HMAP6);
  433.                       iff_anim_flags |= ANIM_HAM6;
  434.             }
  435.                     IFF_Setup_HMAP(act,iff_hmap,iff_cmap,iff_cmap_bits);
  436.                     iff_cur_hmap = (ColorReg *)act->data;
  437.  
  438.                     if (cmap_true_to_332 == xaTRUE)
  439.                     {
  440.                       iff_chdr = CMAP_Create_332(iff_cmap,&iff_imagec);
  441.                       iff_or_mask = 0;
  442.                     }
  443.                     else /* if (cmap_true_to_gray == xaTRUE) */
  444.                     {
  445.                       iff_chdr = CMAP_Create_Gray(iff_cmap,&iff_imagec);
  446.                       iff_or_mask = 0;
  447.                     }
  448.             chdr_flag = xaTRUE;
  449.                   }
  450.           else if (camg_flag & IFF_CAMG_EHB)
  451.           {
  452.                     IFF_Adjust_For_EHB(iff_cmap,iff_cmap_bits);
  453.                     iff_chdr =
  454.                       ACT_Get_CMAP(iff_cmap,iff_imagec,iff_or_mask,
  455.                 iff_imagec,iff_or_mask,
  456.                 iff_cmap_bits,iff_cmap_bits,iff_cmap_bits);
  457.             chdr_flag = xaTRUE;
  458.           }
  459.           else if (camg_flag) /* NOT HAM6,HAM8 or EHB */
  460.           {
  461.             if (iff_cmap_bits == 4) 
  462.             IFF_Shift_CMAP(iff_cmap,iff_imagec);
  463.                     iff_chdr = ACT_Get_CMAP(iff_cmap,iff_imagec,iff_or_mask,
  464.                 iff_imagec,iff_or_mask,
  465.                 iff_cmap_bits,iff_cmap_bits,iff_cmap_bits);
  466.             chdr_flag = xaTRUE;
  467.           }
  468.                   cmap_flag = xaTRUE;
  469.                 }
  470.                 break;
  471.  
  472.     case BODY:
  473.       {
  474.         XA_ACTION *act;
  475.         ACT_DLTA_HDR *dlta_hdr;
  476.  
  477.         DEBUG_LEVEL2 fprintf(stderr,"IFF BODY\n");
  478.         if (chdr_flag == xaFALSE)
  479.         {
  480.           if (cmap_flag==xaTRUE)
  481.           {   
  482.             if (iff_cmap_bits == 4) IFF_Shift_CMAP(iff_cmap,iff_imagec);
  483.             iff_chdr = ACT_Get_CMAP(iff_cmap,iff_imagec,iff_or_mask,
  484.                     iff_imagec,iff_or_mask,iff_cmap_bits,
  485.                     iff_cmap_bits,iff_cmap_bits);
  486.             chdr_flag = xaTRUE;
  487.             IFF_Register_CRNGs(anim_hdr,iff_chdr);
  488.             camg_flag = IFF_CAMG_NOP; /* so future CMAPs okay */
  489.           }   
  490.           else IFF_TheEnd1("IFF_Read_BODY: no cmap\n");
  491.         }
  492.  
  493.         act = ACT_Get_Action(anim_hdr,ACT_DELTA);
  494.         ACT_Add_CHDR_To_Action(act,iff_chdr);
  495.         act->h_cmap = iff_cur_hmap;
  496.         IFF_Add_Frame(1,act);
  497.  
  498. /* POD TEMP FINISH THIS eventually. For now body's are read in
  499.         if (xin->load_flag & XA_IN_LOAD_FILE)
  500.         {
  501.           dlta_hdr =(ACT_DLTA_HDR *)malloc(sizeof(ACT_DLTA_HDR));
  502.           if (dlta_hdr == 0) IFF_TheEnd1("IFF_Read_BODY: malloc err");
  503.           act->data = (xaUBYTE *)dlta_hdr;
  504.           dlta_hdr->flags = ACT_DBL_BUF;
  505.           dlta_hdr->fpos  = xin->Seek_FPos(xin);
  506.           dlta_hdr->fsize = chunk.size;
  507.           xin->Seek_FPos(xin,chunk.size,1);
  508.           if (chunk.size > iff_max_fvid_size) iff_max_fvid_size =chunk.size;
  509.         }
  510.         else
  511. */
  512.         {
  513.           dlta_hdr = (ACT_DLTA_HDR *) malloc( sizeof(ACT_DLTA_HDR)
  514.                         + (iff_imagex * iff_imagey) );
  515.           if (dlta_hdr == 0) IFF_TheEnd1("IFF_Read_BODY: malloc err");
  516.           act->data = (xaUBYTE *)dlta_hdr;
  517.           dlta_hdr->flags = ACT_DBL_BUF | DLTA_DATA;
  518.           dlta_hdr->fpos = 0; dlta_hdr->fsize = chunk.size;
  519.           IFF_Read_BODY(xin,dlta_hdr->data,chunk.size,
  520.                 iff_imagex, iff_imagey, iff_imaged,
  521.                 (int)(bmhd.compression),(int)(bmhd.masking),
  522.                 iff_or_mask);
  523.         }
  524.         dlta_hdr->xapi_rev = 0x0001;
  525.         dlta_hdr->delta = IFF_Delta_Body;
  526.         dlta_hdr->xsize = iff_imagex;    dlta_hdr->ysize = iff_imagey;
  527.         dlta_hdr->xpos = dlta_hdr->ypos = 0;
  528.         dlta_hdr->special = 0;
  529.         dlta_hdr->extra = (void *)(0);
  530.       }
  531.       break;
  532.  
  533.         case ANHD:
  534.         {
  535.           Anim_Header   anhd;
  536.           DEBUG_LEVEL2 fprintf(stderr,"IFF ANHD\n");
  537.           if (chunk.size >= Anim_Header_SIZE)
  538.           {
  539.             IFF_Read_ANHD(xin,&anhd,chunk.size);
  540.             iff_dlta_compression = anhd.op;
  541.             iff_dlta_bits = anhd.bits;
  542. /*
  543.             if (xa_verbose) 
  544.             fprintf(stderr,"ANHD time = %d\n",anhd.reltime); 
  545. */
  546.           }
  547.           else 
  548.           {
  549.             xin->Seek_FPos(xin,chunk.size,1);
  550.             iff_dlta_compression = 0xffffffff;
  551.             iff_dlta_bits = 0x0;
  552.             fprintf(stderr,"ANHD chunksize mismatch %d\n",chunk.size);
  553.           }
  554.         }
  555.         break;
  556.  
  557.         case DLTA:
  558.       {
  559.         ACT_DLTA_HDR *dlta_hdr;
  560.         XA_ACTION *act;
  561.         DEBUG_LEVEL2 fprintf(stderr,"IFF DLTA: ");
  562.         act = ACT_Get_Action(anim_hdr,ACT_DELTA);
  563.         ACT_Add_CHDR_To_Action(act,iff_chdr);
  564.         act->h_cmap = iff_cur_hmap;
  565.           IFF_Add_Frame(1,act);
  566.  
  567.         if (xin->load_flag & XA_IN_LOAD_FILE)
  568.         {
  569.           dlta_hdr =(ACT_DLTA_HDR *)malloc(sizeof(ACT_DLTA_HDR));
  570.           if (dlta_hdr == 0) IFF_TheEnd1("IFF_Read_DLTA: malloc err");
  571.           act->data = (xaUBYTE *)dlta_hdr;
  572.           dlta_hdr->flags = ACT_DBL_BUF;
  573.           dlta_hdr->fpos  = xin->Seek_FPos(xin);
  574.           dlta_hdr->fsize = chunk.size;
  575.           xin->Seek_FPos(xin,chunk.size,1);
  576.           if (chunk.size > iff_max_fvid_size) iff_max_fvid_size =chunk.size;
  577.         }
  578.         else
  579.         {
  580.           dlta_hdr =(ACT_DLTA_HDR *)malloc(sizeof(ACT_DLTA_HDR)+chunk.size);
  581.           if (dlta_hdr == 0) IFF_TheEnd1("IFF_Read_DLTA: malloc err");
  582.           act->data = (xaUBYTE *)dlta_hdr;
  583.           dlta_hdr->flags = ACT_DBL_BUF | DLTA_DATA;
  584.           dlta_hdr->fpos = 0; dlta_hdr->fsize = chunk.size;
  585.           ret=xin->Read_Block(xin,dlta_hdr->data,chunk.size);
  586.         }
  587.  
  588.         dlta_hdr->xsize = iff_imagex;
  589.         dlta_hdr->ysize = iff_imagey;
  590.         dlta_hdr->xpos = dlta_hdr->ypos = 0;
  591.         dlta_hdr->special = 0;
  592.         dlta_hdr->extra = (void *)(0);
  593.         dlta_hdr->xapi_rev = 0x0001;
  594.         switch(iff_dlta_compression)
  595.         {
  596.           case  3:
  597.         DEBUG_LEVEL2 fprintf(stderr,"type 3\n");
  598.         dlta_hdr->delta = IFF_Delta_3;
  599.         break;
  600.           case 5:
  601.         DEBUG_LEVEL2 fprintf(stderr,"type 5\n");
  602.         dlta_hdr->delta = IFF_Delta_5;
  603.         break;
  604.           case 7:
  605.         dlta_hdr->delta = IFF_Delta_7;
  606.         if (iff_dlta_bits & IFF_ANHD_LDATA)
  607.         { 
  608.           DEBUG_LEVEL2 fprintf(stderr,"type 7L\n");
  609.           dlta_hdr->extra =  (void *)(0);
  610.         } 
  611.         else 
  612.         { 
  613.           DEBUG_LEVEL2 fprintf(stderr,"type 7S\n");
  614.           dlta_hdr->extra =  (void *)(1);
  615.         } 
  616.         break;
  617.           case 8:
  618.         dlta_hdr->delta = IFF_Delta_8;
  619.         if (iff_dlta_bits & IFF_ANHD_LDATA)
  620.         {
  621.           DEBUG_LEVEL2 fprintf(stderr,"type 8L\n");
  622.           dlta_hdr->extra =  (void *)(0);
  623.         }
  624.         else
  625.         {
  626.           DEBUG_LEVEL2 fprintf(stderr,"type 8S\n");
  627.           dlta_hdr->extra =  (void *)(1);
  628.         }
  629.         break;
  630.           case 74:
  631.         DEBUG_LEVEL2 fprintf(stderr,"type J\n");
  632.         dlta_hdr->delta = IFF_Delta_J;
  633.         break;
  634.           case  108:
  635.         dlta_hdr->delta = IFF_Delta_l;
  636.         dlta_hdr->extra =  (void *)(1);
  637.         DEBUG_LEVEL2 fprintf(stderr,"type l\n");
  638.         break;
  639.           default:  
  640.         act->type = ACT_NOP;
  641.         fprintf(stderr,"Unsupported Delta %d\n",iff_dlta_compression);
  642.         break;
  643.         }
  644.       }
  645.     break;
  646.  
  647.     case ANSQ:
  648.       {
  649.         DEBUG_LEVEL2 fprintf(stderr,"IFF ANSQ\n");
  650.         ansq_flag = 1;  /* we found an ansq chunk */
  651.         IFF_Read_ANSQ(xin,chunk.size);
  652.       }
  653.       break;
  654.  
  655.         case CRNG: 
  656.       DEBUG_LEVEL2 fprintf(stderr,"IFF CRNG\n");
  657.       IFF_Read_CRNG(anim_hdr,xin,chunk.size,&crng_flag);
  658.       break;
  659.  
  660.     case TINY : /* ignore */
  661.     case DPI : /* ignore */
  662.     case IMRT: /* ignore */
  663.     case GRAB: /* ignore */
  664.     case DPPS: /* ignore */
  665.     case DPPV: /* ignore */
  666.     case DPAN: /* ignore */
  667.     case DRNG: /* ignore */
  668.     case VHDR: /* sound ignore should kill next body until bmhd*/
  669.     case ANNO: /* sound ignore */
  670.     case CHAN: /* sound ignore */
  671.     case ANFI: /* sound ignore */
  672.         xin->Seek_FPos(xin,chunk.size,1);
  673.                 break;
  674.     default:
  675.     if ( xin->At_EOF(xin,-1) ) exit_flag = 1;   /* end of file */
  676.     else
  677.     {
  678.       fprintf(stderr,"Unknown IFF type="); IFF_Print_ID(stderr,chunk.id);
  679.       if (   (file_read < file_size)    /* there should be more  */
  680.           && (chunk.size < (file_size - file_read) ) /*  size n 2 big */
  681.          )
  682.       {
  683.         fprintf(stderr,"  Will Continue Reading File.\n");
  684.         xin->Seek_FPos(xin,chunk.size,1);
  685.       }
  686.       else
  687.       {
  688.         fprintf(stderr,"  Will Stop Reading File.\n");
  689.         exit_flag = 1;
  690.       }
  691.     }
  692.     break;
  693.    } /* end chunk switch */
  694.    /*
  695.     * keep track of number of bytes read. This allows us to distinguish
  696.     * valid unknown chunks from garbage tacked to the end of a file.
  697.     */
  698.    if (!exit_flag)
  699.    {
  700.      if (file_read == -1) file_read = 4; /* assuming FORM chunk or similar */
  701.      else file_read += chunk.size + 8; /* add ID and SIZE of other chunks */
  702.    }
  703.  
  704.   } /* end if ret==0 */
  705.  } /* end of while not eof or exit_flag */
  706.  DEBUG_LEVEL2 fprintf(stderr,"Bytes Read = %x\n",file_read);
  707.  xin->Close_File(xin);
  708.  
  709.  /* 
  710.   * Set up a map of delta's to their action numbers.
  711.   */
  712.  {
  713.    xaULONG i;
  714.    xaULONG inter_dlta_i,dlta_i,act_i;
  715.  
  716.    iff_dlta_acts = 
  717.     (IFF_DLTA_TABLE *)malloc( (iff_dlta_cnt + 1) * sizeof(IFF_DLTA_TABLE));
  718.    if (iff_dlta_acts == 0) IFF_TheEnd1("IFF_Read_File: dlta_cnts malloc err");
  719.    for(i=0; i < iff_dlta_cnt; i++) 
  720.    {
  721.      iff_dlta_acts[i].cnt   = 0;
  722.      iff_dlta_acts[i].frame = 0;
  723.      iff_dlta_acts[i].start = 0;
  724.      iff_dlta_acts[i].end   = 0;
  725.    }
  726.    dlta_i = 0;
  727.    act_i = 0;
  728.    inter_dlta_i = 0;
  729.  
  730.    iff_act_cur = iff_act_start;
  731.    iff_dlta_acts[dlta_i].start = iff_act_cur;
  732.    iff_dlta_acts[dlta_i].frame = act_i;
  733.    while(iff_act_cur != 0)
  734.    {
  735.      inter_dlta_i++;
  736.      act_i++;
  737.      switch(iff_act_cur->act->type)
  738.      {
  739.        case ACT_DELTA:
  740.         iff_dlta_acts[dlta_i].cnt = inter_dlta_i;
  741.         iff_dlta_acts[dlta_i].end = iff_act_cur;
  742.         inter_dlta_i = 0;
  743.         iff_act_cur = iff_act_cur->next;
  744.         dlta_i++; 
  745.         if (dlta_i > iff_dlta_cnt)
  746.         {
  747.             fprintf(stderr,"IFF_Read: dlta setup err  <%d > %d> \n",
  748.                         dlta_i,iff_dlta_cnt);
  749.             IFF_TheEnd();
  750.         }
  751.         if (dlta_i < iff_dlta_cnt)
  752.         {
  753.           iff_dlta_acts[dlta_i].start = iff_act_cur;
  754.           iff_dlta_acts[dlta_i].frame = act_i;
  755.         }
  756.         break;
  757.        default:
  758.         iff_act_cur = iff_act_cur->next;
  759.         break;
  760.      }
  761.    } /* end of while */
  762.    DEBUG_LEVEL1 fprintf(stderr,"%d dltas found\n",dlta_i);
  763.  
  764.    iff_time = XA_GET_TIME(IFF_SPEED_DEFAULT * IFF_MS_PER_60HZ);
  765.  
  766.    if (ansq_flag)
  767.    {
  768.      xaLONG i,t_time;
  769.      xaULONG iff_frame_cnt,frame_i;
  770.  
  771.      t_time = 0;
  772.      iff_frame_cnt = iff_dlta_acts[0].cnt;  /* start with body cnt */
  773.      for(i=0; i < iff_ansq_cnt; i++) /* count frames */
  774.      {
  775.        if (iff_ansq[i].time != 0xffff) /* if not loop frame */
  776.       iff_frame_cnt += iff_dlta_acts[ iff_ansq[i].dnum + 1 ].cnt;
  777.      }
  778.      anim_hdr->frame_lst = 
  779.     (XA_FRAME *)malloc(sizeof(XA_FRAME) * (iff_frame_cnt + 1));
  780.      if (anim_hdr->frame_lst == NULL) 
  781.     IFF_TheEnd1("IFF ANSQ: frame_lst malloc err");
  782.   
  783.        /* For movies default loop frame is 0 */
  784.      anim_hdr->loop_frame = 0;
  785.  
  786.      /* take care of frame up to BODY */
  787.      frame_i = 0;
  788.      iff_act_cur = iff_dlta_acts[0].start;
  789.      while(iff_act_cur != 0)
  790.      {
  791.        anim_hdr->frame_lst[frame_i].act = iff_act_cur->act;
  792.        if (iff_act_cur == iff_dlta_acts[0].end)
  793.        {
  794.      anim_hdr->frame_lst[frame_i].time_dur = iff_time;
  795.      anim_hdr->frame_lst[frame_i].zztime = t_time;
  796.      t_time += iff_time;
  797.      frame_i++;
  798.      break;
  799.        }
  800.        else 
  801.        {
  802.      anim_hdr->frame_lst[frame_i].time_dur = 0;
  803.      anim_hdr->frame_lst[frame_i].zztime = t_time;
  804.        }
  805.        frame_i++;  
  806.        iff_act_cur = iff_act_cur->next;
  807.        if ( (frame_i > iff_frame_cnt) && (iff_act_cur != 0) )
  808.        {
  809.          fprintf(stderr,"IFF_ansq: frame err %d %d\n",frame_i,iff_frame_cnt);
  810.          IFF_TheEnd();
  811.        }
  812.      }
  813.      for(i=0; i < iff_ansq_cnt; i++)
  814.      {
  815.         if (iff_ansq[i].time == 0xffff) /* loop frame */
  816.         {
  817.           anim_hdr->loop_frame = iff_ansq[ iff_ansq[i].dnum ].frame;
  818.         }
  819.         else
  820.         {
  821.       xaULONG dlta_j;
  822.       iff_ansq[i].frame = frame_i; /* for looping info */
  823.           dlta_j = iff_ansq[i].dnum + 1;
  824.           iff_time = XA_GET_TIME(iff_ansq[i].time * IFF_MS_PER_60HZ);
  825.       iff_act_cur = iff_dlta_acts[dlta_j].start;
  826.       while(iff_act_cur != 0)
  827.       {
  828.         anim_hdr->frame_lst[frame_i].act = iff_act_cur->act;
  829.             if (iff_act_cur == iff_dlta_acts[dlta_j].end) 
  830.         {
  831.           anim_hdr->frame_lst[frame_i].time_dur = iff_time;
  832.           anim_hdr->frame_lst[frame_i].zztime = t_time;
  833.           t_time += iff_time;
  834.           frame_i++;  
  835.           break;
  836.         }
  837.         else 
  838.         {
  839.           anim_hdr->frame_lst[frame_i].time_dur = 0;
  840.           anim_hdr->frame_lst[frame_i].zztime = t_time;
  841.         }
  842.         frame_i++;  
  843.             iff_act_cur = iff_act_cur->next;
  844.         if ( (frame_i > iff_frame_cnt) && (iff_act_cur != 0) )
  845.         {
  846.           fprintf(stderr,"IFF_ansq: frame err %d %d\n",
  847.                         frame_i,iff_frame_cnt);
  848.           IFF_TheEnd();
  849.         }
  850.       }
  851.         }
  852.       } /* end of for */
  853.       anim_hdr->frame_lst[frame_i].time_dur = 0;
  854.       anim_hdr->frame_lst[frame_i].zztime = -1;
  855.       anim_hdr->frame_lst[frame_i].act  = 0;
  856.       anim_hdr->last_frame = frame_i - 1;
  857.       anim_hdr->total_time = anim_hdr->frame_lst[frame_i-1].zztime 
  858.                                 + anim_hdr->frame_lst[frame_i-1].time_dur;
  859.     }
  860.     else   /* no ansq chunk */
  861.     {
  862.       xaLONG frame_i,t_time;
  863.  
  864.       t_time = 0;
  865.       /* extra for end and JMP2END */
  866.       anim_hdr->frame_lst = 
  867.       (XA_FRAME *)malloc(sizeof(XA_FRAME) * (iff_act_cnt + 2));
  868.       if (anim_hdr->frame_lst == NULL)
  869.         IFF_TheEnd1("IFF_Read: frame malloc err");
  870.       iff_act_cur = iff_act_start;
  871.       frame_i = 0;
  872.       while(iff_act_cur != 0)
  873.       {
  874.         anim_hdr->frame_lst[frame_i].act  = iff_act_cur->act;
  875.     if (iff_act_cur->type == 1)
  876.     {
  877.       if ( (iff_dlta_cnt == 1) && (crng_flag) && (xa_jiffy_flag == 0) )
  878. /* && (iff_act_cur->act->type == ACT_IFF_BODY) ) */
  879.       {
  880.             anim_hdr->frame_lst[frame_i].time_dur = DEFAULT_CYCLING_TIME;
  881.             anim_hdr->frame_lst[frame_i].zztime = t_time;
  882.         t_time += DEFAULT_CYCLING_TIME;
  883.       }
  884.           else
  885.       {
  886.         anim_hdr->frame_lst[frame_i].time_dur = iff_time;
  887.         anim_hdr->frame_lst[frame_i].zztime   = t_time;
  888.         t_time += iff_time;
  889.       }
  890.     }
  891.     else
  892.     {
  893.       anim_hdr->frame_lst[frame_i].time_dur = 0;
  894.       anim_hdr->frame_lst[frame_i].zztime = t_time;
  895.     }
  896.         iff_act_cur = iff_act_cur->next;
  897.         frame_i++;
  898.         if (frame_i > iff_act_cnt)
  899.         {
  900.           fprintf(stderr,"IFF_Read: frame inconsistency %d %d\n",
  901.                 frame_i,iff_act_cnt);
  902.           IFF_TheEnd();
  903.         }
  904.       }
  905.       /* Add JMP2END so deltas to beginning aren't displayed unless looping */
  906.       if ( !(iff_anim_flags & ANIM_NOLOOP) && (iff_dlta_cnt > 3) && !face_flag)
  907.       { xaULONG kk = frame_i;
  908.     anim_hdr->frame_lst[kk].time_dur = 
  909.             anim_hdr->frame_lst[iff_dlta_acts[1].frame].time_dur;
  910.     anim_hdr->frame_lst[kk].zztime = 
  911.             anim_hdr->frame_lst[iff_dlta_acts[1].frame].zztime;
  912.     anim_hdr->frame_lst[kk].act  = anim_hdr->frame_lst[kk-1].act;
  913.     anim_hdr->frame_lst[kk-1].time_dur = 
  914.             anim_hdr->frame_lst[iff_dlta_acts[0].frame].time_dur;
  915.     anim_hdr->frame_lst[kk-1].zztime = 
  916.             anim_hdr->frame_lst[iff_dlta_acts[0].frame].zztime;
  917.     anim_hdr->frame_lst[kk-1].act  = anim_hdr->frame_lst[kk-2].act;
  918.         anim_hdr->frame_lst[kk-2].time_dur = 0;
  919.         anim_hdr->frame_lst[kk-2].zztime = -1;
  920.     anim_hdr->frame_lst[kk-2].act = ACT_Get_Action(anim_hdr,ACT_JMP2END);
  921.     /* PODNOTE: IFF last two frames need to have zztime start at 0 again*/
  922.         frame_i++;
  923.         anim_hdr->loop_frame = iff_dlta_acts[2].frame;
  924.         anim_hdr->total_time = anim_hdr->frame_lst[frame_i-4].zztime 
  925.                                 + anim_hdr->frame_lst[frame_i-4].time_dur;
  926.       }
  927.       else
  928.       {
  929.     anim_hdr->loop_frame = 0; 
  930.         anim_hdr->total_time = anim_hdr->frame_lst[frame_i-1].zztime 
  931.                                 + anim_hdr->frame_lst[frame_i-1].time_dur;
  932.       }
  933.       if (frame_i > 0 ) anim_hdr->last_frame = frame_i - 1;
  934.       else anim_hdr->last_frame = 0;
  935.       anim_hdr->frame_lst[frame_i].time_dur = 0;
  936.       anim_hdr->frame_lst[frame_i].zztime = -1;
  937.       anim_hdr->frame_lst[frame_i].act  = 0;
  938.       frame_i++;
  939.       if (xa_verbose) 
  940.       {
  941.     fprintf(stderr,"     dlta_cnt=%d comp=%d ",
  942.                 iff_dlta_cnt,iff_dlta_compression);
  943.     if (camg_flag & IFF_CAMG_EHB) fprintf(stderr," EHB\n");
  944.     else if (iff_anim_flags & ANIM_HAM8) fprintf(stderr," HAM8\n");
  945.     else if (iff_anim_flags & ANIM_HAM6) fprintf(stderr," HAM6\n");
  946.     else fprintf(stderr,"\n");
  947.       }
  948.     }
  949.   }
  950.   anim_hdr->imagex = iff_max_imagex;
  951.   anim_hdr->imagey = iff_max_imagey;
  952.   anim_hdr->imagec = iff_imagec;
  953.   anim_hdr->imaged = iff_max_imaged;
  954.  
  955.   /* Some older IFF files don't include a CAMG chunk to indicate they
  956.    * are interlaced. They just assume the viewer will figure it out.
  957.    * Below is an arbitrary ruleset that'll hopefully work for most cases.
  958.    */
  959.    if ((iff_max_imagex >= 400) && (iff_max_imagey > iff_max_imagex))
  960.     iff_anim_flags |= ANIM_LACE;
  961.  
  962.   /* NOTE: A lot of IFF animations have active color cycle chunks, yet
  963.    *       they were never intended to cycle. AAARRRRGH!!!
  964.    */
  965.   if (iff_dlta_cnt == 1)  /* single image IFF files */
  966.   {
  967.     if ( (crng_flag) && (iff_allow_cycling == xaTRUE) )
  968.                     iff_anim_flags |= ANIM_CYCLE;
  969.     else iff_anim_flags &= ~ANIM_CYCLE;
  970.   }
  971.   else /* animation IFF files */
  972.   {
  973.     if ( (crng_flag) && (iff_allow_cycling == xaTRUE) 
  974.         && (xa_anim_cycling == xaTRUE) )   iff_anim_flags |= ANIM_CYCLE;
  975.     else iff_anim_flags &= ~ANIM_CYCLE;
  976.   }
  977.   anim_hdr->anim_flags = iff_anim_flags;
  978.   IFF_Free_Stuff();
  979.   iff_chdr = 0;
  980.   if (xin->load_flag & XA_IN_LOAD_BUF) IFF_Buffer_Action(anim_hdr);
  981.   else
  982.   {
  983.     anim_hdr->anim_flags |= ANIM_SNG_BUF;
  984.     if (iff_dlta_cnt > 1) anim_hdr->anim_flags |= ANIM_DBL_BUF;
  985.     if (iff_anim_flags | ANIM_HAM) anim_hdr->anim_flags |= ANIM_3RD_BUF;
  986.   }
  987.   if (xin->load_flag & XA_IN_LOAD_FILE) anim_hdr->anim_flags |= ANIM_USE_FILE;
  988.   anim_hdr->fname = anim_hdr->name;
  989.   anim_hdr->max_fvid_size = iff_max_fvid_size;
  990.   return(xaTRUE);
  991. }
  992.  
  993. /*
  994.  *
  995.  */
  996. void IFF_Adjust_For_EHB(colormap,cmap_bits)
  997. ColorReg colormap[];
  998. xaULONG cmap_bits;
  999. {
  1000.   xaLONG i,cmap_num;
  1001.  
  1002.   DEBUG_LEVEL1 
  1003.     fprintf(stderr,"Adjusting CMAP for Amiga Extra Half-Brite Mode\n");
  1004.   if (cmap_bits == 8) cmap_num = 128;
  1005.   else 
  1006.   { /* 4 bits per rgb, shift down from 8 bits to 4 bits */
  1007.     cmap_num = 32;
  1008.     IFF_Shift_CMAP(colormap,cmap_num);
  1009.   }
  1010.  
  1011.    /* make upper half a darkened version of the lower half */
  1012.   for(i=0;i<cmap_num;i++)
  1013.   {
  1014.     colormap[i + cmap_num].red   = colormap[i].red   >> 2;
  1015.     colormap[i + cmap_num].green = colormap[i].green >> 2;
  1016.     colormap[i + cmap_num].blue  = colormap[i].blue  >> 2;
  1017.   }
  1018.   iff_imagec = 2 * cmap_num;
  1019.   iff_or_mask = CMAP_Get_Or_Mask(iff_imagec);
  1020. }
  1021.  
  1022.  
  1023. /*
  1024.  *
  1025.  */
  1026. void IFF_Read_BODY(xin,image_out,bodysize,xsize,ysize,depth,
  1027.             compression,masking,or_mask)
  1028. XA_INPUT *xin;
  1029. xaUBYTE *image_out;
  1030. xaULONG xsize,ysize,depth;
  1031. xaLONG bodysize,compression,masking;
  1032. xaULONG or_mask;
  1033. {
  1034.  xaLONG i,ret,x,y,d,dmask,tmp,rowsize;
  1035.  xaLONG imagex_pad;
  1036.  xaBYTE *inbuff,*rowbuff,*sptr;
  1037.  xaBYTE *sbuff,*dbuff;
  1038.  
  1039.  if (   (compression != BMHD_COMP_NONE) 
  1040.      && (compression != BMHD_COMP_BYTERUN) 
  1041.     ) IFF_TheEnd1("IFF_Read_Body: unsupported compression");
  1042.  
  1043.  if (   (masking != BMHD_MSK_NONE)
  1044.      && (masking != BMHD_MSK_HAS)
  1045.      && (masking != BMHD_MSK_TRANS)
  1046.     ) IFF_TheEnd1("IFF_Read_Body: unsupported masking");
  1047.  
  1048.  inbuff = (xaBYTE *)malloc(bodysize);
  1049.  if (inbuff == 0) IFF_TheEnd1("IFF_Read_Body: malloc failed");
  1050.  ret=xin->Read_Block(xin,inbuff,bodysize);
  1051.  if (ret<bodysize) IFF_TheEnd1("IFF_Read_Body: read of BODY chunk failed");
  1052.  sbuff = inbuff;
  1053.  
  1054.  
  1055.  /* width is rounded to multiples of 16 in the BODY form */
  1056.  /* extra bits are ignored upon reading */
  1057.  imagex_pad = xsize / 16;
  1058.  if (xsize % 16) imagex_pad++;
  1059.  imagex_pad *= 16;
  1060.  
  1061.  rowbuff = (xaBYTE *)malloc( imagex_pad );
  1062.  if (rowbuff == 0) IFF_TheEnd1("IFF_Read_Body: malloc failed");
  1063.  
  1064.  memset(image_out,or_mask,(xsize * ysize) );
  1065.  
  1066.  if (compression==BMHD_COMP_NONE) sptr = inbuff;
  1067.  
  1068.  for(y=0; y<ysize; y++)
  1069.  {
  1070.    tmp = y * xsize;
  1071.    dmask=1;
  1072.    for(d=0; d<depth; d++)
  1073.    {
  1074.  
  1075.      if (compression == BMHD_COMP_BYTERUN)
  1076.      {
  1077.        rowsize = imagex_pad / 8; 
  1078.        dbuff = rowbuff;
  1079.        ret=UnPackRow(&sbuff,&dbuff,&bodysize,&rowsize);
  1080.        if (ret) { fprintf(stderr,"error %d in unpack\n",ret); IFF_TheEnd();}
  1081.        sptr = rowbuff;
  1082.      }
  1083.  
  1084.      i = 0;
  1085.      for(x=0; x<xsize; x++)
  1086.      {
  1087.        if (mask[i] & (*sptr)) image_out[tmp+x] |= dmask;
  1088.        i++;
  1089.        if (i >= 8)
  1090.        {
  1091.      i = 0;
  1092.      sptr++;
  1093.        }
  1094.      }
  1095.      if (imagex_pad >= (xsize+8)) sptr++;
  1096.  
  1097.      dmask <<= 1;
  1098.    } /* end of depth loop */
  1099.  
  1100.    if (masking == BMHD_MSK_HAS)
  1101.    {
  1102.      /* read the mask row and then throw out for now */
  1103.      if (compression == BMHD_COMP_BYTERUN)
  1104.      {
  1105.        rowsize = imagex_pad / 8;
  1106.        dbuff = rowbuff;
  1107.        ret=UnPackRow(&sbuff,&dbuff,&bodysize,&rowsize);
  1108.        if (ret) { fprintf(stderr,"error %d in unpack\n",ret); IFF_TheEnd();}
  1109.      }
  1110.      else sptr += xsize/8;
  1111.    }
  1112.  } /* end of y loop */
  1113.  FREE(inbuff,0x1004);  inbuff=0;
  1114.  FREE(rowbuff,0x1005); rowbuff=0;
  1115. }
  1116.  
  1117.  
  1118.  
  1119. /*
  1120.  *
  1121.  */
  1122. void IFF_Print_ID(fout,id)
  1123. FILE *fout;
  1124. xaLONG id;
  1125. {
  1126.  fprintf(fout,"%c",     (char)((id >> 24) & 0xff)   );
  1127.  fprintf(fout,"%c",     (char)((id >> 16) & 0xff)   );
  1128.  fprintf(fout,"%c",     (char)((id >>  8) & 0xff)   );
  1129.  fprintf(fout,"%c(%x)",(char)(id        & 0xff),id);
  1130. }
  1131.  
  1132.  
  1133. /* 
  1134.  *
  1135.  */
  1136. xaULONG
  1137. IFF_Delta_5(image,delta,dsize,dec_info)
  1138. xaUBYTE *image;         /* Image Buffer. */
  1139. xaUBYTE *delta;         /* delta data. */
  1140. xaULONG dsize;          /* delta size */
  1141. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  1142. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  1143.   xaULONG imaged = dec_info->imaged;
  1144.   register xaLONG col,depth,dmask;
  1145.   register xaLONG rowsize,width;
  1146.   xaULONG poff;
  1147.   register xaUBYTE *i_ptr;
  1148.   register xaUBYTE *dptr,opcnt,op,cnt;
  1149.   xaLONG miny,minx,maxy,maxx;
  1150.  
  1151.   /* set to opposites for min/max testing */
  1152.   dec_info->xe = dec_info->ye = 0; dec_info->ys = imagey; dec_info->xs = imagex;
  1153.  
  1154.   width = imagex;
  1155.   rowsize = width >> 3;
  1156.   dmask = 1;
  1157.  for(depth=0; depth<imaged; depth++)
  1158.  {
  1159.   minx = -1;
  1160.   maxx = -1;
  1161.   
  1162.   i_ptr = image;
  1163.   /* offset into delt chunk */
  1164.   { register xaUSHORT ddepth = depth << 2;
  1165.     poff  = (xaULONG)(delta[ ddepth++ ]) << 24;
  1166.     poff |= (xaULONG)(delta[ ddepth++ ]) << 16;
  1167.     poff |= (xaULONG)(delta[ ddepth++ ]) <<  8;
  1168.     poff |= (xaULONG)(delta[ ddepth   ]);
  1169.   }
  1170.  
  1171.   if (poff)
  1172.   {
  1173.    dptr = (xaUBYTE *)(delta + poff);
  1174.    for(col=0;col<rowsize;col++)
  1175.    {
  1176.     /* start at top of column */
  1177.     i_ptr = (xaUBYTE *)(image + (col << 3));
  1178.     opcnt = *dptr++;  /* get number of ops for this column */
  1179.     
  1180.     miny = -1;
  1181.     maxy = -1;
  1182.  
  1183.     while(opcnt)    /* execute ops */
  1184.     {
  1185.        /* keep track of min and max columns */
  1186.        if (minx == -1) minx = col << 3;
  1187.        maxx = (col << 3) + 7;  
  1188.  
  1189.        op = *dptr++;   /* get op */
  1190.      
  1191.        if (op & 0x80)    /* if type uniqe */
  1192.        {
  1193.           if (miny == -1) miny=(xaULONG)( i_ptr - image ) / width;
  1194.           cnt = op & 0x7f;         /* get cnt */
  1195.       
  1196.           while(cnt--) /* loop through data */
  1197.           {
  1198.              register xaUBYTE data = *dptr++;
  1199.              IFF_Byte_Mod(i_ptr,data,dmask,0);
  1200.              i_ptr += width;
  1201.           }
  1202.         } /* end unique */
  1203.         else
  1204.         {
  1205.            if (op == 0)   /* type same */
  1206.            {
  1207.               register xaUBYTE data;
  1208.               if (miny == -1) miny=(xaULONG)( i_ptr - image ) / width;
  1209.               cnt = *dptr++;
  1210.               data = *dptr++;
  1211.  
  1212.               while(cnt--) /* loop through data */
  1213.               { 
  1214.                  IFF_Byte_Mod(i_ptr,data,dmask,0);
  1215.                  i_ptr += width;
  1216.               }
  1217.             } /* end same */
  1218.             else
  1219.             {
  1220.                i_ptr += (width * op);  /* type skip */
  1221.             }
  1222.          } /* end of hi bit clear */
  1223.        opcnt--;
  1224.      } /* end of while opcnt */
  1225.      maxy = (xaULONG)( i_ptr - image ) / width;
  1226.      if ( (miny>=0) && (miny < dec_info->ys)) dec_info->ys = miny;
  1227.      if ( (maxy>=0) && (maxy > dec_info->ye)) dec_info->ye = maxy;
  1228.     } /* end of column loop */
  1229.    } /* end of valid pointer for this plane */
  1230.    dmask <<= 1;
  1231.    if ( (minx>=0) && (minx < dec_info->xs)) dec_info->xs = minx;
  1232.    if ( (maxx>=0) && (maxx > dec_info->xe)) dec_info->xe = maxx;
  1233.   } /* end of for depth */
  1234.  
  1235.   if (xa_optimize_flag == xaTRUE)
  1236.   {
  1237.     if (dec_info->xs >= imagex) dec_info->xs = 0;
  1238.     if (dec_info->ys >= imagey) dec_info->ys = 0;
  1239.     if (dec_info->xe <= 0)      dec_info->xe = imagex;
  1240.     if (dec_info->ye <= 0)      dec_info->ye = imagey;
  1241.   }
  1242.   else
  1243.   {
  1244.     dec_info->xs = 0;      dec_info->ys = 0;
  1245.     dec_info->xe = imagex; dec_info->ye = imagey;
  1246.   }
  1247.   return(ACT_DLTA_NORM); 
  1248. } /* end of routine */
  1249.  
  1250. /*
  1251.  * 
  1252.  */
  1253. xaULONG
  1254. IFF_Delta_3(image,delta,dsize,dec_info)
  1255. xaUBYTE *image;         /* Image Buffer. */
  1256. xaUBYTE *delta;         /* delta data. */
  1257. xaULONG dsize;          /* delta size */
  1258. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  1259. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  1260.   xaULONG imaged = dec_info->imaged;
  1261.  register xaLONG i,depth,dmask;
  1262.  xaULONG poff;
  1263.  register xaSHORT  offset;
  1264.  register xaUSHORT s,data;
  1265.  register xaUBYTE  *i_ptr,*dptr;
  1266.  
  1267.  dec_info->xs = dec_info->ys = 0; dec_info->xe = imagex; dec_info->ye = imagey;
  1268.  dmask = 1;
  1269.  for(depth=0;depth<imaged;depth++)
  1270.  {
  1271.   i_ptr = image;
  1272.  
  1273.   /*poff = planeoff[depth];*/ /* offset into delt chunk */
  1274.  
  1275.   poff  = (xaULONG)(delta[ 4 * depth    ]) << 24;
  1276.   poff |= (xaULONG)(delta[ 4 * depth + 1]) << 16;
  1277.   poff |= (xaULONG)(delta[ 4 * depth + 2]) <<  8;
  1278.   poff |= (xaULONG)(delta[ 4 * depth + 3]);
  1279.  
  1280.   if (poff)
  1281.   {
  1282.    dptr = (xaUBYTE *)(delta + poff);
  1283.    while( (dptr[0] != 0xff) || (dptr[1] != 0xff) )
  1284.    {
  1285.      offset = (*dptr++)<<8; offset |= (*dptr++);
  1286.      if (offset >= 0)
  1287.      {
  1288.       data = (*dptr++)<<8; data |= (*dptr++);
  1289.       i_ptr += 16 * (xaULONG)(offset);
  1290.       IFF_Short_Mod(i_ptr,data,dmask,0);
  1291.      } /* end of pos */
  1292.      else
  1293.      {
  1294.       i_ptr += 16 * (xaULONG)(-(offset+2));
  1295.       s = (*dptr++)<<8; s |= (*dptr++); /* size of next */
  1296.       for(i=0; i < (xaULONG)s; i++)
  1297.       {
  1298.        data = (*dptr++)<<8; data |= (*dptr++);
  1299.        i_ptr += 16;
  1300.        IFF_Short_Mod(i_ptr,data,dmask,0);
  1301.       }
  1302.     }  /* end of neg */
  1303.    } /* end of delta for this plane */
  1304.   } /* plane has changed data */
  1305.   dmask <<= 1;
  1306.  } /* end of d */
  1307.  return(ACT_DLTA_NORM); 
  1308. }
  1309.  
  1310.  
  1311. void IFF_Hash_Init(num)
  1312. xaULONG num;
  1313. { register xaULONG i;
  1314.   iff_hash_cur=0;
  1315.   iff_hash_tbl = (IFF_HASH *)malloc(num * sizeof(IFF_HASH));
  1316.   if (iff_hash_tbl == 0) TheEnd1("IFF_Hash_Init: malloc err");
  1317.   for(i=0;i<num;i++) iff_hash_tbl[i].flag = ACT_DLTA_BAD;
  1318. }
  1319.  
  1320. void IFF_Hash_CleanUp()
  1321. {
  1322.   if (iff_hash_tbl)
  1323.   { register xaULONG i=0;
  1324.     while(i<iff_hash_cur)
  1325.     {
  1326.       register XA_ACTION *tact = iff_hash_tbl[i].dlta;
  1327.       if (tact)
  1328.       {
  1329.     if (tact->type == ACT_DELTA) ACT_Free_Act(tact);
  1330.       }
  1331.       i++;
  1332.     }
  1333.     FREE(iff_hash_tbl,0x100E); iff_hash_tbl=0;
  1334.   }
  1335. }
  1336.  
  1337. void IFF_Hash_Add(dlta,nxtdlta,src,dst,flag)
  1338. XA_ACTION *dlta,*nxtdlta,*src,**dst;
  1339. xaULONG flag;
  1340. { 
  1341.   register IFF_HASH *hptr = &iff_hash_tbl[iff_hash_cur];
  1342.   hptr->flag = flag;    
  1343.   hptr->dlta = dlta;    hptr->nxtdlta = nxtdlta;
  1344.   hptr->src = src;    hptr->dst = *dst;
  1345.   iff_hash_cur++;
  1346. }
  1347.  
  1348. xaULONG pod_temp_i;
  1349. XA_ACTION *IFF_Hash_Get(dlta,src,nxtdlta)
  1350. XA_ACTION *dlta,*src,*nxtdlta;
  1351. { register xaULONG i = 0;
  1352.   while(1)
  1353.   { IFF_HASH *hptr = &iff_hash_tbl[i];
  1354. pod_temp_i = i;
  1355.     if (hptr->flag & ACT_DLTA_BAD) return(0); /* end and nothing found */
  1356.     else if (hptr->dlta == dlta)
  1357.     {
  1358.       if (hptr->flag & ACT_DLTA_NOP)            return(src);
  1359.       else if (    (src == hptr->src)
  1360.         || (hptr->flag & ACT_DLTA_BODY) )    return(hptr->dst);
  1361.       else if (    (src == hptr->dst)
  1362.         && (hptr->flag & ACT_DLTA_XOR) )    return(hptr->src);
  1363.       else if (hptr->nxtdlta == nxtdlta)        return(hptr->dst);
  1364.     }
  1365.     i++;
  1366.   }
  1367. }
  1368.  
  1369.  
  1370. /* 
  1371.  *
  1372.  */
  1373. void IFF_Buffer_Action(anim_hdr)
  1374. XA_ANIM_HDR *anim_hdr;
  1375. {
  1376.   xaLONG image_size;
  1377.   xaUBYTE *buff0,*buff1,*tmp,*dbl_buff;
  1378.   XA_ACTION *act,*old_act0,*old_act1;
  1379.   XA_FRAME *frame_lst;
  1380.   xaULONG frame_i,frame_num;
  1381.   xaULONG scale_x,scale_y,need_to_scale;
  1382.  
  1383.   iff_chdr = 0;
  1384.   image_size = iff_imagex * iff_imagey;
  1385.   dbl_buff = buff1 = buff0 = (xaUBYTE *) malloc( 2 * image_size );
  1386.   if (buff0 == 0) TheEnd1("IFF Buffer Action: malloc failed 0");
  1387.   buff1 += image_size;
  1388.   frame_num = anim_hdr->last_frame + 1;
  1389.  
  1390.   IFF_Hash_Init(frame_num);
  1391.   need_to_scale = 
  1392.     UTIL_Get_Buffer_Scale(iff_imagex,iff_imagey,&scale_x,&scale_y);
  1393.  
  1394.   frame_i = 0;  old_act0 = old_act1 = 0;
  1395.   frame_lst = anim_hdr->frame_lst; 
  1396.   while(frame_lst[frame_i].act != 0)
  1397.   {
  1398.     XA_ACTION *dst_act,*new_act,*nxt_act;
  1399.  
  1400.  
  1401.     act = frame_lst[frame_i].act;
  1402.     nxt_act = frame_lst[frame_i + 1].act;
  1403.  
  1404.       switch(act->type)
  1405.       {
  1406.     case ACT_DELTA:
  1407.         { XA_DEC_INFO dec_info;
  1408.       ACT_DLTA_HDR *dlta_hdr = (ACT_DLTA_HDR *)act->data;
  1409.           xaLONG minx,miny,maxx,maxy; 
  1410.           xaLONG pic_x,pic_y;
  1411.           xaUBYTE *t_pic;
  1412.       xaULONG dlta_flag = 1;
  1413.       dec_info.imagex    = iff_imagex;
  1414.       dec_info.imagey    = iff_imagey;
  1415.       dec_info.imaged    = iff_imaged;
  1416.       dec_info.chdr      = 0;
  1417.       dec_info.map_flag  = xaFALSE;
  1418.       dec_info.map       = 0;
  1419.       dec_info.special   = dlta_hdr->special;
  1420.       dec_info.extra     = dlta_hdr->extra;
  1421.       dec_info.skip_flag = 0;
  1422.  
  1423.       dlta_flag = dlta_hdr->delta(buff0, dlta_hdr->data, 
  1424.                         dlta_hdr->fsize, &dec_info);
  1425.       minx = dec_info.xs;    miny = dec_info.ys;
  1426.       maxx = dec_info.xe;    maxy = dec_info.ye;
  1427.  
  1428.           if (dlta_flag & ACT_DLTA_BODY)
  1429.       {
  1430.         memcpy((char *)buff1, (char *)buff0, image_size);
  1431.         maxx = dlta_hdr->xsize; maxy = dlta_hdr->ysize;
  1432.             IFF_Init_DLTA_HDR(maxx,maxy);
  1433.       }
  1434.  
  1435.  
  1436.           IFF_Update_DLTA_HDR(&minx,&miny,&maxx,&maxy);
  1437.       dst_act = IFF_Hash_Get(act,old_act0,nxt_act); 
  1438.     /* IF unbuffered action has been previously setup and IF it's
  1439.      * smaller than old one, use the old one. IF it's larger than
  1440.      * the old one, then free up the old one and replace with this one.
  1441.      * Same goes for deltas that don't change an images(the NOPs).
  1442.      */
  1443.       if ( (dst_act) || (dlta_flag & ACT_DLTA_NOP) )
  1444.       {
  1445.         XA_ACTION *tst_act;
  1446.         if (!dst_act) /* if here because no change */
  1447.         {
  1448.           if (old_act0 == 0) TheEnd1("IFF Buff: No Body err");
  1449.           IFF_Hash_Add(act,nxt_act,old_act0,&old_act0,dlta_flag);
  1450.           tst_act = old_act0;
  1451.         } else tst_act = dst_act;
  1452.  
  1453.             if ( (tst_act->type==ACT_MAPPED) || (tst_act->type==ACT_DISP) )
  1454.         { 
  1455.           ACT_MAPPED_HDR *maphdr = (ACT_MAPPED_HDR *)tst_act->data;
  1456.           xaULONG px,py,sx,sy;
  1457.           xaULONG opx,opy,osx,osy;
  1458.           px = minx;  sx = maxx - minx; py = miny;  sy = maxy - miny;
  1459.           if (need_to_scale) UTIL_Scale_Pos_Size(&px,&py,&sx,&sy,
  1460.                     iff_imagex,iff_imagey,scale_x,scale_y);
  1461.           sx += px;    opx = maphdr->xpos;    osx = maphdr->xsize + opx;
  1462.           sy += py;    opy = maphdr->ypos;    osy = maphdr->ysize + opy;
  1463.           if (   ((px >= opx) && (px <= osx))  /* new is <= old */
  1464.               && ((sx >= opx) && (sx <= osx))
  1465.               && ((py >= opy) && (py <= osy))
  1466.               && ((sy >= opy) && (sy <= osy)) )
  1467.           {
  1468.         frame_lst[frame_i].act = tst_act;
  1469.         old_act0 = old_act1; old_act1 = tst_act;
  1470.         tmp = buff0; buff0 = buff1; buff1 = tmp;
  1471.         break;
  1472.           }
  1473.         } /* NOTE: this might should be an error */
  1474.         ACT_Free_Act(tst_act);
  1475.         new_act = tst_act;   /* free_act should wipe chdr info */ 
  1476.       }
  1477.       else 
  1478.       {
  1479.           /* get new action for unbuffered frame */
  1480.         new_act = ACT_Get_Action(anim_hdr,0);
  1481.         ACT_Add_CHDR_To_Action(new_act,act->chdr);
  1482.       }
  1483.  
  1484.           pic_x = maxx - minx; pic_y = maxy - miny;
  1485.       /* now get into shape */
  1486.           if (iff_anim_flags & ANIM_HAM)
  1487.       { 
  1488.         xaULONG disp_flag;
  1489.  
  1490.         if (x11_display_type == XA_MONOCHROME)
  1491.         {minx=miny=0; pic_x=iff_imagex; pic_y=iff_imagey; }
  1492.  
  1493.             t_pic = (xaUBYTE *) malloc( XA_PIC_SIZE(pic_x * pic_y) );
  1494.         if (x11_display_type & XA_X11_TRUE) disp_flag = xaTRUE;
  1495.         else disp_flag = xaFALSE;
  1496.         if (iff_anim_flags & ANIM_HAM6)
  1497.         {
  1498.           if (cmap_true_map_flag == xaTRUE)
  1499.           {
  1500.             XA_CHDR *tmp_chdr = 0;
  1501.         ACT_Del_CHDR_From_Action(new_act,new_act->chdr);
  1502.         IFF_HAM6_As_True (t_pic,buff0,&tmp_chdr,act->h_cmap,
  1503.             pic_x,pic_y,minx,miny,iff_imagex);
  1504.         ACT_Add_CHDR_To_Action(new_act,tmp_chdr);
  1505.            }
  1506.           else
  1507.          IFF_Buffer_HAM6(t_pic,buff0,new_act->chdr,act->h_cmap,
  1508.             pic_x,pic_y,minx,miny,iff_imagex,xaFALSE);
  1509.         }
  1510.         else
  1511.         {
  1512.           if (cmap_true_map_flag == xaTRUE)
  1513.           {
  1514.             XA_CHDR *tmp_chdr = 0;
  1515.         ACT_Del_CHDR_From_Action(new_act,new_act->chdr);
  1516.         IFF_HAM8_As_True (t_pic,buff0,&tmp_chdr,act->h_cmap,
  1517.             pic_x,pic_y,minx,miny,iff_imagex);
  1518.         ACT_Add_CHDR_To_Action(new_act,tmp_chdr);
  1519.            }
  1520.           else
  1521.         IFF_Buffer_HAM8(t_pic,buff0,new_act->chdr,act->h_cmap,
  1522.             pic_x,pic_y,minx,miny,iff_imagex,xaFALSE);
  1523.         }
  1524.         ACT_Setup_Mapped(new_act, t_pic, new_act->chdr, 
  1525.         minx, miny, pic_x, pic_y, iff_imagex, iff_imagey,
  1526.         xaFALSE, 0, xaTRUE, xaFALSE, disp_flag);
  1527.       }
  1528.       else ACT_Setup_Mapped(new_act, buff0, new_act->chdr, 
  1529.         minx, miny, pic_x, pic_y, iff_imagex, iff_imagey,
  1530.         xaFALSE,0, xaFALSE, xaTRUE, xaFALSE);
  1531.           if (dlta_flag & ACT_DLTA_BODY) old_act0 = old_act1 = new_act;
  1532.       IFF_Hash_Add(act,nxt_act,old_act0,&new_act,dlta_flag);
  1533.       old_act0 = old_act1; old_act1 = new_act; 
  1534.       frame_lst[frame_i].act = new_act;
  1535.           tmp = buff0; buff0 = buff1; buff1 = tmp;
  1536.         } /* end of delta7,5,j */
  1537.         break;
  1538.       } /* end of switch */
  1539.     frame_i++; /* move to next action in list */
  1540.   } /* end of while */
  1541.   if (dbl_buff) { FREE(dbl_buff,0x100A); dbl_buff = buff0 = buff1 = 0;}
  1542.   IFF_Hash_CleanUp();
  1543.   iff_chdr = 0;
  1544. }
  1545.  
  1546. xaULONG
  1547. IFF_Delta_J(image,delta,dsize,dec_info)
  1548. xaUBYTE *image;         /* Image Buffer. */
  1549. xaUBYTE *delta;         /* delta data. */
  1550. xaULONG dsize;          /* delta size */
  1551. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  1552. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  1553.   xaULONG imaged = dec_info->imaged;
  1554.   register xaLONG rowsize,width;
  1555.   register xaUBYTE *i_ptr;
  1556.   register xaLONG exitflag;
  1557.   register xaULONG  type,r_flag,b_cnt,g_cnt,r_cnt; 
  1558.   register xaULONG b,g,r;
  1559.   register xaULONG offset,dmask,depth;
  1560.   register xaUBYTE data;
  1561.   xaLONG changed,xor_flag;
  1562.   xaLONG tmp,minx,miny,maxx,maxy;
  1563.   xaLONG kludge_j;
  1564.  /* this kludge is because animations with width less than 320 are considered
  1565.   * centered in the middle of a 320 screen. Does this happen with
  1566.   * animations greater than lores overscan(374) and less than hi-res(640)????
  1567.   */
  1568.  
  1569.  if (imagex >= 320) kludge_j = 0;
  1570.  else kludge_j = (320-imagex)/2;
  1571.  
  1572.  maxx = maxy = 0; minx = imagex; miny = imagey;
  1573.  
  1574.  changed = xor_flag = 0;
  1575.  width = imagex;
  1576.  rowsize = width / 8;
  1577.  exitflag = 0;
  1578.  while(!exitflag)
  1579.  {
  1580.   /* read compression type and reversible_flag(xor data not just set) 
  1581.    */
  1582.   type   = (*delta++) << 8; type   |= (*delta++);
  1583.  
  1584.   if (type != 0 )
  1585.   {
  1586.     r_flag = (*delta++) << 8; r_flag |= (*delta++);
  1587.   }
  1588.   else r_flag = 0; /* Might possibly have to read it anyways */
  1589.   /* switch on compression type */
  1590.   switch(type)
  1591.   {
  1592.    case 0: exitflag = 1; break; /* end of list */
  1593.    case 1:
  1594.       /* Get byte count and group count 
  1595.        */
  1596.       xor_flag |= r_flag;
  1597.       b_cnt = (*delta++) << 8; b_cnt |= (*delta++);
  1598.       g_cnt = (*delta++) << 8; g_cnt |= (*delta++);
  1599.       
  1600.       /* Loop thru groups
  1601.        */
  1602.       for(g=0; g<g_cnt; g++)
  1603.       {
  1604.     xaULONG odd_flag;
  1605.         offset = (*delta++) << 8; offset |= (*delta++);
  1606.  
  1607.         offset <<= 3; /* counts bytes */
  1608.         if (kludge_j) 
  1609.              offset = ((offset/320) * imagex) + (offset%320) - kludge_j;
  1610.  
  1611.         i_ptr = (xaUBYTE *)(image + offset);
  1612.  
  1613.         tmp = offset%imagex; if (tmp<minx) minx=tmp;
  1614.         tmp += 8;            if (tmp>maxx) maxx=tmp;
  1615.         tmp = offset/imagex; if (tmp<miny) miny=tmp;
  1616.         tmp += b_cnt;        if (tmp>maxy) maxy=tmp;
  1617.        
  1618.         odd_flag = (b_cnt * imaged) & 0x01;
  1619.         /* Loop thru byte count 
  1620.          */
  1621.         for(b=0; b < b_cnt; b++)
  1622.         {
  1623.           dmask = 1;
  1624.           for(depth=0;depth<imaged;depth++) /* loop thru planes */
  1625.           {
  1626.             data = *delta++;
  1627.             changed |= data;          /* CHECKFORZERO change */
  1628.             IFF_Byte_Mod(i_ptr,data,dmask,r_flag);
  1629.             dmask <<= 1;
  1630.           } /* end of depth loop */
  1631.           i_ptr += width; /* direction is vertical */
  1632.         } /* end of byte loop */
  1633.         if (odd_flag) delta++; /* pad to short */
  1634.       } /* end of group loop */
  1635.       break;
  1636.    case 2:
  1637.       /* Read row count, byte count and group count 
  1638.        */
  1639.       xor_flag |= r_flag;
  1640.       r_cnt = (*delta++) << 8; r_cnt |= (*delta++);
  1641.       b_cnt = (*delta++) << 8; b_cnt |= (*delta++);
  1642.       g_cnt = (*delta++) << 8; g_cnt |= (*delta++);
  1643.       
  1644.       /* Loop thru groups
  1645.        */
  1646.       for(g=0; g < g_cnt; g++)
  1647.       { xaULONG odd_flag;
  1648.         offset = (*delta++) << 8; offset |= (*delta++);
  1649.         offset <<= 3; /* counts bytes */
  1650.         if (kludge_j) 
  1651.              offset = ((offset/320) * imagex) + (offset%320) - kludge_j;
  1652.  
  1653.         tmp = offset%imagex;     if (tmp<minx) minx=tmp;
  1654.         tmp += b_cnt * 8;        if (tmp>maxx) maxx=tmp;
  1655.         tmp = offset/imagex;     if (tmp<miny) miny=tmp;
  1656.         tmp += r_cnt;            if (tmp>maxy) maxy=tmp;
  1657.        
  1658.         odd_flag = (r_cnt * b_cnt * imaged) & 0x01;
  1659.         /* Loop thru rows of group
  1660.          */
  1661.         for(r=0; r < r_cnt; r++)
  1662.         {
  1663.           dmask = 1;
  1664.           for(depth=0;depth<imaged;depth++) /* loop thru planes */
  1665.           {
  1666.             i_ptr = (xaUBYTE *)(image + offset + (r * width));
  1667.             for(b=0; b < b_cnt; b++) /* loop thru byte count */
  1668.             {
  1669.               data = *delta++;
  1670.               changed |= data;        /* CHECKFORZERO */
  1671.            
  1672.               IFF_Byte_Mod(i_ptr,data,dmask,r_flag);
  1673.               i_ptr += 8;        /* data is horizontal */
  1674.             } /* end of byte loop */
  1675.             dmask <<= 1;
  1676.           } /* end of depth loop */
  1677.         } /* end of row loop */
  1678.         if (odd_flag) delta++; /* pad to short */
  1679.       } /* end of group loop */
  1680.       break;
  1681.    default: /* don't know this one yet */
  1682.             fprintf(stderr,"Unknown J-type %x\n",type);
  1683.             type = 0;      /* force an exit */
  1684.             exitflag = 1;
  1685.             break;
  1686.   } /* end of type switch */
  1687.  } /* end of while loop */
  1688.  
  1689.  /* if changed is zero then this Delta didn't change the image at all */ 
  1690.  /* BUT we can't return a NOP because we still need the double buffers to
  1691.   * be swapped
  1692.   */
  1693.  if (changed==0)
  1694.  {
  1695.    dec_info->xs = dec_info->ys = 0;
  1696.    dec_info->xe = 8; dec_info->ye = 1;
  1697.    DEBUG_LEVEL2 fprintf(stderr,"DELTA J nothing changed\n");
  1698.    if (xor_flag) return(ACT_DLTA_XOR);
  1699.    return(ACT_DLTA_NORM);
  1700.  }
  1701.  if (xa_optimize_flag == xaTRUE)
  1702.  {
  1703.    dec_info->xs = minx; dec_info->ys = miny;
  1704.    dec_info->xe = maxx; dec_info->ye = maxy;
  1705.  
  1706.    if (dec_info->xs >= imagex) dec_info->xs = 0;
  1707.    if (dec_info->ys >= imagey) dec_info->ys = 0;
  1708.    if (dec_info->xe <= 0)      dec_info->xe = imagex;
  1709.    if (dec_info->ye <= 0)      dec_info->ye = imagey;
  1710.    DEBUG_LEVEL2 fprintf(stderr,"xypos=<%d,%d> xysize=<%d %d>\n",
  1711.         dec_info->xs,dec_info->ys,dec_info->xe,dec_info->ye );
  1712.  }
  1713.  else
  1714.  {
  1715.    dec_info->xs = 0; dec_info->ys = 0;
  1716.    dec_info->xe = imagex; dec_info->ye = imagey;
  1717.  }
  1718.  if (xor_flag) return(ACT_DLTA_XOR);
  1719.  return(ACT_DLTA_NORM);
  1720. } /* end of IFF_DeltaJ routine */
  1721.  
  1722. /* 
  1723.  *  Decode IFF type l anims
  1724.  */
  1725. xaULONG
  1726. IFF_Delta_l(image,delta,dsize,dec_info)
  1727. xaUBYTE *image;         /* Image Buffer. */
  1728. xaUBYTE *delta;         /* delta data. */
  1729. xaULONG dsize;          /* delta size */
  1730. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  1731. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  1732.   xaULONG imaged = dec_info->imaged;
  1733.   xaULONG vertflag = (xaULONG)(dec_info->extra);
  1734.  register xaLONG i,depth,dmask,width;
  1735.  xaULONG poff0,poff1;
  1736.  register xaUBYTE *i_ptr;
  1737.  register xaUBYTE *optr,*dptr;
  1738.  register xaSHORT cnt;
  1739.  register xaUSHORT offset,data;
  1740.  
  1741.  dec_info->xs = dec_info->ys = 0; dec_info->xe = imagex; dec_info->ye = imagey;
  1742.  i_ptr = image;
  1743.  if (vertflag) width = imagex;
  1744.  else width = 16;
  1745.  dmask = 1;
  1746.  for(depth = 0; depth<imaged; depth++)
  1747.  {
  1748.    i_ptr = image;
  1749.    /*poff = planeoff[depth];*/ /* offset into delt chunk */
  1750.    poff0  = (xaULONG)(delta[ 4 * depth    ]) << 24;
  1751.    poff0 |= (xaULONG)(delta[ 4 * depth + 1]) << 16;
  1752.    poff0 |= (xaULONG)(delta[ 4 * depth + 2]) <<  8;
  1753.    poff0 |= (xaULONG)(delta[ 4 * depth + 3]);
  1754.  
  1755.    if (poff0)
  1756.    {
  1757.      poff1  = (xaULONG)(delta[ 4 * (depth+8)    ]) << 24;
  1758.      poff1 |= (xaULONG)(delta[ 4 * (depth+8) + 1]) << 16;
  1759.      poff1 |= (xaULONG)(delta[ 4 * (depth+8) + 2]) <<  8;
  1760.      poff1 |= (xaULONG)(delta[ 4 * (depth+8) + 3]);
  1761.  
  1762.      dptr = (xaUBYTE *)(delta + 2 * poff0); 
  1763.      optr = (xaUBYTE *)(delta + 2 * poff1); 
  1764.  
  1765.      /* while short *optr != -1 */
  1766.      while( (optr[0] != 0xff) || (optr[1] != 0xff) )
  1767.      {
  1768.        offset = (*optr++) << 8; offset |= (*optr++);
  1769.        cnt    = (*optr++) << 8; cnt    |= (*optr++);
  1770.  
  1771.        if (cnt < 0)  /* cnt negative */
  1772.        {
  1773.          i_ptr = image + 16 * (xaULONG)(offset);
  1774.          cnt = -cnt;
  1775.          data = (*dptr++) << 8; data |= (*dptr++);
  1776.          for(i=0; i < (xaULONG)cnt; i++)
  1777.          {
  1778.            IFF_Short_Mod(i_ptr,data,dmask,0);
  1779.            i_ptr += width;
  1780.          }
  1781.        }  /* end of neg */
  1782.        else/* cnt pos then */
  1783.        {
  1784.          i_ptr = image + 16 * (xaULONG)(offset);
  1785.          for(i=0; i < (xaULONG)cnt; i++)
  1786.          {
  1787.            data = (*dptr++) << 8; data |= (*dptr++);
  1788.            IFF_Short_Mod(i_ptr,data,dmask,0);
  1789.            i_ptr += width;
  1790.          }
  1791.        } /* end of pos */
  1792.      } /* end of delta for this plane */
  1793.    } /* plane has changed data */
  1794.    dmask <<= 1;
  1795.  } /* end of d */
  1796.  return(ACT_DLTA_NORM);
  1797. }
  1798.  
  1799. void
  1800. IFF_Setup_HMAP(act,hmap,cmap,bits)
  1801. XA_ACTION *act;
  1802. ColorReg *hmap,*cmap;
  1803. xaULONG bits;
  1804. {
  1805.   ColorReg *hptr;
  1806.   xaULONG i,size,shift;
  1807.  
  1808.   if (bits == 8) {size = XA_HMAP8_SIZE; shift = 2;}
  1809.   else {size = XA_HMAP6_SIZE; shift = 4;}
  1810.   
  1811.   act->data = (xaUBYTE *) malloc(size * sizeof(ColorReg) );
  1812.   if (act->data == 0) IFF_TheEnd1("IFF_Setup_HMAP: malloc failed\n");
  1813.   hptr = (ColorReg *) act->data;
  1814.   for(i=0; i < size; i++) 
  1815.   {
  1816.     hptr[i].red   = hmap[i].red   = cmap[i].red   >> shift;
  1817.     hptr[i].green = hmap[i].green = cmap[i].green >> shift;
  1818.     hptr[i].blue  = hmap[i].blue  = cmap[i].blue  >> shift;
  1819.   }
  1820. }
  1821.  
  1822.  
  1823. IFF_DLTA_HDR iff_dlta[2];
  1824.  
  1825. void
  1826. IFF_Init_DLTA_HDR(max_x,max_y)
  1827. xaULONG max_x,max_y;
  1828. {
  1829.   iff_dlta[0].minx = iff_dlta[1].minx = 0;
  1830.   iff_dlta[0].miny = iff_dlta[1].miny = 0;
  1831.   iff_dlta[0].maxx = iff_dlta[1].maxx = max_x;
  1832.   iff_dlta[0].maxy = iff_dlta[1].maxy = max_y;
  1833. }
  1834.  
  1835. void
  1836. IFF_Update_DLTA_HDR(min_x,min_y,max_x,max_y)
  1837. xaLONG *min_x,*min_y,*max_x,*max_y;
  1838. {
  1839.   register xaLONG tmin_x,tmin_y,tmax_x,tmax_y;
  1840.  
  1841.  /* This mess keeps track of the largest rectangle needed to
  1842.   * display all changes. Since things are double buffered, the
  1843.   * min/maxes of the corners of the current and previous two
  1844.   * images are taken. If the animation is in single step mode
  1845.   * it's best to display the entire image.
  1846.   */
  1847.   /* Special condition if max_x is 0, then return previous largest values*/
  1848.  
  1849.   if (max_x)
  1850.   {
  1851.     tmin_x = *min_x;
  1852.     tmin_y = *min_y;
  1853.     tmax_x = *max_x;
  1854.     tmax_y = *max_y;
  1855.     iff_dlta[0].minx = xaMIN(iff_dlta[0].minx, tmin_x);
  1856.     iff_dlta[0].miny = xaMIN(iff_dlta[0].miny, tmin_y);
  1857.     iff_dlta[0].maxx = xaMAX(iff_dlta[0].maxx, tmax_x);
  1858.     iff_dlta[0].maxy = xaMAX(iff_dlta[0].maxy, tmax_y);
  1859.     *min_x = xaMIN(iff_dlta[1].minx, iff_dlta[0].minx);
  1860.     *min_y = xaMIN(iff_dlta[1].miny, iff_dlta[0].miny);
  1861.     *max_x = xaMAX(iff_dlta[1].maxx, iff_dlta[0].maxx);
  1862.     *max_y = xaMAX(iff_dlta[1].maxy, iff_dlta[0].maxy);
  1863.     /* Throw out oldest rectangle and store current.  */
  1864.     iff_dlta[1].minx = iff_dlta[0].minx;
  1865.     iff_dlta[1].miny = iff_dlta[0].miny;
  1866.     iff_dlta[1].maxx = iff_dlta[0].maxx;
  1867.     iff_dlta[1].maxy = iff_dlta[0].maxy;
  1868.     iff_dlta[0].minx = tmin_x;
  1869.     iff_dlta[0].miny = tmin_y;
  1870.     iff_dlta[0].maxx = tmax_x;
  1871.     iff_dlta[0].maxy = tmax_y;
  1872.   }
  1873.   else
  1874.   {
  1875.     *min_x = xaMIN(iff_dlta[1].minx, iff_dlta[0].minx);
  1876.     *min_y = xaMIN(iff_dlta[1].miny, iff_dlta[0].miny);
  1877.     *max_x = xaMAX(iff_dlta[1].maxx, iff_dlta[0].maxx);
  1878.     *max_y = xaMAX(iff_dlta[1].maxy, iff_dlta[0].maxy);
  1879.   }
  1880. }
  1881.  
  1882. void
  1883. IFF_Read_BMHD(xin,bmhd)
  1884. XA_INPUT *xin;
  1885. Bit_Map_Header *bmhd;
  1886. {
  1887.   /* read Bit_Map_Header into bmhd */
  1888.   /* read so as to avoid endian problems */
  1889.   bmhd->width              = xin->Read_MSB_U16(xin);
  1890.   bmhd->height             = xin->Read_MSB_U16(xin);
  1891.   bmhd->x                  = xin->Read_MSB_U16(xin);
  1892.   bmhd->y                  = xin->Read_MSB_U16(xin);
  1893.   bmhd->depth              = xin->Read_U8(xin);
  1894.   bmhd->masking            = xin->Read_U8(xin);
  1895.   bmhd->compression        = xin->Read_U8(xin);
  1896.   bmhd->pad1               = xin->Read_U8(xin);
  1897.   bmhd->transparentColor   = xin->Read_MSB_U16(xin);
  1898.   bmhd->xAspect            = xin->Read_U8(xin);
  1899.   bmhd->yAspect            = xin->Read_U8(xin);
  1900.   bmhd->pageWidth          = xin->Read_MSB_U16(xin);
  1901.   bmhd->pageHeight         = xin->Read_MSB_U16(xin);
  1902. } 
  1903.  
  1904. void
  1905. IFF_Read_ANHD(xin,anhd,chunk_size)
  1906. XA_INPUT *xin;
  1907. Anim_Header *anhd;
  1908. xaULONG chunk_size;
  1909. {
  1910.   xaULONG i;
  1911.   anhd->op        = xin->Read_U8(xin);
  1912.   anhd->mask        = xin->Read_U8(xin);
  1913.   anhd->w        = xin->Read_MSB_U16(xin);
  1914.   anhd->h        = xin->Read_MSB_U16(xin);
  1915.   anhd->x        = xin->Read_MSB_U16(xin);
  1916.   anhd->y        = xin->Read_MSB_U16(xin);
  1917.   anhd->abstime        = xin->Read_MSB_U32(xin);
  1918.   anhd->reltime        = xin->Read_MSB_U32(xin);
  1919.   anhd->interleave    = xin->Read_U8(xin);
  1920.   anhd->pad0        = xin->Read_U8(xin);
  1921.   anhd->bits        = xin->Read_MSB_U32(xin);
  1922.   xin->Read_Block(xin,(xaBYTE *)(anhd->pad),16); /* read pad */
  1923.   i = Anim_Header_SIZE;
  1924.   while(i < chunk_size) {xin->Read_U8(xin); i++;}
  1925. }
  1926.  
  1927. void
  1928. IFF_Read_ANSQ(xin,chunk_size)
  1929. XA_INPUT *xin;
  1930. xaULONG chunk_size;
  1931. { xaULONG i;
  1932.   xaUBYTE *p;  /* data is actually big endian xaUSHORT */
  1933.   xaBYTE *garb;
  1934.  
  1935.   iff_ansq_cnt = chunk_size / 4;
  1936.   iff_ansq_cnt++; /* adding dlta 0 up front */
  1937.   DEBUG_LEVEL2 fprintf(stderr,"    ansq_cnt=%d dlta_cnt=%d\n",
  1938.                         iff_ansq_cnt,iff_dlta_cnt);
  1939.   /* allocate space for ansq variables
  1940.   */
  1941.   iff_ansq = (IFF_ANSQ *)malloc( iff_ansq_cnt * sizeof(IFF_ANSQ));
  1942.   if (iff_ansq == NULL) IFF_TheEnd1("IFF_Read_ANSQ: malloc err");
  1943.   if (xa_verbose) fprintf(stderr,"     frames=%d dlts=%d comp=%d\n",
  1944.             iff_ansq_cnt,iff_dlta_cnt,iff_dlta_compression);
  1945.   garb = (xaBYTE *)malloc(chunk_size);
  1946.   if (garb==0)
  1947.   {
  1948.     fprintf(stderr,"ansq malloc not enough\n");
  1949.     IFF_TheEnd();
  1950.   }
  1951.   xin->Read_Block(xin,garb,chunk_size);
  1952.   p = (xaUBYTE *)(garb);
  1953.   /* first delta is only used once and doesn't appear in
  1954.   * the ANSQ
  1955.   */
  1956.   iff_ansq[0].dnum  = 0;
  1957.   iff_ansq[0].time  = 1;
  1958.   for(i=1; i<iff_ansq_cnt; i++)
  1959.   {
  1960.     /* this is delta to apply */
  1961.     iff_ansq[i].dnum  = (xaULONG)(*p++)<<8;
  1962.     iff_ansq[i].dnum |= (xaULONG)(*p++);
  1963.     /* this is jiffy count or if 0xffff then a goto */
  1964.     iff_ansq[i].time  = (xaULONG)(*p++)<<8;
  1965.     iff_ansq[i].time |= (xaULONG)(*p++);
  1966.     iff_ansq[i].frame = 0;
  1967.     DEBUG_LEVEL2
  1968.     fprintf(stderr,"<%d %d> ",iff_ansq[i].dnum, iff_ansq[i].time);
  1969.   }
  1970.   FREE(garb,0x100C); garb=0;
  1971. }
  1972.  
  1973. /*
  1974.  * Function to register any CRNGs that occur before CMAP in IFF file
  1975.  */
  1976. void
  1977. IFF_Register_CRNGs(anim_hdr,chdr)
  1978. XA_ANIM_HDR *anim_hdr;
  1979. XA_CHDR *chdr;
  1980. {
  1981.   XA_ACTION *act;
  1982.  
  1983.   act = (XA_ACTION *)anim_hdr->acts;
  1984.  
  1985.   while(act)
  1986.   {
  1987.     if ( (act->type == ACT_CYCLE) && (act->chdr == 0) )
  1988.              ACT_Add_CHDR_To_Action(act,chdr);
  1989.     act = act->next;
  1990.   }
  1991. }
  1992.  
  1993.  
  1994. void
  1995. IFF_Read_CRNG(anim_hdr,xin,chunk_size,crng_flag)
  1996. XA_ANIM_HDR *anim_hdr;
  1997. XA_INPUT *xin;
  1998. xaULONG chunk_size;
  1999. xaULONG *crng_flag;
  2000. {
  2001. /* CRNG_HDR
  2002.  * word pad1,rate,active;
  2003.  * byte low,high;
  2004.  */
  2005.  
  2006.   /* is the chunk the correct size ?
  2007.   */
  2008.   if (chunk_size == IFF_CRNG_HDR_SIZE)
  2009.   {
  2010.     XA_ACTION *act;
  2011.     xaULONG rate,active,low,high,csize;
  2012.     ACT_CYCLE_HDR *act_cycle;
  2013.  
  2014.     /* read CRNG chunk */
  2015.     rate   = xin->Read_MSB_U16(xin);  /* throw away pad1 */
  2016.     rate   = xin->Read_MSB_U16(xin);
  2017.     active = xin->Read_MSB_U16(xin);
  2018.     low    = xin->Read_U8(xin);
  2019.     high   = xin->Read_U8(xin);
  2020.     /* make it an action only if its valid
  2021.     */
  2022.     if (   (active & IFF_CRNG_ACTIVE) && (low < high) 
  2023.     && (rate > IFF_CRNG_DPII_KLUDGE) && (iff_allow_cycling == xaTRUE) )
  2024.     {
  2025.       xaULONG i,*i_ptr;
  2026.  
  2027.       csize = high - low + 1;
  2028.       act_cycle = (ACT_CYCLE_HDR *)
  2029.     malloc( sizeof(ACT_CYCLE_HDR) + (csize * sizeof(xaULONG)) );
  2030.       if (act_cycle == 0) IFF_TheEnd1("IFF_Read_CRNG: malloc failed");
  2031.  
  2032.       act_cycle->size = csize;
  2033.       act_cycle->curpos = 0;
  2034.       act_cycle->rate  = (xaULONG)(IFF_CRNG_INTERVAL/rate);
  2035.       act_cycle->flags = ACT_CYCLE_ACTIVE;
  2036.       if (active & IFF_CRNG_REVERSE) act_cycle->flags |= ACT_CYCLE_REVERSE;
  2037.  
  2038.       i_ptr = (xaULONG *)act_cycle->data;
  2039.       for(i=0; i<csize; i++) 
  2040.       {
  2041.         i_ptr[i] = low + i + iff_or_mask;
  2042.       }
  2043.  
  2044.       *crng_flag = *crng_flag + 1;
  2045.       act = ACT_Get_Action(anim_hdr,ACT_CYCLE);
  2046.       IFF_Add_Frame(0,act);
  2047.       act->data = (xaUBYTE *) act_cycle;
  2048.     /* register it now if iff_chdr valid, else wait to later */
  2049.       if (iff_chdr) ACT_Add_CHDR_To_Action(act,iff_chdr);
  2050.     }
  2051.     else DEBUG_LEVEL2 fprintf(stderr,"IFF_CRNG not used\n");
  2052.   }
  2053.   else
  2054.   { xin->Seek_FPos(xin,chunk_size,1);
  2055.     fprintf(stderr,"IFF_CRNG chunksize mismatch %d\n",chunk_size);
  2056.   }
  2057. }
  2058.  
  2059.  
  2060. void
  2061. IFF_Read_CMAP_0(cmap,size,xin)
  2062. ColorReg *cmap;
  2063. xaULONG size;
  2064. XA_INPUT *xin;
  2065. {
  2066.   xaULONG i;
  2067.   for(i=0; i < size; i++)
  2068.   {
  2069.     cmap[i].red   = xin->Read_U8(xin);
  2070.     cmap[i].green = xin->Read_U8(xin);
  2071.     cmap[i].blue  = xin->Read_U8(xin);
  2072.   }
  2073. }
  2074.  
  2075. void
  2076. IFF_Read_CMAP_1(cmap,size,xin)
  2077. ColorReg *cmap;
  2078. xaULONG size;
  2079. XA_INPUT *xin;
  2080. {
  2081.   xaULONG i;
  2082.   for(i=0; i < size; i++)
  2083.   {
  2084.     xaULONG d;
  2085.     d = xin->Read_U8(xin);
  2086.     cmap[i].red   = (d & 0x0f) << 4;
  2087.     d = xin->Read_U8(xin);
  2088.     cmap[i].green = (d & 0xf0);
  2089.     cmap[i].blue  = (d & 0x0f) << 4;
  2090.   }
  2091. }
  2092.  
  2093.  
  2094. void IFF_Buffer_HAM6(out,in,chdr,h_cmap,xosize,yosize,xip,yip,xisize,d_flag)
  2095. xaUBYTE *out;        /* output image (size of section) */
  2096. xaUBYTE *in;        /* input image */
  2097. XA_CHDR *chdr;        /* color header to map to */
  2098. ColorReg *h_cmap;    /* ham color map */
  2099. xaULONG xosize,yosize;    /* size of section in input buffer */
  2100. xaULONG xip,yip;        /* pos of section in input buffer */
  2101. xaULONG xisize;        /* x size of input buffer */
  2102. xaULONG d_flag;        /* map_flag */
  2103. {
  2104.   XA_CHDR *the_chdr;
  2105.   xaULONG new_cmap_flag,*the_map,psize;
  2106.   register xaULONG y,xend,the_moff,coff;
  2107.   xaUSHORT g_adj[16];
  2108.  
  2109.   if (x11_display_type & XA_X11_TRUE) 
  2110.     for(y=0;y<16;y++) g_adj[y] = xa_gamma_adj[ (17 * y) ];
  2111.  
  2112.   the_map = chdr->map;
  2113.   coff = chdr->coff;
  2114.   if (chdr->new_chdr == 0) { the_chdr = chdr; new_cmap_flag = 0; }
  2115.   else { the_chdr = chdr->new_chdr; new_cmap_flag = 1; }
  2116.   the_moff = the_chdr->moff;
  2117.   if (x11_display_type & XA_X11_TRUE) d_flag = xaTRUE;
  2118.   if (d_flag==xaTRUE) psize = x11_bytes_pixel;
  2119.   else psize = 1;
  2120.  
  2121.   DEBUG_LEVEL1 fprintf(stderr,"ham_cmap: = %x\n",(xaULONG)h_cmap);
  2122.  
  2123.   if (xa_ham_map == 0)
  2124.   {
  2125.      xa_ham_map_size = XA_HAM6_CACHE_SIZE;
  2126.      xa_ham_map = (xaULONG *)malloc( xa_ham_map_size * sizeof(xaULONG) );
  2127.      if (xa_ham_map == 0) IFF_TheEnd1("IFF_Buffer_HAM6: h_map malloc err");
  2128.   }
  2129.   if ((the_chdr != xa_ham_chdr) || (xa_ham_init != 6))
  2130.   {
  2131.     register xaULONG i;
  2132.     DEBUG_LEVEL1 fprintf(stderr,"xa_ham_map: old = %x new = %x\n",
  2133.                     (xaULONG)xa_ham_chdr,(xaULONG)the_chdr);
  2134.     for(i=0; i<XA_HAM6_CACHE_SIZE; i++) xa_ham_map[i] = XA_HAM_MAP_INVALID;
  2135.     xa_ham_chdr = the_chdr; xa_ham_init = 6;
  2136.   }
  2137.  
  2138.   xend = xip + xosize; if (xend > xisize) xend = xisize;
  2139.   for (y=yip; y < (yip + yosize); y++)
  2140.   {
  2141.     register xaULONG x;
  2142.     register xaUBYTE *i_ptr = (xaUBYTE *)( in + y * xisize );
  2143.     register xaUBYTE *o_ptr = (xaUBYTE *)( out + (y-yip)*xosize * psize );
  2144.     register xaULONG pred,pgrn,pblu,data;
  2145.     pred = pgrn = pblu = 0;
  2146.     for (x=0; x<xend; x++)
  2147.     {
  2148.       data = (xaUSHORT )(*i_ptr++);
  2149.       switch(data & 0x30)
  2150.       {
  2151.         case 0x00: /* use color register given by low */
  2152.           { register xaUSHORT low = data & 0x0f;
  2153.             pred = h_cmap[low].red;
  2154.             pgrn = h_cmap[low].green;
  2155.             pblu = h_cmap[low].blue;
  2156.           } break;
  2157.         case 0x10: pblu = data & 0x0f; break; /* change blue */
  2158.         case 0x20: pred = data & 0x0f; break; /* change red */
  2159.         case 0x30: pgrn = data & 0x0f; break; /* change green */
  2160.       }
  2161.       if ( (x >= xip) && (x < xend) )
  2162.       {
  2163.         register xaULONG t_color;
  2164.         register xaUSHORT indx = (pred << 8) | (pgrn << 4) | pblu;
  2165.  
  2166.         if ( (t_color = xa_ham_map[indx]) == XA_HAM_MAP_INVALID) 
  2167.         {
  2168.           if (x11_display_type & XA_X11_TRUE) t_color = 
  2169.         X11_Get_True_Color( g_adj[pred],g_adj[pgrn],g_adj[pblu],16);
  2170.       else /* don't gamma because chdr already adjusted */
  2171.       {
  2172.             if (cmap_true_to_332 == xaTRUE)
  2173.          t_color = CMAP_GET_332(pred,pgrn,pblu,CMAP_SCALE4);
  2174.         else t_color = CMAP_GET_GRAY(pred,pgrn,pblu,CMAP_SCALE9);
  2175.             if (new_cmap_flag) t_color = the_map[t_color - coff] + the_moff;
  2176.       }
  2177.           xa_ham_map[indx] = t_color;
  2178.     }
  2179.  
  2180.     if (d_flag)
  2181.     {
  2182.           if (x11_bytes_pixel == 4)
  2183.              { xaULONG *ulp = (xaULONG *)o_ptr; *ulp = t_color; o_ptr += 4; }
  2184.           else if (x11_bytes_pixel == 2) { xaUSHORT *usp = (xaUSHORT *)o_ptr;
  2185.              *usp = (xaUSHORT)(t_color); o_ptr += 2; }
  2186.           else *o_ptr++ = (xaUBYTE)t_color;
  2187.     } else *o_ptr++ = (xaUBYTE)t_color;
  2188.       } /* end of output */
  2189.     } /* end of x */
  2190.   } /* end of y */
  2191. }
  2192.  
  2193.  
  2194. void IFF_Buffer_HAM8(out,in,chdr,h_cmap,xosize,yosize,xip,yip,xisize,d_flag)
  2195. xaUBYTE *out;        /* output image (size of section) */
  2196. xaUBYTE *in;        /* input image */
  2197. XA_CHDR *chdr;        /* color header to map to */
  2198. ColorReg *h_cmap;    /* ham color map */
  2199. xaULONG xosize,yosize;    /* size of section in input buffer */
  2200. xaULONG xip,yip;        /* pos of section in input buffer */
  2201. xaULONG xisize;        /* x size of input buffer */
  2202. xaULONG d_flag;        /* map_flag */
  2203. {
  2204.   XA_CHDR *the_chdr;
  2205.   xaULONG new_cmap_flag,*the_map,psize;
  2206.   register xaULONG y,xend,the_moff,coff;
  2207.   xaUSHORT g_adj[64];
  2208.  
  2209.   if (x11_display_type & XA_X11_TRUE) 
  2210.     for(y=0;y<64;y++) g_adj[y] = xa_gamma_adj[ ((65 * y) >> 4) ];
  2211.   the_map = chdr->map;
  2212.   coff = chdr->coff;
  2213.   if (chdr->new_chdr == 0) { the_chdr = chdr; new_cmap_flag = 0; }
  2214.   else { the_chdr = chdr->new_chdr; new_cmap_flag = 1; }
  2215.   the_moff = chdr->moff;
  2216.   if (x11_display_type & XA_X11_TRUE) d_flag = xaTRUE;
  2217.   if (d_flag==xaTRUE) psize = x11_bytes_pixel;
  2218.   else psize = 1;
  2219.  
  2220.   if (xa_ham_map_size != XA_HAM8_CACHE_SIZE)
  2221.   {
  2222.     if (xa_ham_map == 0)
  2223.     {
  2224.          xa_ham_map_size = XA_HAM8_CACHE_SIZE;
  2225.          xa_ham_map = (xaULONG *)malloc( xa_ham_map_size * sizeof(xaULONG) );
  2226.          if (xa_ham_map == 0) IFF_TheEnd1("IFF_Buffer_HAM8: h_map malloc err");
  2227.     }
  2228.     else
  2229.     {
  2230.       xaULONG *tmp;
  2231.       xa_ham_map_size = XA_HAM8_CACHE_SIZE;
  2232.       tmp = (xaULONG *) realloc(xa_ham_map,xa_ham_map_size * sizeof(xaULONG));
  2233.       if (tmp == 0) IFF_TheEnd1("IFF_Buffer_HAM8: h_map malloc err");
  2234.       xa_ham_map = tmp;
  2235.     }
  2236.     xa_ham_chdr = 0;
  2237.   }
  2238.   if ( (the_chdr != xa_ham_chdr) || (xa_ham_init != 8))
  2239.   {
  2240.     register xaULONG i;
  2241.     DEBUG_LEVEL1 fprintf(stderr,"xa_ham8_map: old = %x new = %x\n",
  2242.                     (xaULONG)xa_ham_chdr,(xaULONG)the_chdr);
  2243.     for(i=0; i<XA_HAM8_CACHE_SIZE; i++) xa_ham_map[i] = XA_HAM_MAP_INVALID;
  2244.     xa_ham_chdr = the_chdr; xa_ham_init = 8;
  2245.   }
  2246.  
  2247.   xend = xip + xosize; if (xend > xisize) xend = xisize;
  2248.   for (y=yip; y < (yip + yosize); y++)
  2249.   {
  2250.     register xaULONG x;
  2251.     register xaUBYTE *i_ptr = (xaUBYTE *)( in + y * xisize );
  2252.     register xaUBYTE *o_ptr = (xaUBYTE *)( out + (y-yip) *xosize * psize);
  2253.     register xaULONG pred,pgrn,pblu,data;
  2254.  
  2255.     pred = pgrn = pblu = 0;
  2256.     for (x=0; x<xend; x++)
  2257.     {
  2258.       data = (xaULONG )(*i_ptr++);
  2259.       switch(data & 0xc0)
  2260.       {
  2261.         case 0x00: /* use color register given by low */
  2262.           { register xaULONG low = data & 0x3f;
  2263.             pred  = h_cmap[low].red;
  2264.             pgrn  = h_cmap[low].green;
  2265.             pblu  = h_cmap[low].blue;
  2266.           } break;
  2267.         case 0x40: pblu = data & 0x3f; break; /* change blue */
  2268.         case 0x80: pred = data & 0x3f; break; /* change red */
  2269.         case 0xc0: pgrn = data & 0x3f; break; /* change green */
  2270.       }
  2271.       if ( (x >= xip) && (x < xend) )
  2272.       {
  2273.         register xaULONG t_color;
  2274.         register xaULONG indx = (pred << 12) | (pgrn << 6) | pblu;
  2275.  
  2276.         if ( (t_color = xa_ham_map[indx]) == XA_HAM_MAP_INVALID) 
  2277.         {
  2278.           if (x11_display_type & XA_X11_TRUE) t_color = 
  2279.         X11_Get_True_Color( g_adj[pred],g_adj[pgrn],g_adj[pblu],16);
  2280.       else /* no gamma here because it's already in cmap */
  2281.       {
  2282.             if (cmap_true_to_332 == xaTRUE)
  2283.          t_color = CMAP_GET_332(pred,pgrn,pblu,CMAP_SCALE6);
  2284.         else t_color = CMAP_GET_GRAY(pred,pgrn,pblu,CMAP_SCALE11);
  2285.             if (new_cmap_flag) t_color = the_map[t_color - coff] + the_moff;
  2286.       }
  2287.           xa_ham_map[indx] = t_color;
  2288.     }
  2289.     if (d_flag)
  2290.     {
  2291.           if (x11_bytes_pixel == 4)
  2292.              { xaULONG *ulp = (xaULONG *)o_ptr; *ulp = t_color; o_ptr += 4; }
  2293.           else if (x11_bytes_pixel == 2) { xaUSHORT *usp = (xaUSHORT *)o_ptr;
  2294.                          *usp = (xaUSHORT)(t_color); o_ptr += 2; }
  2295.           else *o_ptr++ = (xaUBYTE)t_color;
  2296.     } else *o_ptr++ = (xaUBYTE)t_color;
  2297.       } /* end of output */
  2298.     } /* end of x */
  2299.   } /* end of y */
  2300. }
  2301.  
  2302. void
  2303. IFF_Shift_CMAP(cmap,csize)
  2304. ColorReg *cmap;
  2305. xaULONG csize;
  2306. { xaULONG i;
  2307.   for(i=0;i<csize;i++)
  2308.   { cmap[i].red   >>= 4;
  2309.     cmap[i].green >>= 4;
  2310.     cmap[i].blue  >>= 4;
  2311.   }
  2312. }
  2313.  
  2314.  /* Extra Info. 0 = short encoding, 1 = long encoding*/
  2315. xaULONG
  2316. IFF_Delta_7(image,delta,dsize,dec_info)
  2317. xaUBYTE *image;         /* Image Buffer. */
  2318. xaUBYTE *delta;         /* delta data. */
  2319. xaULONG dsize;          /* delta size */
  2320. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  2321. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  2322.   xaULONG imaged = dec_info->imaged;
  2323.   void *extra = dec_info->extra;
  2324.  register xaLONG col,depth,dmask;
  2325.  register xaLONG rowsize,width;
  2326.  xaULONG poff,doff,col_shift;
  2327.  register xaUBYTE *i_ptr;
  2328.  register xaUBYTE *optr,opcnt,op,cnt;
  2329.  xaUBYTE *d_ptr;
  2330.  xaLONG miny,minx,maxy,maxx;
  2331.  xaULONG iextra = (xaULONG)(extra);
  2332.  
  2333.  /* set to opposites for min/max testing */
  2334.  dec_info->xs = imagex;
  2335.  dec_info->ys = imagey;
  2336.  dec_info->xe = 0;
  2337.  dec_info->ye = 0;
  2338.  
  2339.  i_ptr = image;
  2340.  width = imagex;
  2341.  col_shift = (iextra)?4:5;
  2342.  rowsize = width >> col_shift;
  2343.  dmask = 1;
  2344.  for(depth=0; depth<imaged; depth++)
  2345.  {
  2346.   minx = -1;
  2347.   maxx = -1;
  2348.   
  2349.   i_ptr = image;
  2350.   /* offset into delt chunk */
  2351.   { register xaULONG ddepth = depth << 2;
  2352.     poff  = (xaULONG)(delta[ ddepth++ ]) << 24;
  2353.     poff |= (xaULONG)(delta[ ddepth++ ]) << 16;
  2354.     poff |= (xaULONG)(delta[ ddepth++ ]) <<  8;
  2355.     poff |= (xaULONG)(delta[ ddepth   ]);
  2356.     ddepth +=29; /* move to data */
  2357.     doff  = (xaULONG)(delta[ ddepth++ ]) << 24;
  2358.     doff |= (xaULONG)(delta[ ddepth++ ]) << 16;
  2359.     doff |= (xaULONG)(delta[ ddepth++ ]) <<  8;
  2360.     doff |= (xaULONG)(delta[ ddepth   ]);
  2361.   }
  2362.   if (poff)
  2363.   {
  2364.    optr   = (xaUBYTE  *)(delta + poff);
  2365.    d_ptr =  (xaUBYTE *)(delta + doff);
  2366.    
  2367.    for(col=0;col<rowsize;col++)
  2368.    {
  2369.     /* start at top of column */
  2370.     i_ptr = (xaUBYTE *)(image + (col << col_shift));
  2371.     opcnt = *optr++;  /* get number of ops for this column */
  2372.     
  2373.     miny = -1;
  2374.     maxy = -1;
  2375.  
  2376.     while(opcnt)    /* execute ops */
  2377.     {
  2378.       /* keep track of min and max columns */
  2379.       if (minx == -1) minx = col;
  2380.       maxx = col;
  2381.  
  2382.       op = *optr++;   /* get op */
  2383.      
  2384.       if (iextra) /* xaSHORT Data */
  2385.       {
  2386.         if (op & 0x80)    /* if type uniqe */
  2387.         {
  2388.           if (miny == -1) miny = (xaULONG)(i_ptr - image ) / width;
  2389.           cnt = op & 0x7f;         /* get cnt */
  2390.       
  2391.           while(cnt--) /* loop through data */
  2392.           {
  2393.              register xaULONG data;
  2394.          data = (*d_ptr++) << 8; data |= *d_ptr++;
  2395.              IFF_Short_Mod(i_ptr,data,dmask,0);
  2396.              i_ptr += width;
  2397.           }
  2398.         } /* end unique */
  2399.         else
  2400.         {
  2401.           if (op == 0)   /* type same */
  2402.           {
  2403.              register xaUSHORT data;
  2404.              if (miny == -1) miny=(xaULONG)(i_ptr - image) / width;
  2405.              cnt = *optr++;
  2406.          data = (*d_ptr++) << 8; data |= *d_ptr++;
  2407.  
  2408.              while(cnt--) /* loop through data */
  2409.              { 
  2410.                 IFF_Short_Mod(i_ptr,data,dmask,0);
  2411.                 i_ptr += width;
  2412.              }
  2413.            } /* end same */
  2414.            else
  2415.            {
  2416.               i_ptr += (width * op);  /* type skip */
  2417.            }
  2418.          } /* end of hi bit clear */
  2419.       } /* end of short data */
  2420.       else /* xaLONG Data */
  2421.       {
  2422.         if (op & 0x80)    /* if type uniqe */
  2423.         {
  2424.           if (miny == -1) miny=(xaULONG)( i_ptr - image ) / width;
  2425.           cnt = op & 0x7f;         /* get cnt */
  2426.       
  2427.           while(cnt--) /* loop through data */
  2428.           { register xaULONG data;
  2429.         data = (*d_ptr++)<<24; data |= (*d_ptr++)<<16;
  2430.         data |= (*d_ptr++)<<8; data |= *d_ptr++;
  2431.             IFF_Long_Mod(i_ptr,data,dmask,0); i_ptr += width;
  2432.           }
  2433.         } /* end unique */
  2434.         else
  2435.         {
  2436.            if (op == 0) /* type same */
  2437.            { register xaULONG data;
  2438.              if (miny == -1) miny=(xaULONG)( i_ptr - image ) / width;
  2439.              cnt = *optr++;
  2440.          data = (*d_ptr++)<<24; data |= (*d_ptr++)<<16;
  2441.          data |= (*d_ptr++)<<8; data |= *d_ptr++;
  2442.  
  2443.              while(cnt--) {IFF_Long_Mod(i_ptr,data,dmask,0); i_ptr += width;}
  2444.            } /* end same */
  2445.            else { i_ptr += (width * op);  /* type skip */ }
  2446.          } /* end of hi bit clear */
  2447.        } /* end of long data */
  2448.        opcnt--;
  2449.      } /* end of while opcnt */
  2450.      maxy = (xaULONG)( i_ptr - image ) / width;
  2451.      if ( (miny>=0) && (miny < dec_info->ys)) dec_info->ys = miny;
  2452.      if ( (maxy>=0) && (maxy > dec_info->ye)) dec_info->ye = maxy;
  2453.     } /* end of column loop */
  2454.    } /* end of valid pointer for this plane */
  2455.    dmask <<= 1;
  2456.    minx <<= col_shift; maxx <<= col_shift;
  2457.    maxx = (iextra)?(maxx+15):(maxx+31);
  2458.    if ( (minx>=0) && (minx < dec_info->xs)) dec_info->xs = minx;
  2459.    if ( (maxx>=0) && (maxx > dec_info->xe)) dec_info->xe = maxx;
  2460.   } /* end of for depth */
  2461.  
  2462.   if (xa_optimize_flag == xaTRUE)
  2463.   {
  2464.     if (dec_info->xs >= imagex) dec_info->xs = 0;
  2465.     if (dec_info->ys >= imagey) dec_info->ys = 0;
  2466.     if (dec_info->xe <= 0)      dec_info->xe = imagex;
  2467.     if (dec_info->ye <= 0)      dec_info->ye = imagey;
  2468.   }
  2469.   else
  2470.   {
  2471.     dec_info->xs = 0;      dec_info->ys = 0;
  2472.     dec_info->xe = imagex; dec_info->ye = imagey;
  2473.   }
  2474.   return(ACT_DLTA_NORM);
  2475. } /* end of routine */
  2476.  
  2477.  
  2478.  
  2479. /* Extra Info. 0 = short encoding, 1 = long encoding*/
  2480. xaULONG
  2481. IFF_Delta_8(image,delta,dsize,dec_info)
  2482. xaUBYTE *image;         /* Image Buffer. */
  2483. xaUBYTE *delta;         /* delta data. */
  2484. xaULONG dsize;          /* delta size */
  2485. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  2486. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  2487.   xaULONG imaged = dec_info->imaged;
  2488.   void *extra = dec_info->extra;
  2489.   register xaLONG col,depth,dmask;
  2490.   register xaLONG rowsize,width;
  2491.   xaULONG poff,col_shift;
  2492.   register xaUBYTE *i_ptr;
  2493.   register xaUBYTE *optr;
  2494.   register xaULONG opcnt,op,cnt;
  2495.   xaLONG miny,minx,maxy,maxx;
  2496.   xaULONG iextra = (xaULONG)(extra);
  2497.  
  2498.  /* set to opposites for min/max testing */
  2499.   dec_info->xs = imagex;
  2500.   dec_info->ys = imagey;
  2501.   dec_info->xe = 0;
  2502.   dec_info->ye = 0;
  2503.  
  2504.  i_ptr = image;
  2505.  width = imagex;
  2506.  col_shift = (iextra)?4:5;
  2507.  rowsize = width >> col_shift;
  2508.  dmask = 1;
  2509.  for(depth=0; depth<imaged; depth++)
  2510.  {
  2511.   minx = -1;
  2512.   maxx = -1;
  2513.   
  2514.   i_ptr = image;
  2515.   /* offset into delt chunk */
  2516.   { register xaULONG ddepth = depth << 2;
  2517.     poff  = (xaULONG)(delta[ ddepth++ ]) << 24;
  2518.     poff |= (xaULONG)(delta[ ddepth++ ]) << 16;
  2519.     poff |= (xaULONG)(delta[ ddepth++ ]) <<  8;
  2520.     poff |= (xaULONG)(delta[ ddepth   ]);
  2521.   }
  2522.   if (poff)
  2523.   {
  2524.    optr   = (xaUBYTE  *)(delta + poff);
  2525.    
  2526.    for(col=0;col<rowsize;col++)
  2527.    {
  2528.      /* start at top of column */
  2529.      i_ptr = (xaUBYTE *)(image + (col << col_shift));
  2530.      if (iextra) /* xaSHORT Data */
  2531.      {
  2532.        opcnt  = (xaULONG)(*optr++) << 8;  /* get number of ops for this column */
  2533.        opcnt |= (xaULONG)(*optr++);
  2534.     
  2535.        miny = -1;
  2536.        maxy = -1;
  2537.  
  2538.        while(opcnt)    /* execute ops */
  2539.        {
  2540.      /* keep track of min and max columns */
  2541.      if (minx == -1) minx = col;
  2542.      maxx = col;
  2543.  
  2544.      op  = (xaULONG)(*optr++) << 8;   /* get op */
  2545.      op |= (xaULONG)(*optr++);
  2546.      
  2547.      if (op & 0x8000)    /* if type uniqe */
  2548.      {
  2549.        if (miny == -1) miny = (xaULONG)(i_ptr - image ) / width;
  2550.        cnt = op & 0x7fff;         /* get cnt */
  2551.       
  2552.        while(cnt--) /* loop through data */
  2553.        {
  2554.              register xaULONG data;
  2555.          data = (*optr++) << 8; data |= *optr++;
  2556.              IFF_Short_Mod(i_ptr,data,dmask,0);
  2557.              i_ptr += width;
  2558.        }
  2559.      } /* end unique */
  2560.      else
  2561.      {
  2562.        if (op == 0)   /* type same */
  2563.        {
  2564.              register xaUSHORT data;
  2565.              if (miny == -1) miny=(xaULONG)(i_ptr - image) / width;
  2566.          cnt  = (xaULONG)(*optr++) << 8;
  2567.          cnt |= (xaULONG)(*optr++);
  2568.          data = (*optr++) << 8; data |= *optr++;
  2569.  
  2570.              while(cnt--) /* loop through data */
  2571.          { 
  2572.            IFF_Short_Mod(i_ptr,data,dmask,0);
  2573.            i_ptr += width;
  2574.              }
  2575.            } /* end same */
  2576.            else
  2577.            {
  2578.          i_ptr += (width * op);  /* type skip */
  2579.            }
  2580.          } /* end of hi bit clear */
  2581.      opcnt--;
  2582.        } /* end of while opcnt */
  2583.      } /* end of short data */
  2584.      else /* xaLONG Data */
  2585.      {
  2586.        opcnt  = (xaULONG)(*optr++) << 24; /* get number of ops for this column */
  2587.        opcnt |= (xaULONG)(*optr++) << 16;
  2588.        opcnt |= (xaULONG)(*optr++) <<  8;
  2589.        opcnt |= (xaULONG)(*optr++);
  2590.     
  2591.        miny = -1;
  2592.        maxy = -1;
  2593.  
  2594.        while(opcnt)    /* execute ops */
  2595.        {
  2596.      /* keep track of min and max columns */
  2597.      if (minx == -1) minx = col;
  2598.      maxx = col;
  2599.  
  2600.      op  = (xaULONG)(*optr++) << 24;   /* get op */
  2601.      op |= (xaULONG)(*optr++) << 16;
  2602.      op |= (xaULONG)(*optr++) <<  8;
  2603.      op |= (xaULONG)(*optr++);
  2604.  
  2605.      if (op & 0x80000000)    /* if type uniqe */
  2606.      {
  2607.        if (miny == -1) miny=(xaULONG)( i_ptr - image ) / width;
  2608.        cnt = op & 0x7fffffff;         /* get cnt */
  2609.       
  2610.        while(cnt--) /* loop through data */
  2611.        { register xaULONG data;
  2612.          data = (*optr++)<<24; data |= (*optr++)<<16;
  2613.          data |= (*optr++)<<8; data |= *optr++;
  2614.          IFF_Long_Mod(i_ptr,data,dmask,0); i_ptr += width;
  2615.        }
  2616.      } /* end unique */
  2617.      else
  2618.      {
  2619.            if (op == 0) /* type same */
  2620.        { register xaULONG data;
  2621.              if (miny == -1) miny=(xaULONG)( i_ptr - image ) / width;
  2622.          cnt  = (xaULONG)(*optr++) << 24;
  2623.          cnt |= (xaULONG)(*optr++) << 16;
  2624.          cnt |= (xaULONG)(*optr++) <<  8;
  2625.          cnt |= (xaULONG)(*optr++);
  2626.          data = (*optr++)<<24; data |= (*optr++)<<16;
  2627.          data |= (*optr++)<<8; data |= *optr++;
  2628.  
  2629.              while(cnt--) {IFF_Long_Mod(i_ptr,data,dmask,0); i_ptr += width;}
  2630.            } /* end same */
  2631.            else { i_ptr += (width * op);  /* type skip */ }
  2632.          } /* end of hi bit clear */
  2633.      opcnt--;
  2634.        } /* end of while opcnt */
  2635.      } /* end of long data */
  2636.      maxy = (xaULONG)( i_ptr - image ) / width;
  2637.      if ( (miny>=0) && (miny < dec_info->ys)) dec_info->ys = miny;
  2638.      if ( (maxy>=0) && (maxy > dec_info->ye)) dec_info->ye = maxy;
  2639.     } /* end of column loop */
  2640.    } /* end of valid pointer for this plane */
  2641.    dmask <<= 1;
  2642.    minx <<= col_shift; maxx <<= col_shift;
  2643.    maxx = (iextra)?(maxx+15):(maxx+31);
  2644.    if ( (minx>=0) && (minx < dec_info->xs)) dec_info->xs = minx;
  2645.    if ( (maxx>=0) && (maxx > dec_info->xe)) dec_info->xe = maxx;
  2646.   } /* end of for depth */
  2647.  
  2648.   if (xa_optimize_flag == xaTRUE)
  2649.   {
  2650.     if (dec_info->xs >= imagex) dec_info->xs = 0;
  2651.     if (dec_info->ys >= imagey) dec_info->ys = 0;
  2652.     if (dec_info->xe <= 0)      dec_info->xe = imagex;
  2653.     if (dec_info->ye <= 0)      dec_info->ye = imagey;
  2654.   }
  2655.   else
  2656.   {
  2657.     dec_info->xs = 0;      dec_info->ys = 0;
  2658.     dec_info->xe = imagex; dec_info->ye = imagey;
  2659.   }
  2660.   return(ACT_DLTA_NORM);
  2661. } /* end of routine */
  2662.  
  2663.  
  2664. /* POD NOTE: no need to support xorflag yet */
  2665. void IFF_Long_Mod(ptr,data,dmask,xorflag) 
  2666. xaUBYTE *ptr;
  2667. xaULONG data,dmask,xorflag;
  2668. { register xaUBYTE *_iptr = ptr; 
  2669.   register xaUBYTE dmaskoff = ~dmask;
  2670.   if (xorflag) TheEnd1("IFF comp7: xorflag not supported yet. Contact Author");
  2671.   if (0x80000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2672.   if (0x40000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2673.   if (0x20000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2674.   if (0x10000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2675.   if (0x08000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2676.   if (0x04000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2677.   if (0x02000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2678.   if (0x01000000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2679.   if (0x00800000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2680.   if (0x00400000 & data)  *_iptr++  |= dmask; else  *_iptr++  &= dmaskoff;
  2681.   if (0x00200000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2682.   if (0x00100000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2683.   if (0x00080000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2684.   if (0x00040000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2685.   if (0x00020000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2686.   if (0x00010000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2687.   if (0x00008000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2688.   if (0x00004000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2689.   if (0x00002000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2690.   if (0x00001000 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2691.   if (0x00000800 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2692.   if (0x00000400 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2693.   if (0x00000200 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2694.   if (0x00000100 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2695.   if (0x00000080 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2696.   if (0x00000040 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2697.   if (0x00000020 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2698.   if (0x00000010 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2699.   if (0x00000008 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2700.   if (0x00000004 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2701.   if (0x00000002 & data) *_iptr++   |= dmask; else *_iptr++   &= dmaskoff;
  2702.   if (0x00000001 & data) *_iptr     |= dmask; else *_iptr     &= dmaskoff;
  2703. }
  2704.  
  2705.  
  2706.  
  2707.  
  2708. void IFF_HAM6_As_True(out,in,chdr,h_cmap,xosize,yosize,xip,yip,xisize)
  2709. xaUBYTE *out,*in;
  2710. XA_CHDR **chdr;
  2711. ColorReg *h_cmap;
  2712. xaULONG xosize,yosize,xip,yip,xisize;
  2713. {
  2714.   xaULONG xend,y;
  2715.   xaUBYTE *tpic,*optr;
  2716.   xaUSHORT g_adj[16];
  2717.  
  2718.   for(y=0;y<16;y++) g_adj[y] = xa_gamma_adj[ (17 * y) ] >> 8;
  2719.   tpic = (xaUBYTE *)malloc( 3 * xosize * yosize);
  2720.   if (tpic == 0) TheEnd1("IFF_HAM6_As_True: malloc err\n");
  2721.   optr = tpic;
  2722.   xend = xip + xosize; if (xend > xisize) xend = xisize;
  2723.   for (y=yip; y < (yip + yosize); y++)
  2724.   {
  2725.     register xaULONG x;
  2726.     register xaUBYTE *i_ptr = (xaUBYTE *)( in + y * xisize );
  2727.     register xaULONG pred,pgrn,pblu,data;
  2728.  
  2729.     pred = pgrn = pblu = 0;
  2730.     for (x=0; x<xend; x++)
  2731.     {
  2732.       data = (xaULONG )(*i_ptr++);
  2733.       switch( (data & 0x30) )
  2734.       {
  2735.         case 0x00: /* use color register given by low */
  2736.           { register xaULONG low;
  2737.             low = data & 0x0f;
  2738.             pred  = g_adj[ h_cmap[low].red   ];
  2739.             pgrn  = g_adj[ h_cmap[low].green ];
  2740.             pblu  = g_adj[ h_cmap[low].blue  ];
  2741.           } break;
  2742.         case 0x10: pblu = g_adj[ (data & 0x0f) ]; break;
  2743.         case 0x20: pred = g_adj[ (data & 0x0f) ]; break;
  2744.         case 0x30: pgrn = g_adj[ (data & 0x0f) ]; break;
  2745.       } 
  2746.       if ( (x >= xip) && (x < xend) )
  2747.       {
  2748.     *optr++ = pred;
  2749.     *optr++ = pgrn;
  2750.     *optr++ = pblu;
  2751.       }
  2752.     } /* end of x */
  2753.   } /* end of y */
  2754.   if (    (cmap_true_to_all == xaTRUE) 
  2755.       || ((cmap_true_to_1st == xaTRUE) && (iff_chdr == 0)) )    
  2756.     iff_chdr = CMAP_Create_CHDR_From_True(tpic,8,8,8,xosize,yosize,
  2757.                     iff_cmap,&iff_imagec);
  2758.   else if ( (cmap_true_to_332 == xaTRUE) && (iff_chdr == 0) )
  2759.     iff_chdr = CMAP_Create_332(iff_cmap,&iff_imagec);
  2760.   else if ( (cmap_true_to_gray == xaTRUE) && (iff_chdr == 0) )
  2761.     iff_chdr = CMAP_Create_Gray(iff_cmap,&iff_imagec);
  2762.  
  2763.   if (cmap_dither_type == CMAP_DITHER_FLOYD)
  2764.         out = UTIL_RGB_To_FS_Map(out,tpic,iff_chdr,xosize,yosize,xaTRUE);
  2765.   else
  2766.         out = UTIL_RGB_To_Map(out,tpic,iff_chdr,xosize,yosize,xaTRUE);
  2767.   *chdr = iff_chdr; 
  2768. }
  2769.  
  2770. void IFF_HAM8_As_True(out,in,chdr,h_cmap,xosize,yosize,xip,yip,xisize)
  2771. xaUBYTE *out,*in;
  2772. XA_CHDR **chdr;
  2773. ColorReg *h_cmap;
  2774. xaULONG xosize,yosize,xip,yip,xisize;
  2775. {
  2776.   xaULONG xend,y;
  2777.   xaUBYTE *tpic,*optr;
  2778.   xaUSHORT g_adj[64];
  2779.  
  2780.   for(y=0;y<64;y++) g_adj[y] = xa_gamma_adj[ ((65 * y) >> 4) ] >> 8;
  2781.   tpic = (xaUBYTE *)malloc( 3 * xosize * yosize);
  2782.   if (tpic == 0) TheEnd1("IFF_HAM8_As_True: malloc err\n");
  2783.   optr = tpic;
  2784.   xend = xip + xosize; if (xend > xisize) xend = xisize;
  2785.   for (y=yip; y < (yip + yosize); y++)
  2786.   {
  2787.     register xaULONG x;
  2788.     register xaUBYTE *i_ptr = (xaUBYTE *)( in + y * xisize );
  2789.     register xaULONG pred,pgrn,pblu,data;
  2790.  
  2791.     pred = pgrn = pblu = 0;
  2792.     for (x=0; x<xend; x++)
  2793.     {
  2794.       data = (xaULONG )(*i_ptr++);
  2795.       switch( (data & 0xc0) )
  2796.       {
  2797.         case 0x00: /* use color register given by low */
  2798.           { register xaULONG low = data & 0x3f;
  2799.             pred  = g_adj[ h_cmap[low].red   ];
  2800.             pgrn  = g_adj[ h_cmap[low].green ];
  2801.             pblu  = g_adj[ h_cmap[low].blue  ];
  2802.           } break;
  2803.         case 0x40: pblu = g_adj[ (data & 0x3f) ]; break;
  2804.         case 0x80: pred = g_adj[ (data & 0x3f) ]; break;
  2805.         case 0xc0: pgrn = g_adj[ (data & 0x3f) ]; break;
  2806.       } 
  2807.       if ( (x >= xip) && (x < xend) )
  2808.       {
  2809.     *optr++ = pred;
  2810.     *optr++ = pgrn;
  2811.     *optr++ = pblu;
  2812.       }
  2813.     } /* end of x */
  2814.   } /* end of y */
  2815.   if (    (cmap_true_to_all == xaTRUE) 
  2816.       || ((cmap_true_to_1st == xaTRUE) && (iff_chdr == 0)) )    
  2817.     iff_chdr = CMAP_Create_CHDR_From_True(tpic,8,8,8,xosize,yosize,
  2818.                     iff_cmap,&iff_imagec);
  2819.   else if ( (cmap_true_to_332 == xaTRUE) && (iff_chdr == 0) )
  2820.     iff_chdr = CMAP_Create_332(iff_cmap,&iff_imagec);
  2821.   else if ( (cmap_true_to_gray == xaTRUE) && (iff_chdr == 0) )
  2822.     iff_chdr = CMAP_Create_Gray(iff_cmap,&iff_imagec);
  2823.  
  2824.   if (cmap_dither_type == CMAP_DITHER_FLOYD)
  2825.         out = UTIL_RGB_To_FS_Map(out,tpic,iff_chdr,xosize,yosize,xaTRUE);
  2826.   else
  2827.         out = UTIL_RGB_To_Map(out,tpic,iff_chdr,xosize,yosize,xaTRUE);
  2828.   *chdr = iff_chdr; 
  2829. }
  2830.  
  2831.  
  2832. xaULONG
  2833. IFF_Delta_Body(image,delta,dsize,dec_info)
  2834. xaUBYTE *image;         /* Image Buffer. */
  2835. xaUBYTE *delta;         /* delta data. */
  2836. xaULONG dsize;          /* delta size */
  2837. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  2838. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  2839.   xaULONG image_size = imagex * imagey;
  2840.   memcpy( (char *)image, (char *)delta, image_size);
  2841.   dec_info->xs = dec_info->ys = 0;  dec_info->xe = imagex; dec_info->ye = imagey; 
  2842.   return(ACT_DLTA_BODY);
  2843. }
  2844.  
  2845.