home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_dl.c < prev    next >
C/C++ Source or Header  |  1997-01-26  |  19KB  |  695 lines
  1.  
  2. /*
  3.  * xa_dl.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.  
  19. #include "xa_dl.h"
  20.  
  21. XA_CHDR   *ACT_Get_CMAP();
  22. XA_ACTION *ACT_Get_Action();
  23. void  ACT_Setup_Mapped();
  24. void  ACT_Add_CHDR_To_Action();
  25. void  ACT_Setup_Loop();
  26. xaULONG DL_Read_File();
  27. extern XA_ANIM_SETUP *XA_Get_Anim_Setup();
  28. void XA_Free_Anim_Setup();
  29. xaULONG DL_Decode_Image();
  30. ACT_DLTA_HDR *DL_Get_Dlta_HDR();
  31.  
  32. extern void ACT_Setup_Delta();
  33.  
  34. static xaULONG dl_version;
  35. static xaULONG dl_format;
  36. static xaUBYTE dl_title[41];
  37. static xaUBYTE dl_author[41];
  38. static xaULONG dl_num_of_screens;
  39. static xaULONG dl_num_of_images;
  40. static xaULONG dl_ims_per_screen;
  41. static xaULONG dl_num_of_frames;
  42. static xaULONG dl_frame_cnt;
  43. static xaULONG dl_loop_frame;
  44. static xaULONG dl_txt_size;
  45.  
  46.  
  47. static XA_ACTION **dl_acts;
  48. static xaULONG dl_image_cnt;
  49.  
  50. typedef struct DL_FRAME_STRUCT
  51. {
  52.   xaULONG type;
  53.   xaULONG cnt;
  54.   xaULONG dat0,dat1,dat2,dat3;
  55.   xaULONG time;
  56.   xaULONG timelo;
  57.   XA_ACTION *act;
  58.   struct DL_FRAME_STRUCT *loop;
  59.   struct DL_FRAME_STRUCT *prev_loop;
  60.   struct DL_FRAME_STRUCT *next;
  61. } DL_FRAME;
  62.  
  63. DL_FRAME *DL_Add_Cmd();
  64. void DL_Free_Cmd_List();
  65. xaULONG DL_Cnt_Cmds();
  66. xaULONG DL_Gen_Frame_List();
  67. static DL_FRAME *dl_cmd_start,*dl_cmd_cur;
  68. static xaULONG dl_cmd_cnt;
  69.  
  70. /**********
  71.  *
  72.  ****/
  73. DL_FRAME *DL_Add_Cmd(type,time,timelo)
  74. xaULONG type;
  75. xaULONG time,timelo;
  76. { DL_FRAME *fframe;
  77.  
  78.   fframe = (DL_FRAME *) malloc(sizeof(DL_FRAME));
  79.   if (fframe == 0) TheEnd1("DL_Add_Cmd: malloc err");
  80.  
  81.   fframe->type = type;
  82.   fframe->act = 0;
  83.   fframe->time   = time;
  84.   fframe->timelo = timelo;
  85.   fframe->cnt = 0;
  86.   fframe->dat0 = fframe->dat1 = fframe->dat2 = fframe->dat3 = 0;
  87.   fframe->next = 0;
  88.   fframe->loop = 0;
  89.  
  90.   if (dl_cmd_start == 0) dl_cmd_start = fframe;
  91.   else dl_cmd_cur->next = fframe;
  92.  
  93.   dl_cmd_cur = fframe;
  94.   dl_cmd_cnt++;
  95.   return(fframe);
  96. }
  97.  
  98. /**********
  99.  *
  100.  ****/
  101. void DL_Free_Cmd_List(fframes)
  102. DL_FRAME *fframes;
  103. { DL_FRAME *ftmp;
  104.   while(fframes != 0)
  105.   { ftmp = fframes;
  106.     fframes = fframes->next;
  107.     FREE(ftmp,0x2000);
  108.   }
  109. }
  110.  
  111.  
  112. /**********
  113.  *
  114.  ****/
  115. xaULONG DL_Read_File(fname,anim_hdr)
  116. XA_ANIM_HDR *anim_hdr;
  117. char *fname;
  118. { XA_INPUT *xin = anim_hdr->xin;
  119.   xaLONG i,j,tmp;
  120.   XA_ACTION *prev_end_act;
  121.   XA_ANIM_SETUP *dl;
  122.  
  123.   dl = XA_Get_Anim_Setup();
  124.   dl->vid_time = XA_GET_TIME(100);
  125.  
  126.   dl_acts = 0; 
  127.  
  128.   dl_cmd_start = 0;
  129.   dl_cmd_cur   = 0;
  130.   dl_cmd_cnt   = 0;
  131.  
  132.   dl_ims_per_screen = 1;
  133.  
  134.   dl_version = xin->Read_U8(xin);  /* either 1 or 2 */
  135.  
  136. /* EVENTUALLY MERGE below two switches into one */
  137.   switch(dl_version)
  138.   {
  139.     case DL_VERSION_1:
  140.         dl_format = DL_FORM_MEDIUM;
  141.         dl_txt_size = 20;
  142.         break;
  143.     case DL_VERSION_2:
  144.         dl_format = xin->Read_U8(xin);
  145.         dl_txt_size = 20;
  146.         break;
  147.     case DL_VERSION_3:
  148.         dl_format = xin->Read_U8(xin);
  149.         dl_format = DL_FORM_LARGE; 
  150.         dl_txt_size = 40;
  151.         /* not really. size defined later.kludge */
  152.         break;
  153.     default:
  154.         break;
  155.   }
  156.  
  157.   switch(dl_format)
  158.   {
  159.     case DL_FORM_LARGE:
  160.     dl->imagex = DL_LARGE_XSIZE;
  161.     dl->imagey = DL_LARGE_YSIZE;
  162.     dl_ims_per_screen = 1;
  163.     break;
  164.     case DL_FORM_MEDIUM:
  165.     dl->imagex = DL_MEDIUM_XSIZE;
  166.     dl->imagey = DL_MEDIUM_YSIZE;
  167.     dl_ims_per_screen = 4;
  168.     break;
  169.     case DL_FORM_SMALL:
  170.     dl->imagex = DL_SMALL_XSIZE;
  171.     dl->imagey = DL_SMALL_YSIZE;
  172.     dl_ims_per_screen = 16;
  173.     break;
  174.     default:
  175.     fprintf(stderr,"DL_Read_File: unknown format %x\n",dl_format);
  176.     return(xaFALSE);
  177.     break;
  178.   }
  179.  
  180. /*POD TEMP UNKNOWN STUFF */
  181.   if (dl_version==DL_VERSION_3)
  182.   { int cnt;
  183.     cnt = 50;
  184.     while(cnt--) {xin->Read_U8(xin); }
  185.   }
  186.  
  187.   /********* GET TITLE ***********************/
  188.   dl_title[dl_txt_size] = 0;
  189.   for(i=0; i<dl_txt_size; i++) 
  190.   {
  191.     tmp = xin->Read_U8(xin);
  192.     dl_title[i] = (tmp)?(tmp ^ 0xff):tmp;
  193.   }
  194.  
  195.   /********* GET AUTHOR ***********************/
  196.   dl_author[0] = dl_author[dl_txt_size] = 0;
  197.   if ( (dl_version == DL_VERSION_2) || (dl_version == DL_VERSION_3) )
  198.   {
  199.     for(i=0; i< dl_txt_size; i++)
  200.     {
  201.       tmp = xin->Read_U8(xin);
  202.       dl_author[i] = (tmp)?(tmp ^ 0xff):tmp;
  203.     }
  204.   }
  205.  
  206.   if (dl_version == DL_VERSION_3)
  207.     dl_num_of_screens = xin->Read_LSB_U16(xin);
  208.   else
  209.     dl_num_of_screens = xin->Read_U8(xin);
  210.  
  211.   dl_num_of_images = dl_num_of_screens * dl_ims_per_screen;
  212.  
  213.   if (dl_version == DL_VERSION_1)
  214.      dl_num_of_frames = xin->Read_LSB_U16(xin);
  215.   else if (dl_version == DL_VERSION_2)
  216.      dl_num_of_frames = xin->Read_LSB_U32(xin);
  217.   else
  218.   { xaULONG dl_num_of_audio;
  219.     dl_num_of_frames = xin->Read_LSB_U16(xin);
  220.     dl_num_of_audio = xin->Read_LSB_U16(xin);
  221.   }
  222.      
  223.  
  224.   dl->imagec = DL_MAX_COLORS;
  225.   for(i=0; i < DL_MAX_COLORS; i++)
  226.   {
  227.     dl->cmap[i].red   = xin->Read_U8(xin) & 0x3f;
  228.     dl->cmap[i].green = xin->Read_U8(xin) & 0x3f;
  229.     dl->cmap[i].blue  = xin->Read_U8(xin) & 0x3f;
  230.   }
  231.   dl->chdr = ACT_Get_CMAP(dl->cmap,DL_MAX_COLORS,0,DL_MAX_COLORS,0,6,6,6);
  232.   
  233.  DEBUG_LEVEL1
  234.  {
  235.    fprintf(stderr,"   Version %d  Format %d",dl_version,dl_format);
  236.    fprintf(stderr," Images %d  Frames %d\n",
  237.             dl_num_of_images, dl_num_of_frames );
  238.    fprintf(stderr,"   Title = %s  Author = %s\n",dl_title,dl_author);
  239.  }
  240.  
  241.   if (dl_version != DL_VERSION_3)
  242.   {
  243.     if (dl->imagex > dl->max_imagex) dl->max_imagex = dl->imagex;
  244.     if (dl->imagey > dl->max_imagey) dl->max_imagey = dl->imagey;
  245.   }
  246.  
  247.   dl->pic_size = dl->imagex * dl->imagey;
  248.  
  249.   dl_acts = (XA_ACTION **)malloc(dl_num_of_images * sizeof(XA_ACTION *));
  250.   dl_image_cnt = 0;
  251.  
  252. /* Since dl_format is fixed per file, move this loop down and replicate*/
  253.   for(j = 0; j < dl_num_of_screens; j++)
  254.   {
  255.     switch(dl_format)
  256.     {
  257.       case DL_FORM_LARGE: /* large */
  258.     { ACT_DLTA_HDR *dlta_hdr;
  259.       XA_ACTION *act;
  260.  
  261.           if (dl_version == DL_VERSION_3)
  262.       {
  263.         dl->imagex = xin->Read_LSB_U16(xin);
  264.         dl->imagey = xin->Read_LSB_U16(xin);
  265.         if (dl->imagex > dl->max_imagex) dl->max_imagex = dl->imagex;
  266.         if (dl->imagey > dl->max_imagey) dl->max_imagey = dl->imagey;
  267.         dl->pic_size = dl->imagex * dl->imagey;
  268.         DEBUG_LEVEL1 fprintf(stderr,"DL %d) size %d %d\n",
  269.                         j,dl->imagex,dl->imagey);
  270.       }
  271.       DEBUG_LEVEL2 fprintf(stderr,"Read large format image\n");
  272.  
  273.           act = ACT_Get_Action(anim_hdr,ACT_DELTA);
  274.       dl_acts[dl_image_cnt] = act;  dl_image_cnt++;
  275.  
  276.       dlta_hdr = DL_Get_Dlta_HDR(xin,dl->pic_size,act,
  277.                     dl->imagex,dl->imagey,0,xaTRUE);
  278.       if (dlta_hdr==0) return(xaFALSE);
  279.           /* xin->Seek_FPos(xin,dl->pic_size,1); */  /* skip over image */
  280.       if (dl->pic_size > dl->max_fvid_size)
  281.                     dl->max_fvid_size = dl->pic_size;
  282.       dl->pic = 0;
  283.       ACT_Setup_Delta(dl,act,dlta_hdr,xin);
  284.     }
  285.     break;
  286.  
  287.       case DL_FORM_MEDIUM: /* medium */
  288.       case DL_FORM_SMALL:  /* small */
  289.     { xaULONG r,rows,off,small_flag = (dl_format == DL_FORM_SMALL)?(1):(0);
  290.  
  291.       rows = (small_flag)?(4):(2);
  292.       off = rows - 1;
  293.  
  294.       DEBUG_LEVEL2 fprintf(stderr,"Read small/medium image\n");
  295.  
  296.       r = rows;
  297.           while(r--)
  298.       { ACT_DLTA_HDR *d_hdr0,*d_hdr1,*d_hdr2,*d_hdr3;
  299.         XA_ACTION    *act0,*act1,*act2,*act3;
  300.         xaULONG s_size = rows * dl->imagex * dl->imagey;
  301.  
  302.         /*** dlta_hdr for image0 */
  303.         act0 = ACT_Get_Action(anim_hdr,ACT_DELTA);
  304.         dl_acts[dl_image_cnt] = act0;  dl_image_cnt++;
  305.         act1 = ACT_Get_Action(anim_hdr,ACT_DELTA);
  306.         dl_acts[dl_image_cnt] = act1;  dl_image_cnt++;
  307.         if (small_flag)
  308.         {
  309.           act2 = ACT_Get_Action(anim_hdr,ACT_DELTA);
  310.           dl_acts[dl_image_cnt] = act2;  dl_image_cnt++;
  311.           act3 = ACT_Get_Action(anim_hdr,ACT_DELTA);
  312.           dl_acts[dl_image_cnt] = act3;  dl_image_cnt++;
  313.         }
  314.  
  315.         if (xin->load_flag & XA_IN_LOAD_FILE)
  316.         { if (s_size > dl->max_fvid_size) dl->max_fvid_size = s_size;
  317.           d_hdr0 = DL_Get_Dlta_HDR(xin,s_size,act0,
  318.                     dl->imagex,dl->imagey,off,xaFALSE);
  319.           if (d_hdr0 == 0) return(xaFALSE);
  320.           xin->Seek_FPos(xin,dl->imagex,1); s_size -= dl->imagex;
  321.           d_hdr1 = DL_Get_Dlta_HDR(xin,s_size,act1,
  322.                     dl->imagex,dl->imagey,off,xaFALSE);
  323.           if (d_hdr1 == 0) return(xaFALSE);
  324.           if (small_flag)
  325.           {
  326.             xin->Seek_FPos(xin,dl->imagex,1); s_size -= dl->imagex;
  327.             d_hdr2 = DL_Get_Dlta_HDR(xin,s_size,act2,
  328.                     dl->imagex,dl->imagey,off,xaFALSE);
  329.             if (d_hdr2 == 0) return(xaFALSE);
  330.             xin->Seek_FPos(xin,dl->imagex,1); s_size -= dl->imagex;
  331.             d_hdr3 = DL_Get_Dlta_HDR(xin,s_size,act3,
  332.                     dl->imagex,dl->imagey,off,xaFALSE);
  333.             if (d_hdr3 == 0) return(xaFALSE);
  334.           }
  335.           xin->Seek_FPos(xin,s_size,1);
  336.         }
  337.         else
  338.         { xaULONG y = dl->imagey;
  339.           xaUBYTE *dp0,*dp1,*dp2,*dp3;
  340.  
  341.           d_hdr0 = DL_Get_Dlta_HDR(xin,dl->pic_size,act0,
  342.                     dl->imagex,dl->imagey,0,xaFALSE);
  343.           if (d_hdr0 == 0) return(xaFALSE);
  344.           dp0 = d_hdr0->data;    
  345.  
  346.           d_hdr1 = DL_Get_Dlta_HDR(xin,dl->pic_size,act1,
  347.                     dl->imagex,dl->imagey,0,xaFALSE);
  348.           if (d_hdr1 == 0) return(xaFALSE);
  349.           dp1 = d_hdr1->data;
  350.  
  351.           if (small_flag)
  352.           { 
  353.         d_hdr2 = DL_Get_Dlta_HDR(xin,dl->pic_size,act2,
  354.                     dl->imagex,dl->imagey,0,xaFALSE);
  355.         if (d_hdr2 == 0) return(xaFALSE);
  356.         dp2 = d_hdr2->data;
  357.  
  358.         d_hdr3 = DL_Get_Dlta_HDR(xin,dl->pic_size,act3,
  359.                     dl->imagex,dl->imagey,0,xaFALSE);
  360.         if (d_hdr3 == 0) return(xaFALSE);
  361.         dp3 = d_hdr3->data; 
  362.           }
  363.           while(y--)
  364.           { xin->Read_Block(xin,(char *)(dp0),dl->imagex); dp0 += dl->imagex;
  365.         xin->Read_Block(xin,(char *)(dp1),dl->imagex); dp1 += dl->imagex;
  366.         if (small_flag)
  367.             { xin->Read_Block(xin,(char *)(dp2),dl->imagex); dp2 += dl->imagex;
  368.           xin->Read_Block(xin,(char *)(dp3),dl->imagex); dp3 += dl->imagex;
  369.             }
  370.           }
  371.         }
  372.  
  373.         dl->pic = 0;    ACT_Setup_Delta(dl,act0,d_hdr0,xin);
  374.         dl->pic = 0;    ACT_Setup_Delta(dl,act1,d_hdr1,xin);
  375.         if (small_flag)
  376.         {
  377.           dl->pic = 0;    ACT_Setup_Delta(dl,act2,d_hdr2,xin);
  378.           dl->pic = 0;    ACT_Setup_Delta(dl,act3,d_hdr3,xin);
  379.         }
  380.       } /* end of rows */
  381.     } /* end of case */
  382.     break;
  383.    }
  384.  }
  385.  
  386.  if (xa_verbose == xaTRUE)
  387.  {
  388.    fprintf(stderr,"   Version %d  Format %d",dl_version,dl_format);
  389.    fprintf(stderr," Images %d  Frames %d\n",
  390.             dl_num_of_images, dl_num_of_frames );
  391.    fprintf(stderr,"   Title = %s  Author = %s\n",dl_title,dl_author);
  392.  }
  393.  
  394.  prev_end_act = 0;
  395.  dl_loop_frame = 0;
  396.  dl_frame_cnt = 0;
  397.  switch(dl_version)
  398.  {
  399.    case DL_VERSION_1:
  400.     for(i=0; i < dl_num_of_frames; i++)
  401.     { DL_FRAME *dl_fm;
  402.       register xaULONG tmp;
  403.       tmp = xin->Read_U8(xin);
  404.       tmp = (tmp % 10) - 1 + ((tmp / 10) - 1) * 4;
  405.  
  406.       if (tmp < dl_image_cnt)
  407.       {
  408.         dl_fm = DL_Add_Cmd(tmp,dl->vid_time,dl->vid_timelo);
  409.         dl_fm->act = dl_acts[tmp];
  410.         dl_frame_cnt++;
  411.       }
  412.       else fprintf(stderr,"   unknown code - ignored. %x\n",tmp);
  413.     }
  414.     break;
  415.    case DL_VERSION_3: /* POD TEMP FOR NOW */
  416.    case DL_VERSION_2:
  417.     { DL_FRAME *dl_fm,*dl_endloop;
  418.           xaULONG dl_ffea_xpos,dl_ffea_ypos;
  419.           dl_ffea_xpos = dl_ffea_ypos = 0;
  420.       DEBUG_LEVEL2 fprintf(stderr," DL reading frame lst: ");
  421.       dl_endloop = 0;
  422.       i = 0;
  423.       while(i < dl_num_of_frames)
  424.       { register xaULONG tmp;
  425.         tmp  =  xin->Read_U8(xin); tmp |=  ( xin->Read_U8(xin) << 8); i++;
  426.         DEBUG_LEVEL2 fprintf(stderr,"\t<%d %x>",i,tmp);
  427.  
  428.         if (tmp & 0x8000)
  429.         {
  430.           switch(tmp)
  431.           {
  432.         case 0xffff:
  433.           { xaULONG cnt;
  434.             cnt  =  xin->Read_LSB_U16(xin); i++;
  435.             DEBUG_LEVEL1 fprintf(stderr,"DL: begin loop %d\n",cnt);
  436.             if (cnt > 20) cnt = 20; /* POD NOTE: ARBITRARY */
  437.             dl_fm = DL_Add_Cmd(0xffff,0,0);
  438.             dl_fm->cnt = cnt;
  439.             /* add to prev loop chain */
  440.             dl_fm->prev_loop = dl_endloop;
  441.             dl_endloop = dl_fm;
  442.           }
  443.           break;
  444.         case 0xfffe:
  445.           { DL_FRAME *loop_start = dl_endloop;
  446.             if (loop_start)
  447.             { dl_fm = DL_Add_Cmd(0xfffe,0,0);
  448.               loop_start->loop = dl_fm;
  449.               dl_fm->loop = loop_start;
  450.               dl_endloop = loop_start->prev_loop;
  451.               DEBUG_LEVEL1 fprintf(stderr,"DL: end loop\n");
  452.             }
  453.             else fprintf(stderr,"DL: invalid end loop\n");
  454.           }
  455.           break;
  456.         case 0xFFFD:
  457.           tmp  =  xin->Read_LSB_U16(xin); i++;
  458.           DEBUG_LEVEL1 fprintf(stderr,"DL: key press %x\n",tmp);
  459.           break;
  460.         default: 
  461.           fprintf(stderr,"DL: unk code %x\n",tmp);
  462.           break;
  463.           }
  464.         }
  465.         else /* code is below 8000 */
  466.         {
  467.           if (tmp < dl_image_cnt)
  468.           {
  469. /* NOTE YET DL 3.0 only 
  470.             if ( (dl_ffea_xpos) || (dl_ffea_ypos) )
  471.         else
  472. */
  473.         DEBUG_LEVEL1 fprintf(stderr,"DL: image %d\n",tmp);
  474.         dl_fm = DL_Add_Cmd(tmp,dl->vid_time,dl->vid_timelo);
  475.         dl_fm->act = dl_acts[tmp];
  476.             dl_frame_cnt++;
  477.           }
  478.           else fprintf(stderr,"   unknown code - ignored. %x\n",tmp);
  479.         }
  480.       }
  481.       DEBUG_LEVEL2 fprintf(stderr,"\n");
  482.       if (dl_loop_frame >= dl_frame_cnt) dl_loop_frame = 0;
  483.     }
  484.     break;
  485.   }
  486.   xin->Close_File(xin);
  487.  
  488. DEBUG_LEVEL1 fprintf(stderr,"OLD: dl_frame_cnt %d\n",dl_frame_cnt);
  489. dl_frame_cnt = DL_Cnt_Cmds();
  490. DEBUG_LEVEL1 fprintf(stderr,"NEW: dl_frame_cnt %d\n",dl_frame_cnt);
  491.  
  492.   anim_hdr->frame_lst = 
  493.     (XA_FRAME *)malloc(sizeof(XA_FRAME) * (dl_frame_cnt + 1) ); 
  494.   if (anim_hdr->frame_lst == NULL)
  495.       TheEnd1("DL_ANIM: couldn't malloc for frame_lst\0");
  496.  
  497.   dl_frame_cnt = DL_Gen_Frame_List(anim_hdr->frame_lst,dl_frame_cnt);
  498.  
  499.   anim_hdr->frame_lst[dl_frame_cnt].time_dur = 0;
  500.   anim_hdr->frame_lst[dl_frame_cnt].zztime = 0;
  501.   anim_hdr->frame_lst[dl_frame_cnt].act  = 0;
  502.   if (dl_frame_cnt > 0)
  503.   {
  504.     anim_hdr->last_frame = dl_frame_cnt-1;
  505.     anim_hdr->total_time =  anim_hdr->frame_lst[dl_frame_cnt-1].zztime
  506.               + anim_hdr->frame_lst[dl_frame_cnt-1].time_dur;
  507.   }
  508.   else
  509.   {
  510.     anim_hdr->last_frame = 0;
  511.     anim_hdr->total_time = 0;
  512.   }
  513.   if (!(xin->load_flag & XA_IN_LOAD_BUF)) anim_hdr->anim_flags |= ANIM_SNG_BUF;
  514.   if (xin->load_flag & XA_IN_LOAD_FILE)  anim_hdr->anim_flags |= ANIM_USE_FILE;
  515.   anim_hdr->anim_flags |= ANIM_FULL_IM; /* always full image - until V3 */
  516.   anim_hdr->loop_frame = dl_loop_frame;
  517.   anim_hdr->imagex = dl->max_imagex;
  518.   anim_hdr->imagey = dl->max_imagey;
  519.   anim_hdr->imagec = dl->imagec;
  520.   anim_hdr->imaged = 8; /* nop */
  521.   anim_hdr->max_fvid_size = dl->max_fvid_size;
  522.   anim_hdr->max_faud_size = 0;
  523.   anim_hdr->fname = anim_hdr->name;
  524.   
  525.   DL_Free_Cmd_List(dl_cmd_start);
  526.   FREE(dl_acts,0x5001); dl_acts=0;
  527.   XA_Free_Anim_Setup(dl);
  528.   return(xaTRUE);
  529. }
  530.  
  531. xaULONG DL_Cnt_Cmds()
  532. { xaULONG cnt = 0;
  533.   DL_FRAME *fm_next,*fm = dl_cmd_start;
  534.  
  535.   while(fm)
  536.   {
  537.     fm_next = fm->next;
  538.     if (fm->act) cnt++;
  539.     else
  540.     {
  541.        switch(fm->type)
  542.        {
  543.          case 0xffff:
  544.         fm->dat0 = fm->cnt;
  545. DEBUG_LEVEL1 { fprintf(stderr,"BEGIN: dat0 <= %d\n",fm->cnt); }
  546.         break;
  547.          case 0xfffe:
  548.         { DL_FRAME *lp = fm->loop;
  549.           lp->dat0--;
  550. DEBUG_LEVEL1 { fprintf(stderr,"END: dat0 = %d\n",lp->dat0); }
  551.           if (lp->dat0 > 0) fm_next = lp->next;
  552.         }
  553.         break;
  554.          default: 
  555.         fprintf(stderr,"DL_Cnt_Cmds: def err %x\n",fm->type);
  556.         break;
  557.       
  558.        }
  559.     } 
  560.     fm = fm_next;
  561.   }
  562.   return(cnt);
  563. }
  564.  
  565. xaULONG DL_Gen_Frame_List(frame_lst,frame_cnt)
  566. XA_FRAME *frame_lst;
  567. xaLONG frame_cnt;
  568. { DL_FRAME *fm_next,*fm = dl_cmd_start;
  569.   xaULONG i,t_time,t_timelo;
  570.   t_time = t_timelo = 0;
  571.  
  572.   i = 0;
  573.   while(fm && (i < frame_cnt) )
  574.   {
  575.     fm_next = fm->next;
  576.     if (fm->act)
  577.     {
  578.       frame_lst[i].act        = fm->act;
  579.       frame_lst[i].time_dur   = fm->time;
  580.       frame_lst[i].zztime     = t_time;
  581.       t_time += fm->time;
  582.       t_timelo += fm->timelo;
  583.       while(t_timelo > (1<<24)) {t_time++; t_timelo -= (1<<24);}
  584.  
  585. DEBUG_LEVEL3 fprintf(stderr,"frame list %d) type = %x act = %x\n",
  586.         i,fm->type,(xaULONG)frame_lst[i].act);
  587.       i++;
  588.     }
  589.     else
  590.     {
  591.        switch(fm->type)
  592.        {
  593.          case 0xffff:
  594.         fm->dat0 = fm->cnt;
  595.         break;
  596.          case 0xfffe:
  597.         { DL_FRAME *lp = fm->loop;
  598.           lp->dat0--;
  599.           if (lp->dat0 > 0) fm_next = lp->next;
  600.         }
  601.         break;
  602.          default: fprintf(stderr,"DL_Cnt_Cmds: def err %x\n",fm->type);
  603.       
  604.        }
  605.     }
  606.     fm = fm_next;
  607.   }
  608.   return(i);
  609. }
  610.  
  611. ACT_DLTA_HDR *DL_Get_Dlta_HDR(xin,fsize,act,imx,imy,extra,rd_flag)
  612. XA_INPUT *xin;
  613. xaULONG fsize;
  614. XA_ACTION *act;
  615. xaULONG imx,imy,extra;
  616. xaULONG rd_flag;
  617. { ACT_DLTA_HDR *dlta_hdr;
  618.   if (xin->load_flag & XA_IN_LOAD_FILE)
  619.   {
  620.     dlta_hdr = (ACT_DLTA_HDR *) malloc(sizeof(ACT_DLTA_HDR));
  621.     if (dlta_hdr == 0) TheEnd1("DL dlta: malloc err0");
  622.     act->data = (xaUBYTE *)dlta_hdr;
  623.     dlta_hdr->flags = ACT_SNGL_BUF;
  624.     dlta_hdr->fpos  = xin->Get_FPos(xin);
  625.     dlta_hdr->fsize = fsize;
  626.   }
  627.   else
  628.   { xaULONG d = fsize + (sizeof(ACT_DLTA_HDR));
  629.     dlta_hdr = (ACT_DLTA_HDR *) malloc( d );
  630.     if (dlta_hdr == 0) TheEnd1("DL dlta: malloc err1");
  631.     act->data = (xaUBYTE *)dlta_hdr;
  632.     dlta_hdr->flags = ACT_SNGL_BUF | DLTA_DATA;
  633.     dlta_hdr->fpos  = 0;
  634.     dlta_hdr->fsize = fsize;
  635.     if (rd_flag == xaTRUE)
  636.     { xaLONG ret;    /* POD fpos = xin->Get_FPos(xin); */
  637.       ret = xin->Read_Block(xin,dlta_hdr->data, fsize);
  638.       if (ret < fsize) {fprintf(stderr,"DL dlta: read err\n"); return(0);}
  639.       /* xin->Seek_FPos(xin,fpos,0); */
  640.     }
  641.   }
  642.   dlta_hdr->xpos = dlta_hdr->ypos = 0;
  643.   dlta_hdr->xsize = imx;
  644.   dlta_hdr->ysize = imy;
  645.   dlta_hdr->extra = (void *)(extra);
  646.   dlta_hdr->special = 0;
  647.   dlta_hdr->xapi_rev = 0x0001;
  648.   dlta_hdr->delta = DL_Decode_Image;
  649.   return(dlta_hdr);
  650. }
  651.  
  652.  
  653. xaULONG
  654. DL_Decode_Image(image,delta,dsize,dec_info)
  655. xaUBYTE *image;         /* Image Buffer. */
  656. xaUBYTE *delta;         /* delta data. */
  657. xaULONG dsize;          /* delta size */
  658. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  659. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  660.   xaULONG map_flag = dec_info->map_flag;        xaULONG *map = dec_info->map;
  661.   void *extra = dec_info->extra;
  662.   xaUBYTE *dp = delta;
  663.   xaULONG skip_lines = imagex * ((xaULONG)(extra));
  664.   xaULONG x, y = imagey;
  665.  
  666.   if (map_flag==xaFALSE) 
  667.   { xaUBYTE *ip = (xaUBYTE *)image; 
  668.     while(y--) { x = imagex; while(x--) { *ip++ = (xaUBYTE)(*dp++); }
  669.     dp += skip_lines; }
  670.   }
  671.   else if (x11_bytes_pixel==1) 
  672.   { xaUBYTE *ip = (xaUBYTE *)image; 
  673.     while(y--) 
  674.     { x = imagex; while(x--) { *ip++ = (xaUBYTE)map[*dp++]; } 
  675.     dp += skip_lines; }
  676.   }
  677.   else if (x11_bytes_pixel==2) 
  678.   { xaUSHORT *ip = (xaUSHORT *)image; 
  679.     while(y--) 
  680.     { x = imagex; while(x--) { *ip++ = (xaUSHORT)map[*dp++]; }
  681.     dp += skip_lines; }
  682.   }
  683.   else /* if (x11_bytes_pixel==4) */
  684.   { xaULONG *ip = (xaULONG *)image; 
  685.     while(y--) 
  686.     { x = imagex; while(x--) { *ip++ = (xaULONG)map[*dp++]; }
  687.     dp += skip_lines; }
  688.   }
  689.   dec_info->xs = dec_info->ys = 0; dec_info->xe = imagex; dec_info->ye = imagey;
  690.   if (map_flag==xaTRUE) return(ACT_DLTA_MAPD);
  691.   else return(ACT_DLTA_NORM);
  692. }
  693.  
  694.  
  695.