home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_set.c < prev    next >
C/C++ Source or Header  |  1997-01-26  |  33KB  |  1,170 lines
  1.  
  2. /*
  3.  * xa_set.c
  4.  *
  5.  * Copyright (C) 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_set.h"
  20. #include "xa_iff.h"
  21. #include <ctype.h>
  22.  
  23. xaULONG SET_Read_File();
  24. SET_FRAM_HDR *SET_Init_FRAM_HDRS();
  25. xaUBYTE *SET_Read_BACK();
  26. xaUBYTE *SET_Read_FACE();
  27. SET_SSET_HDR *SET_Alloc_SSET_HDR();
  28. SET_SSET_HDR *SET_Get_SSET();
  29. SET_BACK_HDR *SET_Alloc_BACK_HDR();
  30. SET_BACK_HDR *SET_Get_BACK();
  31. SET_BACK_HDR *SET_Add_Black();
  32. void SET_TheEnd();
  33. void SET_TheEnd1();
  34. void SET_Extract_Directory();
  35. void SET_Modify_Directory();
  36. void SET_Read_SSET();
  37. void SET_Add_SETTER();
  38. void SET_Add_BACK();
  39. void SET_Add_TIME();
  40. void SET_Read_Sound_IFF();
  41. void SET_Add_CHDR();
  42. void SET_Free_Stuff();
  43.  
  44. XA_ACTION *ACT_Get_Action();
  45. xaULONG UTIL_Get_Buffer_Scale();
  46. void UTIL_Scale_Buffer_Pos();
  47. void ACT_Setup_Mapped();
  48. void IFF_Read_BMHD();
  49. void IFF_Read_BODY();
  50. void IFF_Read_CMAP_0();
  51. void IFF_Read_CMAP_1();
  52. void IFF_Shift_CMAP();
  53. void IFF_Print_ID();
  54.  
  55. XA_CHDR *ACT_Get_CMAP();
  56. xaULONG CMAP_Get_Or_Mask();
  57. void ACT_Add_CHDR_To_Action();
  58. extern void XA_Setup_Input_Methods();
  59.  
  60. static ColorReg set_cmap[256];
  61. static XA_CHDR *set_chdr;
  62. static SET_BACK_HDR *set_back_start,*set_back_cur;
  63. static xaULONG set_back_num,set_sset_num;
  64. static SET_FRAM_HDR *set_frames;
  65. static xaULONG set_fram_num;
  66. static SET_SSET_HDR *set_sset_start,*set_sset_cur;
  67. static XA_ACTION *work_act;
  68. static XA_ACTION *back_act;
  69. static xaULONG set_time;
  70. static xaLONG set_xscroll_flag,set_xscroll_len,set_yscroll_flag,set_yscroll_len;
  71. static xaLONG set_back_xpos,set_back_ypos;
  72. static xaULONG set_back_scroll_fram;
  73. static xaLONG set_sset_cur_num,set_sset_xoff,set_sset_yoff;
  74. static xaULONG set_multi_flag;
  75. static xaULONG set_or_mask;
  76.  
  77. static char set_buff[512];
  78. static char set_buff1[64];
  79. static Bit_Map_Header bmhd;
  80.  
  81. static xaULONG set_imagex,set_imagey,set_imagec,set_imaged;
  82.  
  83.  
  84. void SET_Print_CHID(chid)
  85. xaULONG chid;
  86. {
  87.   xaULONG d;
  88.   d = (chid >> 24) & 0xff; fputc(d,stderr);
  89.   d = (chid >> 16) & 0xff; fputc(d,stderr);
  90.   d = (chid >>  8) & 0xff; fputc(d,stderr);
  91.   d = chid  & 0xff;        fputc(d,stderr);
  92.   fputc(' ',stderr);
  93. }
  94.  
  95. SET_BACK_HDR *SET_Get_BACK(back_num)
  96. xaULONG back_num;
  97. {
  98.   SET_BACK_HDR *tmp;
  99.  
  100.   tmp = set_back_start;
  101.   while(tmp)
  102.   {
  103.     if (tmp->num == back_num) return(tmp);
  104.     tmp = tmp->next;
  105.   }
  106.   fprintf(stderr,"SET_Get_BACK: invalid back_num %x\n",back_num);
  107.   SET_TheEnd();
  108.   return(0);
  109. }
  110.  
  111. SET_BACK_HDR *SET_Add_Black(anim_hdr)
  112. XA_ANIM_HDR *anim_hdr;
  113. {
  114.   xaUBYTE *pic;
  115.   SET_BACK_HDR *tmp;
  116.   XA_ACTION *act;
  117.   xaULONG psize;
  118.  
  119.     /* if black already exists */
  120.   if (set_back_start != 0)
  121.     if (set_back_start->num == 0xffff) return(set_back_start);
  122.  
  123.   psize = set_imagex * set_imagey;
  124.   if (work_act == 0)
  125.   {
  126.     xaUBYTE *t_pic;
  127.     t_pic = (xaUBYTE *)malloc( XA_PIC_SIZE(psize) );
  128.     if (t_pic == 0) SET_TheEnd1("SET a: malloc failed\n");
  129.     memset(t_pic, 0x00, psize );
  130.     act = ACT_Get_Action(anim_hdr,ACT_MAPPED);
  131.     ACT_Setup_Mapped(act,t_pic,set_chdr,0,0,set_imagex,set_imagey,
  132.     set_imagex,set_imagey,xaFALSE,0,xaTRUE,xaTRUE,xaFALSE);
  133.     work_act = act;
  134.   }
  135.  
  136.   tmp = (SET_BACK_HDR *)malloc( sizeof(SET_BACK_HDR) );
  137.   if (tmp == 0) SET_TheEnd1("SET: back malloc fail\n");
  138.  
  139.   tmp->num = 0xffff;
  140.   tmp->xsize = tmp->xscreen = set_imagex;
  141.   tmp->ysize = tmp->yscreen = set_imagey;
  142.   tmp->xpos = tmp->ypos = 0;
  143.   tmp->back_act = 0;
  144.   tmp->csize = 0;
  145.   tmp->chdr  = 0;
  146.   tmp->next = set_back_start;
  147.   set_back_start = tmp;
  148.  
  149.   pic = (xaUBYTE *)malloc( XA_PIC_SIZE(psize) );
  150.   if (pic == 0) SET_TheEnd1("SET_Add_Black: malloc failed\n");
  151.  
  152.   memset( pic, set_or_mask, psize );
  153.   act = ACT_Get_Action(anim_hdr,ACT_MAPPED);
  154.   tmp->back_act = act; 
  155.   ACT_Setup_Mapped(act,pic,set_chdr,0,0,set_imagex,set_imagey,
  156.     set_imagex,set_imagey,xaFALSE,0,xaTRUE,xaTRUE,xaFALSE);
  157.   return(set_back_start);
  158. }
  159.   
  160.  
  161. SET_BACK_HDR *SET_Alloc_BACK_HDR()
  162. {
  163.   SET_BACK_HDR *tmp;
  164.  
  165.   
  166.   tmp = (SET_BACK_HDR *)malloc( sizeof(SET_BACK_HDR) );
  167.   if (tmp == 0) SET_TheEnd1("SET: back malloc fail\n");
  168.  
  169.   tmp->num = set_back_num;
  170.   set_back_num++;
  171.   tmp->xsize = 0;   tmp->ysize = 0;
  172.   tmp->xscreen = 0; tmp->yscreen = 0;
  173.   tmp->xpos = 0;    tmp->ypos = 0;
  174.   tmp->back_act = 0;
  175.   tmp->csize = 0;
  176.   tmp->chdr = 0;
  177.   tmp->next = 0;
  178.  
  179.   if (set_back_start == 0) set_back_start = tmp;
  180.   else set_back_cur->next = tmp;
  181.   set_back_cur = tmp;
  182.   return(set_back_cur);
  183. }
  184.  
  185. SET_SSET_HDR *SET_Get_SSET(sset_num)
  186. xaULONG sset_num;
  187. {
  188.   SET_SSET_HDR *tmp;
  189.  
  190.   tmp = set_sset_start;
  191.   while(tmp)
  192.   {
  193.     if (tmp->num == sset_num) return(tmp);
  194.     tmp = tmp->next;
  195.   }
  196.   fprintf(stderr,"SET_Get_SSET: invalid sset_num %x\n",sset_num);
  197.   SET_TheEnd();
  198.   return(0);
  199. }
  200.  
  201. SET_SSET_HDR *SET_Alloc_SSET_HDR()
  202. {
  203.   SET_SSET_HDR *tmp;
  204.  
  205.   tmp = (SET_SSET_HDR *)malloc( sizeof(SET_SSET_HDR) );
  206.   if (tmp == 0) SET_TheEnd1("SET: set malloc fail\n");
  207.  
  208.   tmp->num = set_sset_num;
  209.   set_sset_num++;
  210.   tmp->faces = 0;
  211.   tmp->next = 0;
  212.   tmp->face_num = 0;
  213.  
  214.   if (set_sset_start == 0) set_sset_start = tmp;
  215.   else set_sset_cur->next = tmp;
  216.   set_sset_cur = tmp;
  217.   return(set_sset_cur);
  218. }
  219.  
  220.  
  221. xaULONG SET_Read_File(fname,anim_hdr)
  222. char *fname;
  223. XA_ANIM_HDR *anim_hdr;
  224. { XA_INPUT *xin = anim_hdr->xin;
  225.   xaULONG op; 
  226.   xaULONG cur_fram_num;
  227.   xaULONG cur_fram_cnt;
  228.   xaULONG exit_flag;
  229.  
  230.   set_multi_flag = xaTRUE;
  231.   cur_fram_num   = 0;
  232.   cur_fram_cnt   = 0;
  233.   work_act    = 0;
  234.   back_act    = 0;
  235.   set_fram_num   = 0;
  236.   set_frames     = (SET_FRAM_HDR *)0;
  237.   set_back_start = 0;
  238.   set_back_cur   = 0;
  239.   set_back_num   = 0;
  240.   set_sset_start = 0;
  241.   set_sset_cur   = 0;
  242.   set_sset_num   = 0;
  243.   set_xscroll_flag = 0;
  244.   set_xscroll_len = 0;
  245.   set_yscroll_flag = 0;
  246.   set_yscroll_len = 0;
  247.   set_back_xpos = 0;
  248.   set_back_ypos = 0;
  249.   set_back_scroll_fram = 1;
  250.   /* default stuff if no background */
  251.   set_imagex = 352;
  252.   set_imagey = 240;
  253.   set_imaged = 5;
  254.   bmhd.compression = BMHD_COMP_BYTERUN;
  255.   bmhd.masking = BMHD_MSK_NONE;
  256.  
  257.   set_or_mask = CMAP_Get_Or_Mask(1 << set_imaged);
  258.  
  259.   DEBUG_LEVEL1 fprintf(stderr,"Reading SET file %s:\n",fname);
  260.   exit_flag = 0;
  261.   while( !(xin->At_EOF(xin)) && !exit_flag)
  262.   {
  263.    XA_ACTION *act;
  264.  
  265.     op = xin->Read_U8(xin);
  266.  
  267.     switch(op)
  268.     {
  269.      case 'a':  /* 256 ascii 32 ascii IFF stuff  Background Image */
  270.     {
  271.       SET_BACK_HDR *tmp_back_hdr;
  272.       xaUBYTE *pic;
  273.       xin->Read_Block(xin,set_buff,256);    set_buff[256] = 0;
  274.       DEBUG_LEVEL1 fprintf(stderr," a) %s    ",set_buff);
  275.       xin->Read_Block(xin,set_buff1,32);    set_buff1[32] = 0;
  276.       DEBUG_LEVEL1 fprintf(stderr,"   %s\n",set_buff1);
  277.       tmp_back_hdr = SET_Alloc_BACK_HDR();
  278.       if (set_multi_flag == xaFALSE)
  279.           pic = SET_Read_BACK(xin,tmp_back_hdr);
  280.       else
  281.       { XA_INPUT xin_new;
  282.         SET_Extract_Directory(set_buff,set_buff1);
  283.         (void)XA_Setup_Input_Methods(&xin_new,set_buff);
  284.         if (xin_new.Open_File(&xin_new) == xaFALSE)
  285.         {
  286.           SET_Modify_Directory(set_buff,0);
  287.           (void)XA_Setup_Input_Methods(&xin_new,set_buff);
  288.           if (xin_new.Open_File(&xin_new) == xaFALSE)
  289.           {
  290.             fprintf(stderr,"Can't open SET File %s for reading\n",set_buff);
  291.             SET_TheEnd();
  292.           }
  293.         }
  294.         pic = SET_Read_BACK(&xin_new,tmp_back_hdr);
  295.         xin_new.Close_File(&xin_new);
  296.       }
  297.       if (pic == 0) SET_TheEnd1("SET read a) failed");
  298.       if (work_act == 0)
  299.       {
  300.         xaUBYTE *t_pic;
  301.         t_pic = (xaUBYTE *) malloc( 
  302.         XA_PIC_SIZE(tmp_back_hdr->xsize * tmp_back_hdr->ysize) );
  303.         if (t_pic == 0) SET_TheEnd1("SET a: malloc failed\n");
  304.         memset(t_pic, 0x00, (tmp_back_hdr->xsize * tmp_back_hdr->ysize) ); 
  305.         act = ACT_Get_Action(anim_hdr,ACT_MAPPED);
  306.         ACT_Setup_Mapped(act,t_pic,set_chdr,
  307.         0,0,tmp_back_hdr->xsize,tmp_back_hdr->ysize,
  308.             set_imagex,set_imagey,xaFALSE,0,xaTRUE,xaFALSE,xaFALSE);
  309.             ACT_Add_CHDR_To_Action(act,tmp_back_hdr->chdr);
  310.         work_act = act;
  311.       }
  312.       act = ACT_Get_Action(anim_hdr,ACT_MAPPED);
  313.       tmp_back_hdr->back_act = act;
  314.       ACT_Setup_Mapped(act,pic,set_chdr,
  315.         0,0,tmp_back_hdr->xsize,tmp_back_hdr->ysize,
  316.             set_imagex,set_imagey,xaFALSE,0,xaTRUE,xaFALSE,xaFALSE);
  317.           ACT_Add_CHDR_To_Action(act,set_chdr);
  318.     }
  319.     break;
  320.      case 'b':  /* 256 ascii 32 ascii IFF stuff  Faces */
  321.     {
  322.       SET_SSET_HDR *tmp_sset_hdr;
  323.       tmp_sset_hdr = SET_Alloc_SSET_HDR();
  324.       xin->Read_Block(xin,set_buff,256); /* disk:directory name */
  325.       set_buff[256] = 0;
  326.       DEBUG_LEVEL1 fprintf(stderr," b) %s    ",set_buff);
  327.       xin->Read_Block(xin,set_buff1,32); /* file name */
  328.       set_buff1[32] = 0;
  329.       DEBUG_LEVEL1 fprintf(stderr,"   %s\n",set_buff1);
  330.           if (set_multi_flag == xaFALSE) SET_Read_SSET(anim_hdr,xin,tmp_sset_hdr);
  331.           else
  332.           { XA_INPUT xin_new;
  333.             SET_Extract_Directory(set_buff,set_buff1);
  334.         (void)XA_Setup_Input_Methods(&xin_new,set_buff);
  335.         if (xin_new.Open_File(&xin_new) == xaFALSE)
  336.             {
  337.           SET_Modify_Directory(set_buff,0);
  338.           (void)XA_Setup_Input_Methods(&xin_new,set_buff);
  339.           if (xin_new.Open_File(&xin_new) == xaFALSE)
  340.           {
  341.         fprintf(stderr,"Can't open SET File %s for reading\n",set_buff);
  342.         SET_TheEnd();
  343.           }
  344.             }
  345.         SET_Read_SSET(anim_hdr,&xin_new,tmp_sset_hdr);
  346.             xin_new.Close_File(&xin_new);
  347.       }
  348.     }
  349.     break;
  350.      case 'c': /* 10 bytes set current frame */
  351.     {
  352.       xaULONG i;
  353.       i = 8; while(i--) xin->Read_U8(xin);
  354.       cur_fram_num  = xin->Read_MSB_U16(xin);
  355.       cur_fram_cnt = cur_fram_num;
  356.       DEBUG_LEVEL2 fprintf(stderr," c) %x\n",cur_fram_num);
  357.     }
  358.     break;
  359.      case 'd': /* new SSET header 32 ascii + 10 bytes */
  360.     {
  361.       xaULONG i;
  362.       xin->Read_Block(xin,set_buff,32);
  363.       set_buff[32] = 0;
  364.       DEBUG_LEVEL1 fprintf(stderr," d) sset hdr %s  ",set_buff);
  365.       set_sset_cur_num = xin->Read_MSB_U16(xin);
  366.       set_sset_xoff = xin->Read_MSB_U16(xin);
  367.       set_sset_yoff = xin->Read_MSB_U16(xin);
  368.       i = xin->Read_MSB_U16(xin);
  369.       i = xin->Read_MSB_U16(xin); /* last fram in series */
  370.       set_sset_cur = SET_Get_SSET(set_sset_cur_num);
  371.       DEBUG_LEVEL2 fprintf(stderr,"  %x %x\n",
  372.         set_sset_cur_num,set_sset_cur->num);
  373.       cur_fram_cnt = cur_fram_num;
  374.     }
  375.     break;
  376.      case 'e': /* position face 12 bytes */
  377.     {
  378.       SET_FACE_HDR *face_hdr;
  379.       xaULONG face_num,depth,garb,fram_num;
  380.       xaLONG xpos,ypos,xoff,yoff;
  381.       xaLONG back_x,back_y;
  382.  
  383.       face_num = xin->Read_MSB_U16(xin);
  384.       xoff     = xin->Read_MSB_U16(xin);
  385.       yoff     = xin->Read_MSB_U16(xin);
  386.       depth    = xin->Read_MSB_U16(xin);
  387.       garb     = xin->Read_MSB_U16(xin);
  388.       fram_num = xin->Read_MSB_U16(xin); /* not correct */
  389.       DEBUG_LEVEL2 fprintf(stderr," e) %x (%x %x) %x %x %x\n",
  390.         face_num,xoff,yoff,depth,garb,fram_num);
  391.       if (face_num > set_sset_cur->face_num)
  392.       {
  393.         fprintf(stderr,"SET_Read: e) face_num invalid %x (%x)",
  394.         face_num, set_sset_cur->face_num);
  395.         SET_TheEnd();
  396.       }
  397.       face_hdr = &(set_sset_cur->faces[face_num]);
  398.  
  399.       xpos  = face_hdr->xoff + set_sset_xoff;
  400.       xpos += xoff;
  401.       ypos  = face_hdr->yoff + set_sset_yoff;
  402.       ypos += yoff;
  403. DEBUG_LEVEL2 fprintf(stderr,"      e FACE off <%d,%d> fin <%d,%d>\n",
  404.         xoff,yoff,xpos,ypos);
  405.  
  406.  
  407.       /* Back ground Scrolling calculations - see g) */
  408.       if (set_xscroll_flag == 1)
  409.       {
  410.         back_x = -set_xscroll_len * (cur_fram_cnt - set_back_scroll_fram);
  411.         while(back_x < 0) back_x += set_back_cur->xsize;
  412.         if (back_x >= set_back_cur->xsize) back_x %= set_back_cur->xsize;
  413.       } else back_x = 0;
  414.  
  415.       if (set_yscroll_flag == 1)
  416.       {
  417.         back_y = -set_yscroll_len * (cur_fram_cnt - set_back_scroll_fram);
  418.         while(back_y < 0) back_y += set_back_cur->ysize;
  419.         if (back_y >= set_back_cur->ysize) back_y %= set_back_cur->ysize;
  420.       } else back_y = 0;
  421.  
  422.           if (face_hdr->face_act->type != ACT_NOP)
  423.         SET_Add_SETTER(anim_hdr,cur_fram_cnt,back_x,back_y,
  424.           xpos,ypos,face_hdr->face_act,depth);
  425.       cur_fram_cnt++;
  426.     }
  427.     break;
  428.      case 'f': /* backgrnd display info  4 bytes */
  429.     {
  430.       xaULONG back,effect;
  431.       back = xin->Read_MSB_U16(xin);
  432.       effect = xin->Read_MSB_U16(xin);
  433.       DEBUG_LEVEL2 
  434.          fprintf(stderr," f) backgrnd info %x %x  ",back,effect);
  435.       if (back == 0xffff) set_back_cur = SET_Add_Black(anim_hdr);
  436.       else set_back_cur = SET_Get_BACK(back);
  437.       DEBUG_LEVEL2 fprintf(stderr,"  %x\n",set_back_cur->num);
  438.       SET_Add_BACK(cur_fram_num,set_back_cur->back_act,set_back_cur->chdr);
  439.     }
  440.     break;
  441.      case 'g': /* backgrnd scrolling info(?)  8 bytes */
  442.     {
  443.       xaLONG tmp1,tmp2,tmp3,tmp4;
  444.  
  445.       tmp1 = xin->Read_MSB_U16(xin);  if (tmp1 & 0x8000) tmp1 -= 0x10000;
  446.       tmp2 = xin->Read_MSB_U16(xin);  if (tmp2 & 0x8000) tmp2 -= 0x10000;
  447.       tmp3 = xin->Read_MSB_U16(xin);  if (tmp3 & 0x8000) tmp3 -= 0x10000;
  448.       tmp4 = xin->Read_MSB_U16(xin);  if (tmp4 & 0x8000) tmp4 -= 0x10000;
  449.  
  450.       if (tmp4 == 0)
  451.       { /* scroll only in x direction */
  452.         set_xscroll_flag = 1;
  453.         set_yscroll_flag = 0;
  454.         set_yscroll_len = 0;
  455.         if (tmp3 == 0) set_xscroll_len = tmp1;
  456.         else set_xscroll_len = tmp2;
  457.         if (set_xscroll_len == 0) set_xscroll_flag = 0;
  458.       }
  459.       else
  460.       { /* scroll only in y direction */
  461.         set_yscroll_flag = 1;
  462.         set_xscroll_flag = 0;
  463.         set_xscroll_len = 0;
  464.         if (tmp3 == 0) set_yscroll_len = tmp1;
  465.         else set_yscroll_len = tmp2; 
  466.         /* PODNOTE: I haven't seen tmp3 == tmp4 == 1 so this is a guess */
  467.         if (set_yscroll_len == 0) set_yscroll_flag = 0;
  468.       }
  469.       set_back_scroll_fram = cur_fram_num;
  470.       DEBUG_LEVEL2 fprintf(stderr," g) %d %d %d %d\n",
  471.          set_xscroll_flag,set_xscroll_len,set_yscroll_flag,set_yscroll_len);
  472.     }
  473.     break;
  474.      case 'h': /* sound info  10 bytes */
  475.     {
  476.       xaULONG i;
  477.       DEBUG_LEVEL2 fprintf(stderr," h) sound info - not supported\n");
  478.       i = 10; while(i--) xin->Read_U8(xin);
  479.     }
  480.     break;
  481.      case 'i': /* timing info  2 bytes*/
  482.     set_time = xin->Read_MSB_U16(xin); if (set_time == 0) set_time = 1;
  483.     DEBUG_LEVEL2 fprintf(stderr," i) %x\n",set_time);
  484.     set_time = set_time * 16;
  485.         SET_Add_TIME(cur_fram_num,set_time);
  486.     break;
  487.      case 'j':  /* 256 ascii 32 ascii IFF stuff  Sounds Info */
  488.     xin->Read_Block(xin,set_buff,256); set_buff[256] = 0;
  489.     DEBUG_LEVEL1 fprintf(stderr," j) %s    ",set_buff);
  490.     xin->Read_Block(xin,set_buff1,32); set_buff1[32] = 0;
  491.     DEBUG_LEVEL1 fprintf(stderr,"   %s\n",set_buff1);
  492.         if (set_multi_flag == xaFALSE) SET_Read_Sound_IFF(xin);
  493.     /* else ignore */
  494.     break;
  495.      case 'k': /* ? header of some sort 40 bytes */
  496.     {
  497.       xaULONG i;
  498.       DEBUG_LEVEL2 fprintf(stderr," k) ???\n");
  499.       i = 40; while(i--) xin->Read_U8(xin);
  500.     }
  501.     break;
  502.      case 'l': /* cmap info 64 bytes */
  503.     DEBUG_LEVEL2 fprintf(stderr," l) cmap\n");
  504.     set_imagec = 32;
  505.     IFF_Read_CMAP_1(set_cmap,set_imagec,xin);
  506.     IFF_Shift_CMAP(set_cmap,set_imagec);
  507.     set_chdr = ACT_Get_CMAP(set_cmap,set_imagec,set_or_mask,
  508.                 set_imagec,set_or_mask,4,4,4);
  509.     SET_Add_CHDR(set_chdr,cur_fram_num);
  510.     break;
  511.      case 'v': /* ? header of some sort 26 bytes */
  512.     {
  513.       xaULONG i;
  514.       DEBUG_LEVEL2 fprintf(stderr," v) ?header?\n");
  515.       i = 26; while(i--) xin->Read_U8(xin);
  516.     }
  517.     break;
  518.      case 'w': /* frame count */
  519.     set_fram_num = xin->Read_MSB_U16(xin)+1;
  520.         set_frames = SET_Init_FRAM_HDRS(set_fram_num);
  521.     DEBUG_LEVEL1 fprintf(stderr," w) %d frames\n",set_fram_num);
  522.     break;
  523.      case 'x': /* title and version 32 ascii*/
  524.     xin->Read_Block(xin,set_buff1,32); set_buff1[32] = 0;
  525.     DEBUG_LEVEL1 fprintf(stderr," x) %s\n",set_buff1);
  526.     break;
  527.      case 'y': /*  8 bytes  if present indicates IFF chunks included  */
  528.     DEBUG_LEVEL2 fprintf(stderr," y)\n");
  529.     set_multi_flag = xaFALSE;
  530.     break;
  531.      case 'z': /* EOF marker */
  532.     exit_flag = 1;
  533.     break;
  534.  
  535.  
  536.     default: fprintf(stderr,"Unknown opcode = %x\n",op);
  537.         xin->Close_File(xin);
  538.     SET_TheEnd();
  539.    } /* end of switch */
  540.  } /* end of while */
  541.  xin->Close_File(xin);
  542.  
  543.  {
  544.    xaULONG frame_cnt,i,j;
  545.    XA_ACTION *back_act;
  546.    xaULONG fram_time;
  547.    xaULONG buffx,buffy,need_to_scale;
  548.    xaLONG t_time;
  549.  
  550.    /* Check Out For buffer Scaling */
  551.    need_to_scale = UTIL_Get_Buffer_Scale(set_imagex,set_imagey,&buffx,&buffy);
  552.  
  553.    fram_time = 1;
  554.    frame_cnt = 0;
  555.    back_act = 0;
  556.    for(i=0; i<set_fram_num; i++)
  557.    {
  558.      SET_FRAM_HDR *fram_hdr;
  559.      ACT_SETTER_HDR *pms_hdr;
  560.  
  561.      fram_hdr = &(set_frames[i]);
  562.      frame_cnt++;
  563.      /* register chdr's */
  564.      if (fram_hdr->cm_hdr == 0) fram_hdr->cm_hdr = set_chdr;
  565.      else set_chdr = fram_hdr->cm_hdr;
  566.  
  567.      /* spread out timing info */
  568.      if (fram_hdr->time == 0xffffffff)
  569.      {
  570.        fram_hdr->time = fram_time;
  571.      }
  572.      else
  573.      {
  574.        fram_time = fram_hdr->time;
  575.      }
  576.  
  577.      /* spread out backgrounds */
  578.      if (fram_hdr->back_act != 0) back_act = fram_hdr->back_act;
  579.      else 
  580.        if (back_act != 0) fram_hdr->back_act = back_act;
  581.        else 
  582.        { 
  583.          set_back_cur = SET_Add_Black(anim_hdr);
  584.          back_act = set_back_cur->back_act;
  585.          fram_hdr->back_act = back_act;
  586.        }
  587.  
  588.      if (back_act->chdr == 0) ACT_Add_CHDR_To_Action(back_act,set_chdr);
  589.  
  590.     /* add set_chdr to setter action if it doesn't have one */
  591.      if (fram_hdr->pms_act) 
  592.      {
  593.        if (fram_hdr->pms_act->chdr == 0)
  594.         ACT_Add_CHDR_To_Action(fram_hdr->pms_act,set_chdr);
  595.      }
  596.      pms_hdr = fram_hdr->pms_hdr;
  597.      while(pms_hdr)
  598.      {
  599.        ACT_MAPPED_HDR *back_map_hdr;
  600.        back_map_hdr = (ACT_MAPPED_HDR *)back_act->data;
  601.        pms_hdr->back = back_act;
  602.        pms_hdr->xback = back_map_hdr->xsize;
  603.        pms_hdr->yback = back_map_hdr->ysize;
  604. DEBUG_LEVEL1
  605. {
  606.   fprintf(stderr,"---> %d %d   ",pms_hdr->xpback,pms_hdr->ypback);
  607.   if (pms_hdr->face) fprintf(stderr,"%d %d\n",pms_hdr->xpface,pms_hdr->ypface);
  608.   else fprintf(stderr,"\n");
  609. }
  610.        if (need_to_scale)
  611.         UTIL_Scale_Buffer_Pos(&pms_hdr->xpback,&pms_hdr->ypback,
  612.             set_imagex,set_imagey,buffx,buffy);
  613.     /* add set_chdr to face action if it doesn't have one */
  614.        if (pms_hdr->face)
  615.        {
  616.      if (pms_hdr->face->chdr == 0)
  617.         ACT_Add_CHDR_To_Action(pms_hdr->face,set_chdr);
  618.          if (need_to_scale)
  619.         UTIL_Scale_Buffer_Pos(&pms_hdr->xpface,&pms_hdr->ypface,
  620.             set_imagex,set_imagey,buffx,buffy);
  621.        }
  622. DEBUG_LEVEL1
  623. {
  624.   fprintf(stderr,"     %d %d   ",pms_hdr->xpback,pms_hdr->ypback);
  625.   if (pms_hdr->face) 
  626.     fprintf(stderr,"%d %d\n",pms_hdr->xpface,pms_hdr->ypface);
  627.   else fprintf(stderr,"\n");
  628. }
  629.        pms_hdr = pms_hdr->next;
  630.      }
  631.    } /* end of frame list loop */
  632.    frame_cnt++; /* last frame */ 
  633.    anim_hdr->frame_lst = (XA_FRAME *)malloc(sizeof(XA_FRAME) * frame_cnt);
  634.    if (anim_hdr->frame_lst == NULL)
  635.        TheEnd1("SET_ANIM: frame_lst malloc err");
  636.    anim_hdr->frame_lst[frame_cnt-1].time_dur = 0;
  637.    anim_hdr->frame_lst[frame_cnt-1].zztime = -1;
  638.    anim_hdr->frame_lst[frame_cnt-1].act  = 0;
  639.  
  640.    j = 0;
  641.    t_time = 0;
  642.    for(i=0; i<set_fram_num; i++)
  643.    {
  644.      if (set_frames[i].pms_hdr != 0)
  645.      {
  646.        anim_hdr->frame_lst[j].time_dur = set_frames[i].time;
  647.        anim_hdr->frame_lst[j].zztime = t_time;
  648.        anim_hdr->frame_lst[j].act  = set_frames[i].pms_act;
  649.        t_time += set_frames[i].time;
  650.        j++;
  651.      }
  652.      else
  653.      {
  654.        anim_hdr->frame_lst[j].time_dur = set_frames[i].time;
  655.        anim_hdr->frame_lst[j].zztime = t_time;
  656.        anim_hdr->frame_lst[j].act  = set_frames[i].back_act;
  657.        t_time += set_frames[i].time;
  658.        j++;
  659.      }
  660.  
  661.    }
  662.    anim_hdr->total_time = t_time;
  663.    anim_hdr->loop_frame = 0;
  664.    anim_hdr->last_frame = frame_cnt-2;
  665.    anim_hdr->imagex = set_imagex;
  666.    anim_hdr->imagey = set_imagey;
  667.    anim_hdr->imagec = set_imagec;
  668.    anim_hdr->imaged = set_imaged;
  669.  
  670.  }
  671.  SET_Free_Stuff();
  672.  return(xaTRUE);
  673. }
  674.  
  675. xaUBYTE *SET_Read_BACK(xin,back_hdr)
  676. XA_INPUT *xin;
  677. SET_BACK_HDR *back_hdr;
  678. {
  679.   xaULONG chid,data;
  680.   xaLONG size,form_size;
  681.   xaUBYTE *pic;
  682.  
  683.   pic = 0;
  684.   chid = xin->Read_MSB_U32(xin);
  685.   /* NOTE: for whatever reason the Anti-Lemmin' animation as a "bad" form 
  686.    * size with the upper 16 bits set to 0xffff. By making sure the last
  687.    * bit is clear, things should work ok anyways. We just read to the BODY.
  688.    */
  689.   form_size = xin->Read_MSB_U32(xin);
  690.   form_size &= 0x7fffffff;  /* PODNOTE: Anti-Lemmin' kludge/workaround */
  691.   data = xin->Read_MSB_U32(xin); form_size -= 4;
  692.   DEBUG_LEVEL1 fprintf(stderr,"SET_Read_BACK: chid %x fsize %x dat %x\n", chid,form_size,data);
  693.   if (chid != FORM) SET_TheEnd1("SET: back is not FORM\n");
  694.   while(form_size)
  695.   {
  696.     chid = xin->Read_MSB_U32(xin); form_size -= 4;
  697.     size = xin->Read_MSB_U32(xin); form_size -= 4;
  698.     size &= 0x0000ffff;   /* PODNOTE: Anti-Lemmin' kludge/workaround */
  699.     form_size -= size;
  700.     if (form_size < 0) form_size = 0;
  701.  
  702.     DEBUG_LEVEL2 IFF_Print_ID(stderr,chid);
  703.     DEBUG_LEVEL2 fprintf(stderr," size %x ",size);
  704.     switch(chid)
  705.     {
  706.       case BMHD:
  707.     IFF_Read_BMHD(xin,&bmhd);
  708.     set_imagex = bmhd.width;  /*pageWidth;*/
  709.     set_imagey = bmhd.height; /*pageHeight;*/
  710.     set_imaged = bmhd.depth;
  711.     back_hdr->xsize = bmhd.width;
  712.     back_hdr->ysize = bmhd.height;
  713.     back_hdr->xscreen = bmhd.width; /*pageWidth; */
  714.     back_hdr->yscreen = bmhd.height; /*pageHeight; */
  715.     DEBUG_LEVEL1 fprintf(stderr,"    %dx%dx%d %dx%d cmp=%d msk=%d\n",
  716.         back_hdr->xsize,back_hdr->ysize,
  717.             set_imaged,back_hdr->xscreen,back_hdr->yscreen,
  718.         bmhd.compression, bmhd.masking);
  719.     break;
  720.       case CMAP:
  721.     set_imagec = size/3;
  722.     back_hdr->csize = set_imagec;
  723.     IFF_Read_CMAP_0(set_cmap,set_imagec,xin);
  724.     IFF_Shift_CMAP(set_cmap,set_imagec);
  725.     set_chdr = ACT_Get_CMAP(set_cmap,set_imagec,set_or_mask,
  726.                 set_imagec,set_or_mask,4,4,4);
  727.     back_hdr->chdr = set_chdr;
  728.     break;
  729.       case CAMG: /* ignore for now */
  730.       case CRNG: /* ignore for now */
  731.       case DPPS: /* ignore for now */
  732.       case DPPV: /* ignore for now */
  733.     {
  734.       xaULONG d;
  735.           while( (size--) && !xin->At_EOF(xin) ) d = xin->Read_U8(xin);
  736.     }
  737.         break;
  738.       case BODY:
  739.     {
  740.       xaULONG xsize,ysize;
  741.       xsize = bmhd.width;
  742.       ysize = bmhd.height;
  743.       pic = (xaUBYTE *) malloc( XA_PIC_SIZE(xsize * ysize) );
  744.       if (pic == 0) SET_TheEnd1("SET_Read_BODY: malloc failed\n");
  745.       IFF_Read_BODY(xin,pic,size, xsize, ysize, (xaULONG)(bmhd.depth),
  746.         (int)(bmhd.compression), (int)(bmhd.masking),set_or_mask);
  747.       form_size = 0; /* body is always last */
  748.       break;
  749.     }
  750.       default: 
  751.     SET_Print_CHID(chid); SET_TheEnd1("\nUnknown in Back chunk\n");
  752.     break;
  753.     } /* end of switch */
  754.   } /* end of while */
  755.   return(pic);
  756. }
  757.  
  758.  
  759. void SET_Read_SSET(anim_hdr,xin,set_hdr)
  760. XA_ANIM_HDR *anim_hdr;
  761. XA_INPUT *xin;
  762. SET_SSET_HDR *set_hdr;
  763. {
  764.   xaULONG chid,data;
  765.   xaLONG list_num,type,i;
  766.  
  767.   chid = xin->Read_MSB_U32(xin);
  768.   list_num = xin->Read_MSB_U32(xin) + 1;
  769.   data = xin->Read_MSB_U32(xin);
  770.   set_hdr->face_num = list_num;
  771.   DEBUG_LEVEL1 
  772.   {
  773.     fprintf(stderr,"    ");
  774.     SET_Print_CHID(chid);
  775.     fprintf(stderr,"%x ",list_num);
  776.     SET_Print_CHID(data);
  777.     fprintf(stderr,"\n");
  778.   }
  779.   if (chid != LIST) SET_TheEnd1("SET: LIST not 1st in SSET\n");
  780.  
  781.   set_hdr->faces = (SET_FACE_HDR *)malloc(list_num * sizeof(SET_FACE_HDR) );
  782.   if (set_hdr->faces == 0) SET_TheEnd1("SET: faces malloc failed\n");
  783.  
  784.   /* Read PROP */
  785.   chid = xin->Read_MSB_U32(xin);  /* PROP */
  786.   DEBUG_LEVEL1 fprintf(stderr,"    ");
  787.   DEBUG_LEVEL1 SET_Print_CHID(chid);
  788.   if (chid != PROP) SET_TheEnd1("SET: 1st not PROP in SET\n");
  789.   data = xin->Read_MSB_U32(xin);  /* prop size */
  790.   type = xin->Read_MSB_U32(xin);  /* prop type */
  791.   DEBUG_LEVEL1 fprintf(stderr,"%x ",data);
  792.   DEBUG_LEVEL1 SET_Print_CHID(type);
  793.  
  794.   /* Read CMAP */
  795.   chid = xin->Read_MSB_U32(xin);  /* CMAP */
  796.   DEBUG_LEVEL1 SET_Print_CHID(chid);
  797.   if (chid != CMAP) SET_TheEnd1("SET: 2st not CMAP in SET\n");
  798.   set_imagec = xin->Read_MSB_U32(xin);  /* CMAP size */
  799.   set_imagec /= 2;
  800.   DEBUG_LEVEL1 fprintf(stderr," %x\n",set_imagec);
  801.   IFF_Read_CMAP_1(set_cmap,set_imagec,xin);
  802.   IFF_Shift_CMAP(set_cmap,set_imagec);
  803.   set_chdr = ACT_Get_CMAP(set_cmap,set_imagec,set_or_mask,
  804.                 set_imagec,set_or_mask,4,4,4);
  805.   
  806.   for(i = 1; i < list_num; i++)
  807.   {
  808.     SET_FACE_HDR *face;
  809.     xaUBYTE *pic;
  810.     XA_ACTION *act;
  811.  
  812.     face = &set_hdr->faces[i];
  813.     pic = SET_Read_FACE(xin,face);
  814.     if (pic==0) SET_TheEnd1("SET_Read_SSET: read face failed\n");
  815.  
  816.     act = ACT_Get_Action(anim_hdr,ACT_MAPPED);
  817.     ACT_Setup_Mapped(act,pic,set_chdr,
  818.     face->x,face->y,face->xsize,face->ysize,
  819.     set_imagex,set_imagey,xaTRUE,set_or_mask,xaTRUE,xaFALSE,xaFALSE);
  820.     ACT_Add_CHDR_To_Action(act,set_chdr);
  821.     face->face_act = act;
  822.   }
  823. }
  824.  
  825.  
  826. xaUBYTE *SET_Read_FACE(xin,face_hdr)
  827. XA_INPUT *xin;
  828. SET_FACE_HDR *face_hdr;
  829. {
  830.   xaULONG chid,data;
  831.   xaLONG size,form_size;
  832.   xaUBYTE *pic;
  833.  
  834.   pic = 0;
  835.   face_hdr->xsize = 0;
  836.   face_hdr->ysize = 0;
  837.   chid = xin->Read_MSB_U32(xin);
  838.   form_size = xin->Read_MSB_U32(xin);
  839.   data = xin->Read_MSB_U32(xin); form_size -= 4;
  840.   DEBUG_LEVEL2 fprintf(stderr,"    ");
  841.   DEBUG_LEVEL2 SET_Print_CHID(chid);
  842.   DEBUG_LEVEL2 fprintf(stderr,"%x ",form_size);
  843.   DEBUG_LEVEL2 SET_Print_CHID(data);
  844.   if (chid != FORM) SET_TheEnd1("SET: face is not FORM\n");
  845.   while(form_size)
  846.   {
  847.     chid = xin->Read_MSB_U32(xin); form_size -= 4;
  848.     size = xin->Read_MSB_U32(xin); form_size -= 4;
  849.     DEBUG_LEVEL2 SET_Print_CHID(chid);
  850.     DEBUG_LEVEL2 fprintf(stderr,"%x ",size);
  851.     form_size -= size;
  852.     if (form_size < 0) form_size = 0;
  853.  
  854.     switch(chid)
  855.     {
  856.       case FACE:
  857.     face_hdr->xsize = xin->Read_MSB_U16(xin);
  858.     face_hdr->ysize = xin->Read_MSB_U16(xin);
  859.     face_hdr->x     = xin->Read_MSB_U16(xin);
  860.     face_hdr->y     = xin->Read_MSB_U16(xin);
  861.     face_hdr->xoff  = xin->Read_MSB_U16(xin);
  862.     face_hdr->yoff  = xin->Read_MSB_U16(xin);
  863.     DEBUG_LEVEL2 
  864.     {
  865.   fprintf(stderr,"      FACE size <%d,%d> p <%d,%d> off <%d,%d>\n",
  866.       (xaLONG)face_hdr->xsize,(xaLONG)face_hdr->ysize,
  867.       (xaLONG)face_hdr->x,    (xaLONG)face_hdr->y,
  868.       (xaLONG)face_hdr->xoff, (xaLONG)face_hdr->yoff );
  869.     }
  870.     break;
  871.       case BODY:
  872.     {
  873.       pic = (xaUBYTE *) 
  874.         malloc( XA_PIC_SIZE(face_hdr->xsize * face_hdr->ysize) );
  875.       if (pic == 0) SET_TheEnd1("SET_Read_BODY: malloc failed\n");
  876.           DEBUG_LEVEL2 fprintf(stderr,"   %dx%dx%d comp=%d msk=%d",
  877.                 face_hdr->xsize,face_hdr->ysize,set_imaged,bmhd.compression,
  878.         bmhd.masking);
  879.  
  880.       IFF_Read_BODY(xin,pic,size,
  881.         face_hdr->xsize, face_hdr->ysize, 5,
  882.         (xaULONG)(bmhd.compression), (xaULONG)(bmhd.masking),set_or_mask);
  883.       form_size = 0; /* body is always last */
  884.       break;
  885.     }
  886.       default: 
  887.     SET_TheEnd1("\nUnknown in Back chunk\n");
  888.     break;
  889.     } /* end of switch */
  890.   } /* end of while */
  891.  DEBUG_LEVEL2 fprintf(stderr,"\n");
  892.  return(pic);
  893. }
  894.  
  895.  
  896. void SET_Free_Stuff()
  897. {
  898.   while(set_back_cur != 0)
  899.   {
  900.     SET_BACK_HDR *tmp;
  901.     tmp = set_back_cur;
  902.     set_back_cur = set_back_cur->next;
  903.     FREE(tmp,0x7000);
  904.   }
  905.   while(set_sset_cur != 0)
  906.   {
  907.     SET_SSET_HDR *tmp;
  908.     xaULONG num;
  909.     num = set_sset_cur->face_num;
  910.     if (set_sset_cur->faces != 0) 
  911.     { FREE(set_sset_cur->faces,0x7000); set_sset_cur->faces=0;}
  912.     tmp = set_sset_cur;
  913.     set_sset_cur = set_sset_cur->next;
  914.     FREE(tmp,0x7000);
  915.   }
  916. }
  917.  
  918. void SET_TheEnd1(mess)
  919. xaUBYTE *mess;
  920. {
  921.   SET_Free_Stuff();
  922.   TheEnd1(mess);
  923. }
  924.  
  925. void SET_TheEnd()
  926. {
  927.   SET_Free_Stuff();
  928.   TheEnd();
  929. }
  930.  
  931. void SET_Read_Sound_IFF(xin)
  932. XA_INPUT *xin;
  933. {
  934.   xaULONG chid,data;
  935.   xaLONG size,form_size;
  936.  
  937.   chid = xin->Read_MSB_U32(xin);
  938.   form_size = xin->Read_MSB_U32(xin);
  939.   DEBUG_LEVEL2 fprintf(stderr,"    FORM %x ",form_size);
  940.   data = xin->Read_MSB_U32(xin); form_size -= 4;
  941.   DEBUG_LEVEL2 SET_Print_CHID(data);
  942.   if (chid != FORM) SET_TheEnd1("SET: sound is not FORM\n");
  943.   while(form_size)
  944.   {
  945.     xaULONG d;
  946.     chid = xin->Read_MSB_U32(xin); form_size -= 4;
  947.     size = xin->Read_MSB_U32(xin); form_size -= 4;
  948.     DEBUG_LEVEL2 SET_Print_CHID(data);
  949.     DEBUG_LEVEL2 fprintf(stderr," %x ",size);
  950.     form_size -= size;
  951.     if (form_size < 0) form_size = 0;
  952.     switch(chid)
  953.     {
  954.       case BODY:
  955.     form_size = 0; /* last chunk */
  956.       case VHDR:
  957.       case ANNO:
  958.       case CHAN:
  959.     while( (size--) && !xin->At_EOF(xin) ) d = xin->Read_U8(xin);
  960.     break;
  961.       default: 
  962.     SET_Print_CHID(chid); SET_TheEnd1("\nUnknown in SOUND chunk\n");
  963.     break;
  964.     } /* end of switch */
  965.   } /* end of while */
  966.  DEBUG_LEVEL2 fprintf(stderr,"\n");
  967. }
  968.  
  969. SET_FRAM_HDR *SET_Init_FRAM_HDRS(num)
  970. xaULONG num;
  971. {
  972.   SET_FRAM_HDR *tmp_fram;
  973.   xaULONG i;
  974.  
  975.   tmp_fram = (SET_FRAM_HDR *)malloc(num * sizeof(SET_FRAM_HDR) );
  976.   if (tmp_fram == 0) SET_TheEnd1("SET_Init_Fram_HDR: malloc failed");
  977.  
  978.   for(i=0; i<num; i++)
  979.   {
  980.     tmp_fram[i].time     = 0xffffffff;
  981.     tmp_fram[i].cm_act   = 0;
  982.     tmp_fram[i].pms_act  = 0;
  983.     tmp_fram[i].back_act = 0;
  984.     tmp_fram[i].cm_hdr   = 0;
  985.     tmp_fram[i].pms_hdr  = 0;
  986.   }
  987.   return(tmp_fram);
  988. }
  989.  
  990.   
  991. void SET_Add_CHDR(chdr,fram_num)
  992. XA_CHDR *chdr;
  993. xaULONG fram_num;
  994. {
  995.   SET_FRAM_HDR *fram_hdr;
  996.  
  997.   if (fram_num > set_fram_num)
  998.   {
  999.     fprintf(stderr,"SET_Add_CHDR: invalid frame %x\n", fram_num);
  1000.     return;
  1001.   }
  1002.   fram_hdr = &set_frames[fram_num];
  1003.   if (fram_hdr->cm_hdr != 0)
  1004.   {
  1005.     DEBUG_LEVEL2 fprintf(stderr,"SET_Add_CHDR: duplicate cmap warning\n");
  1006.   }
  1007.   fram_hdr->cm_hdr = chdr;
  1008. }
  1009.  
  1010. void SET_Add_BACK(fram_num,back_act,chdr)
  1011. xaULONG fram_num;
  1012. XA_ACTION *back_act;
  1013. XA_CHDR *chdr;
  1014. {
  1015.   SET_FRAM_HDR *fram_hdr;
  1016.  
  1017.   if (fram_num > set_fram_num)
  1018.   {
  1019.     fprintf(stderr,"SET_Add_BACK: invalid frame %x\n", fram_num);
  1020.     return;
  1021.   }
  1022.   fram_hdr = &set_frames[fram_num];
  1023.   if (fram_hdr->back_act != 0)
  1024.     fprintf(stderr,"SET_Add_BACK: duplicate back err\n");
  1025.   fram_hdr->back_act = back_act;
  1026.  
  1027.       /* if no CMAP for this frame add the back's */
  1028.   if (fram_hdr->cm_hdr == 0) SET_Add_CHDR(chdr,fram_num);
  1029.  
  1030. }
  1031.  
  1032. void SET_Add_TIME(fram_num,fram_time)
  1033. xaULONG fram_num,fram_time;
  1034. {
  1035.   SET_FRAM_HDR *fram_hdr;
  1036.   if (fram_num > set_fram_num) 
  1037.   {
  1038.     fprintf(stderr,"SET_Add_TIME: invalid fram_num %x\n",fram_num);
  1039.     return;
  1040.   }
  1041.   fram_hdr = &set_frames[fram_num]; 
  1042.   fram_hdr->time = set_time;
  1043. }
  1044.  
  1045.  
  1046. /*
  1047.  *
  1048.  */
  1049. void SET_Add_SETTER(anim_hdr,fram_num,xpback,ypback,
  1050.         xpface,ypface,face_act,depth)
  1051. XA_ANIM_HDR *anim_hdr;
  1052. xaULONG fram_num;
  1053. xaULONG xpback,ypback;
  1054. xaULONG xpface,ypface;
  1055. XA_ACTION *face_act;
  1056. xaULONG depth;
  1057. {
  1058.   ACT_MAPPED_HDR *face_map_hdr;
  1059.   SET_FRAM_HDR *fram_hdr;
  1060.   ACT_SETTER_HDR *tmp_pms,*cur_pms;
  1061.   XA_ACTION *act;
  1062.  
  1063.   if (fram_num > set_fram_num) 
  1064.   {
  1065.     fprintf(stderr,"SET_Add_SETTER: invalid fram_num %x\n",fram_num);
  1066.     return;
  1067.   }
  1068.   fram_hdr = &set_frames[fram_num]; 
  1069.   face_map_hdr = (ACT_MAPPED_HDR *) face_act->data;
  1070.  
  1071.   act = ACT_Get_Action(anim_hdr,ACT_SETTER);
  1072.  
  1073.  
  1074.   tmp_pms = (ACT_SETTER_HDR *)malloc(sizeof(ACT_SETTER_HDR));
  1075.   if (tmp_pms == 0) SET_TheEnd1("SET_Add_SETTER: malloc failed");
  1076.  
  1077.   act->data = (xaUBYTE *)tmp_pms;
  1078.  
  1079.   tmp_pms->work = work_act;
  1080.   tmp_pms->xpback = xpback;
  1081.   tmp_pms->ypback = ypback;
  1082.   tmp_pms->xface = face_map_hdr->xsize;
  1083.   tmp_pms->yface = face_map_hdr->ysize;
  1084.   tmp_pms->xpface = xpface;
  1085.   tmp_pms->ypface = ypface;
  1086.   tmp_pms->depth = depth;
  1087.   tmp_pms->face = face_act;
  1088.   tmp_pms->back = 0;
  1089.   tmp_pms->xback = 0;
  1090.   tmp_pms->yback = 0;
  1091.  
  1092.    /* if this is the 1st one. */
  1093.   if (fram_hdr->pms_hdr == 0)  /* 1st one */
  1094.   {
  1095.     fram_hdr->pms_hdr = tmp_pms;
  1096.     tmp_pms->next = 0;
  1097.     fram_hdr->pms_act = act;
  1098.     return;
  1099.   }
  1100.   /* if 1st one is of less or equal depth */
  1101.   if (fram_hdr->pms_hdr->depth <= depth)
  1102.   {
  1103.     tmp_pms->next = fram_hdr->pms_hdr;
  1104.     fram_hdr->pms_hdr = tmp_pms;
  1105.     fram_hdr->pms_act = act;  /* keep act current */
  1106.     return;
  1107.   }
  1108.  
  1109.   cur_pms = fram_hdr->pms_hdr;
  1110.   while(cur_pms != 0)
  1111.   {
  1112.     /*  there isn't a next one */
  1113.     if (cur_pms->next == 0)
  1114.     {
  1115.       tmp_pms->next = 0;
  1116.       cur_pms->next = tmp_pms;
  1117.       return;
  1118.     }
  1119.      /* if the next one's depth is <= then put here */
  1120.     if (cur_pms->next->depth <= depth)
  1121.     {
  1122.       tmp_pms->next = cur_pms->next;
  1123.       cur_pms->next = tmp_pms;
  1124.       return;
  1125.     }
  1126.     cur_pms = cur_pms->next;
  1127.   }
  1128.  
  1129. }
  1130.  
  1131. void SET_Extract_Directory(dname,cname)
  1132. xaUBYTE *dname,*cname;
  1133. {
  1134.  xaULONG i,j;
  1135.  
  1136.  i = 0;
  1137.  while( (dname[i] != ':') && (i < 256) && (dname[i] != 0) ) i++;
  1138.  if ((dname[i]==0) || (i >= 256)) SET_TheEnd1("SET_Extract: error 1\n");
  1139.  
  1140.  i++; /* skip over : */
  1141.  j = 0;
  1142.  while( (dname[i] != 0) && (i < 256) )
  1143.  {
  1144.    dname[j] = dname[i]; i++; j++;
  1145.  }
  1146.  if (i >= 256) SET_TheEnd1("SET_Extract: error 2\n");
  1147.  dname[j] = '/'; j++;
  1148.  
  1149.  i = 0;
  1150.  while( (cname[i] != 0) && (i<32) ) 
  1151.  {
  1152.    dname[j] = cname[i]; i++; j++;
  1153.  }
  1154.  if (i >= 32) SET_TheEnd1("SET_Extract: error 3\n");
  1155.  dname[j] = 0;
  1156. }
  1157.  
  1158. void SET_Modify_Directory(dname,flag)
  1159. char dname[];
  1160. xaULONG flag;
  1161. {
  1162.   int d = (int)dname[0];
  1163.   if (flag == 0)  /* flip upper/lower on 1st char */
  1164.   {
  1165.     if (isupper(d) ) dname[0] = (char)tolower(d);
  1166.     else dname[0] = (char)toupper(d);
  1167.   }
  1168. }
  1169.  
  1170.