home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_replay.c < prev    next >
C/C++ Source or Header  |  1997-01-26  |  31KB  |  985 lines
  1.  
  2. /*
  3.  * xa_replay.c
  4.  *
  5.  * Copyright (C) 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. /*******************************
  20.  * Revision
  21.  *
  22.  *
  23.  ********************************/
  24.  
  25.  
  26. #include "xa_replay.h" 
  27.  
  28. xaULONG ARM_Read_File();
  29. ARM_FRAME *ARM_Add_Frame();
  30. void ARM_Free_Frame_List();
  31. void ACT_Setup_Delta();
  32. xaULONG ARM_Read_Header();
  33. xaULONG ARM_Read_Index();
  34. void ARM_Read_Frame();
  35. xaULONG ARM_Get_Length();
  36.  
  37. void ARM_Free_Stuff();
  38. void ARM_Init_Tables();
  39.  
  40.  
  41. xaULONG ARM_Decode_MLINES();
  42.  
  43.  
  44. /* CODEC ROUTINES */
  45. extern void yuv_to_rgb();
  46. extern void XA_Gen_YUV_Tabs();
  47. extern xaULONG XA_RGB24_To_CLR32();
  48.  
  49. void CMAP_Cache_Clear();
  50. void CMAP_Cache_Init();
  51.  
  52. XA_ACTION *ACT_Get_Action();
  53. XA_CHDR *ACT_Get_CMAP();
  54. XA_CHDR *CMAP_Create_332();
  55. XA_CHDR *CMAP_Create_422();
  56. XA_CHDR *CMAP_Create_Gray();
  57. void ACT_Add_CHDR_To_Action();
  58. void ACT_Setup_Mapped();
  59. void ACT_Get_CCMAP();
  60. XA_CHDR *CMAP_Create_CHDR_From_True();
  61. xaULONG CMAP_Find_Closest();
  62. xaUBYTE *UTIL_RGB_To_FS_Map();
  63. xaUBYTE *UTIL_RGB_To_Map();
  64.  
  65. void  UTIL_FPS_2_Time();
  66. extern XA_ANIM_SETUP *XA_Get_Anim_Setup();
  67. extern XA_Add_Func_To_Free_Chain();
  68. void XA_Free_Anim_Setup();
  69. extern xaULONG XA_find_str();
  70.  
  71. xaUBYTE *ARM_prev_buff = 0;
  72. xaULONG ARM_prev_buff_size = 0;
  73. xaLONG *ARM_MOVL_X = 0;
  74. xaLONG *ARM_MOVL_Y = 0;
  75.  
  76. xaULONG arm_audio_attempt;
  77. xaULONG arm_audio_type;
  78. xaULONG arm_audio_freq;
  79. xaULONG arm_audio_chans;
  80. xaULONG arm_audio_bps;
  81. xaULONG XA_Add_Sound();
  82.  
  83.  
  84. xaULONG arm_frame_cnt;
  85. ARM_FRAME *arm_frame_start,*arm_frame_cur;
  86.  
  87. ARM_FRAME *ARM_Add_Frame(time,timelo,act)
  88. xaULONG time,timelo;
  89. XA_ACTION *act;
  90. {
  91.   ARM_FRAME *fframe;
  92.  
  93.   fframe = (ARM_FRAME *) malloc(sizeof(ARM_FRAME));
  94.   if (fframe == 0) TheEnd1("ARM_Add_Frame: malloc err");
  95.  
  96.   fframe->time   = time;
  97.   fframe->timelo = timelo;
  98.   fframe->act = act;
  99.   fframe->next = 0;
  100.  
  101.   if (arm_frame_start == 0) arm_frame_start = fframe;
  102.   else arm_frame_cur->next = fframe;
  103.  
  104.   arm_frame_cur = fframe;
  105.   arm_frame_cnt++;
  106.   return(fframe);
  107. }
  108.  
  109. void ARM_Free_Frame_List(fframes)
  110. ARM_FRAME *fframes;
  111. {
  112.   ARM_FRAME *ftmp;
  113.   while(fframes != 0)
  114.   {
  115.     ftmp = fframes;
  116.     fframes = fframes->next;
  117.     FREE(ftmp,0xA000);
  118.   }
  119. }
  120.  
  121.  
  122. xaULONG ARM_Read_File(fname,anim_hdr,audio_attempt)
  123. char *fname;
  124. XA_ANIM_HDR *anim_hdr;
  125. xaULONG audio_attempt;    /* xaTRUE if audio is to be attempted */
  126. { XA_INPUT *xin = anim_hdr->xin;
  127.   xaLONG i,t_time;
  128.   xaULONG t_timelo;
  129.   XA_ANIM_SETUP *arm;
  130.   ARM_HDR   arm_hdr;
  131.  
  132.  
  133.   arm = XA_Get_Anim_Setup();
  134.   arm->vid_time = XA_GET_TIME( 100 ); /* default */
  135.  
  136.   arm_frame_cnt        = 0;
  137.   arm_frame_start    = 0;
  138.   arm_frame_cur        = 0;
  139.   arm_audio_attempt    = audio_attempt;
  140.  
  141.  
  142.   if (ARM_Read_Header(anim_hdr,xin,arm,&arm_hdr) == xaFALSE)
  143.   {
  144.     fprintf(stderr,"ARM: read header error\n");
  145.     xin->Close_File(xin);
  146.     return(xaFALSE);
  147.   }
  148.  
  149.   if (ARM_Read_Index(xin,anim_hdr,arm,&arm_hdr)==xaFALSE) return(xaFALSE);
  150.  
  151.   if (xa_verbose) 
  152.   {
  153.     fprintf(stderr,"ARM %dx%dx%d frames %d\n",
  154.         arm->imagex,arm->imagey,arm->imagec,arm_frame_cnt);
  155.   }
  156.   if (arm_frame_cnt == 0)
  157.   { 
  158.     fprintf(stderr,"ARM: No supported video frames exist in this file.\n");
  159.     return(xaFALSE);
  160.   }
  161.  
  162.   anim_hdr->frame_lst = (XA_FRAME *)
  163.                 malloc( sizeof(XA_FRAME) * (arm_frame_cnt+1));
  164.   if (anim_hdr->frame_lst == NULL) TheEnd1("ARM_Read_File: frame malloc err");
  165.  
  166.   arm_frame_cur = arm_frame_start;
  167.   i = 0;
  168.   t_time = 0;
  169.   t_timelo = 0;
  170.   while(arm_frame_cur != 0)
  171.   {
  172.     if (i > arm_frame_cnt)
  173.     {
  174.       fprintf(stderr,"ARM_Read_Anim: frame inconsistency %d %d\n",
  175.                 i,arm_frame_cnt);
  176.       break;
  177.     }
  178.     anim_hdr->frame_lst[i].time_dur = arm_frame_cur->time;
  179.     anim_hdr->frame_lst[i].zztime = t_time;
  180.     t_time += arm_frame_cur->time;
  181.     t_timelo += arm_frame_cur->timelo;
  182.     while(t_timelo > (1<<24)) {t_time++; t_timelo -= (1<<24);}
  183.     anim_hdr->frame_lst[i].act = arm_frame_cur->act;
  184.     arm_frame_cur = arm_frame_cur->next;
  185.     i++;
  186.   }
  187.   anim_hdr->imagex = arm->imagex;
  188.   anim_hdr->imagey = arm->imagey;
  189.   anim_hdr->imagec = arm->imagec;
  190.   anim_hdr->imaged = 8; /* nop */
  191.   anim_hdr->frame_lst[i].time_dur = 0;
  192.   anim_hdr->frame_lst[i].zztime = -1;
  193.   anim_hdr->frame_lst[i].act  = 0;
  194.   anim_hdr->loop_frame = 0;
  195.   if (!(xin->load_flag & XA_IN_LOAD_BUF)) anim_hdr->anim_flags |= ANIM_SNG_BUF;
  196.   if (xin->load_flag & XA_IN_LOAD_FILE) anim_hdr->anim_flags |= ANIM_USE_FILE;
  197.   anim_hdr->anim_flags |= ANIM_FULL_IM;
  198.   anim_hdr->max_fvid_size = arm->max_fvid_size;
  199.   anim_hdr->max_faud_size = arm->max_faud_size;
  200.   anim_hdr->fname = anim_hdr->name;
  201.   if (i > 0) 
  202.   {
  203.     anim_hdr->last_frame = i - 1;
  204.     anim_hdr->total_time = anim_hdr->frame_lst[i-1].zztime
  205.                 + anim_hdr->frame_lst[i-1].time_dur;
  206.   }
  207.   else
  208.   {
  209.     anim_hdr->last_frame = 0;
  210.     anim_hdr->total_time = 0;
  211.   }
  212.   ARM_Free_Frame_List(arm_frame_start);
  213.   XA_Free_Anim_Setup(arm);
  214.   return(xaTRUE);
  215. } /* end of read file */
  216.  
  217.  
  218. #define ARM_MAX_LINE 256
  219. char arm_line[ARM_MAX_LINE];
  220.  
  221. xaULONG ARM_Read_Line(xin,ptr)
  222. XA_INPUT *xin;
  223. char *ptr;
  224. { int i = 0;
  225.   while( !xin->At_EOF(xin,-1) )
  226.   { int d = xin->Read_U8(xin);
  227.     if (d >= 0)
  228.     { ptr[i] = d; i++;
  229.       if (i  >= ARM_MAX_LINE) return(xaFALSE);
  230.       if ( (d == 0x0a) || (d == 0x0d) ) 
  231.     { ptr[i] = 0; 
  232.       DEBUG_LEVEL1 fprintf(stderr,"LINE: %s",ptr);
  233.           return(xaTRUE); 
  234.     }
  235.     }
  236.     else return(xaFALSE); 
  237.   }
  238.   return(xaFALSE);
  239. }
  240.  
  241. xaULONG ARM_Read_Header(anim_hdr,xin,arm,arm_hdr)
  242. XA_ANIM_HDR *anim_hdr;
  243. XA_INPUT *xin;
  244. XA_ANIM_SETUP *arm;
  245. ARM_HDR *arm_hdr;
  246. { double tmpf;
  247.  
  248.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* ARMovie */
  249.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* name */
  250.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* date/copyright */
  251.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* author/etc */
  252.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* video format */
  253.   if (arm_line[0] == '1') arm_hdr->vid_codec = ARM_VIDEO_MOVL_RGB;
  254.   else
  255.   { fprintf(stderr,"ARM: Unsupported Video Type: %s,",arm_line);
  256.     arm_hdr->vid_codec = ARM_VIDEO_UNK;
  257.   }
  258.  
  259.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);    /* width */
  260.     tmpf = atof(arm_line);  arm_hdr->width     = (xaLONG)tmpf;
  261.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);    /* height */
  262.     tmpf = atof(arm_line);  arm_hdr->height    = (xaLONG)tmpf;
  263.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);    /* depth */
  264.     tmpf = atof(arm_line);  arm_hdr->depth    = (xaLONG)tmpf;
  265.  
  266. /* Check Video Precision Line for modifiers */
  267.     if (arm_hdr->vid_codec == ARM_VIDEO_MOVL_RGB)
  268.     {
  269.        if (   (XA_find_str(arm_line,"yuv") == xaTRUE) 
  270.            || (XA_find_str(arm_line,"YUV") == xaTRUE) )
  271.         arm_hdr->vid_codec = ARM_VIDEO_MOVL_YUV;
  272.     }
  273.  
  274.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);    /* fps */
  275.     arm_hdr->fps = atof(arm_line);
  276.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /*audio format */
  277.     if (arm_audio_attempt == xaTRUE)
  278.     {
  279.       if (arm_line[0] == '0') 
  280.       {
  281.     arm_hdr->aud_codec = ARM_AUDIO_NONE;
  282.     arm_audio_attempt = xaFALSE;
  283.       }
  284.       else if (arm_line[0] == '1') 
  285.       { 
  286.     arm_hdr->aud_codec = ARM_AUDIO_FORM1;
  287.       }
  288.       else
  289.       { 
  290.     fprintf(stderr,"ARM: Unsupported Audio Type: %s\n",arm_line);
  291.     arm_hdr->aud_codec = ARM_AUDIO_UNK;
  292.     arm_audio_attempt = xaFALSE;
  293.       }
  294.     }
  295.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* audio freq */
  296.      /* NOTE: this can be fraction HZ - eventually support this or us */
  297.     tmpf = atof(arm_line);
  298.     { static unsigned char us[3] = { 0xB5, 0x73, 0x00 };
  299.       if (XA_find_str(arm_line,us)==xaTRUE)
  300.       { double freq = (1000000.0 / tmpf) + 0.5;
  301.         arm_hdr->aud_freq = (xaLONG)freq;
  302.       }
  303.       else arm_hdr->aud_freq = (xaLONG)tmpf;
  304.     }
  305.      
  306.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* audio chans */
  307.     tmpf = atof(arm_line);  arm_hdr->aud_chans    = (xaLONG)tmpf;
  308.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);  /* audio prec */
  309.     tmpf = atof(arm_line);  arm_hdr->aud_prec    = (xaLONG)tmpf;
  310.  
  311.     /* Check Audio Precision Line for modifiers */
  312.     if (arm_audio_attempt == xaTRUE)
  313.     {
  314.       arm_audio_freq  = arm_hdr->aud_freq;
  315.       arm_audio_chans = arm_hdr->aud_chans;
  316.       if (arm_hdr->aud_prec == 8) arm_audio_bps = 1;
  317.       else if (arm_hdr->aud_prec == 16) arm_audio_bps = 2;
  318.       else arm_audio_bps = 0;
  319.       if ( XA_find_str(arm_line,"linear") == xaTRUE) 
  320.       {
  321.         if (xa_verbose==xaTRUE) 
  322.         fprintf(stderr,"AUDIO: Signed %dHz chans: %d  bits: %d\n",
  323.             arm_audio_freq,arm_audio_chans,arm_hdr->aud_prec);
  324.         arm_audio_type = XA_AUDIO_SIGNED;  /* NOTE: little endian */
  325.       } 
  326.       else if ( XA_find_str(arm_line,"logarithmic") == xaTRUE) 
  327.       {
  328.         if (xa_verbose==xaTRUE) 
  329.         fprintf(stderr,"AUDIO: LOGARITHMIC %dHz chans: %d bits: %d\n",
  330.             arm_audio_freq,arm_audio_chans,arm_hdr->aud_prec);
  331.         arm_audio_type = XA_AUDIO_ARMLAW;  /* NOTE: little endian */
  332.       } 
  333.       else arm_audio_type = XA_AUDIO_INVALID;
  334.       /* paranoia */
  335.       if ( (arm_audio_chans > 2) || (arm_audio_chans == 0) )
  336.                     arm_audio_type = XA_AUDIO_INVALID;
  337.       if ( (arm_audio_bps > 2) || (arm_audio_bps == 0) )
  338.                     arm_audio_type = XA_AUDIO_INVALID;
  339.  
  340.       /* warning and final modifications */
  341.       if (arm_audio_type == XA_AUDIO_INVALID)
  342.       {
  343.         if (arm_audio_attempt == xaTRUE) 
  344.       fprintf(stderr,"ARM: Audio Type unsupported %d \n",
  345.                         arm_hdr->aud_codec);
  346.         arm_audio_attempt = xaFALSE;
  347.       }
  348.       else
  349.       {
  350.         if (arm_audio_chans == 2) arm_audio_type |= XA_AUDIO_STEREO_MSK;
  351.         if (arm_audio_bps == 2) arm_audio_type |= XA_AUDIO_BPS_2_MSK;
  352.       }
  353.     }
  354.  
  355.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE);/*frames perchnk*/
  356.     tmpf = atof(arm_line);  arm_hdr->fp_chunk    = (xaLONG)tmpf;
  357.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /* chunk cnt */
  358.     tmpf = atof(arm_line);  arm_hdr->chunk_cnt    = (xaLONG)tmpf;
  359.  
  360.     /* This is necessary so +CF4 will function correctly */
  361.     arm->cmap_frame_num  = (arm_hdr->chunk_cnt * arm_hdr->fp_chunk) 
  362.                             / cmap_sample_cnt;
  363.  
  364.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /*ev chunk sz */
  365.     tmpf = atof(arm_line);  arm_hdr->ev_chk_size    = (xaLONG)tmpf;
  366.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /*od chunk sz */
  367.     tmpf = atof(arm_line);  arm_hdr->od_chk_size    = (xaLONG)tmpf;
  368.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /* idx offset */
  369.     tmpf = atof(arm_line);  arm_hdr->idx_offset    = (xaLONG)tmpf;
  370.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /*sprite offset*/
  371.     tmpf = atof(arm_line);  arm_hdr->sprite_off    = (xaLONG)tmpf;
  372.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /*sprite size*/
  373.     tmpf = atof(arm_line);  arm_hdr->sprite_size = (xaLONG)tmpf;
  374.   if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /*key  offset */
  375.     tmpf = atof(arm_line);  arm_hdr->key_offset    = (xaLONG)tmpf;
  376.   
  377.  
  378.   UTIL_FPS_2_Time(arm, arm_hdr->fps );
  379.  
  380. /*
  381.   switch(arm_hdr->aud_codec)
  382.   {
  383.   }
  384. */
  385.  
  386.   arm->depth  = arm_hdr->depth;
  387.   arm->imagex = arm_hdr->width;
  388.   arm->imagey = arm_hdr->height;
  389.   XA_Gen_YUV_Tabs(anim_hdr);
  390.   ARM_Init_Tables(anim_hdr,arm->imagex,arm->imagey);
  391.  
  392. if (xa_verbose)
  393. {
  394.   fprintf(stderr,"ARM: %dx%dx%x\n",arm->imagex,arm->imagey,arm->depth);
  395. }
  396.  
  397.   if (   (cmap_true_map_flag == xaFALSE) /* depth 16 and not true_map */
  398.       || (!(xin->load_flag & XA_IN_LOAD_BUF)) )
  399.   {
  400.      if (cmap_true_to_332 == xaTRUE)
  401.              arm->chdr = CMAP_Create_332(arm->cmap,&arm->imagec);
  402.      else    arm->chdr = CMAP_Create_Gray(arm->cmap,&arm->imagec);
  403.   }
  404.   if ( (arm->pic==0) && (xin->load_flag & XA_IN_LOAD_BUF))
  405.   {
  406.     arm->pic_size = arm->imagex * arm->imagey;
  407.     if ( (cmap_true_map_flag == xaTRUE) && (arm->depth > 8) )
  408.                 arm->pic = (xaUBYTE *) malloc( 3 * arm->pic_size );
  409.     else arm->pic = (xaUBYTE *) malloc( XA_PIC_SIZE(arm->pic_size) );
  410.     if (arm->pic == 0) TheEnd1("ARM_Buffer_Action: malloc failed");
  411.   }
  412.   return(xaTRUE);
  413. }
  414.  
  415.  
  416. xaULONG ARM_Read_Index(xin,anim_hdr,arm,arm_hdr)
  417. XA_INPUT *xin;
  418. XA_ANIM_HDR *anim_hdr;
  419. XA_ANIM_SETUP *arm;
  420. ARM_HDR *arm_hdr;
  421. { xaULONG idx_cnt = arm_hdr->chunk_cnt;
  422.   xaULONG i,*idx_off,*idx_vsize,*idx_asize;
  423.  
  424.   idx_off = (xaULONG *)malloc( (idx_cnt + 2) * sizeof(xaULONG) );
  425.   idx_vsize = (xaULONG *)malloc( (idx_cnt + 2) * sizeof(xaULONG) );
  426.   idx_asize = (xaULONG *)malloc( (idx_cnt + 2) * sizeof(xaULONG) );
  427.  
  428.   DEBUG_LEVEL2 fprintf(stderr,"    idx offset  %08x\n",arm_hdr->idx_offset);
  429.   xin->Seek_FPos(xin,arm_hdr->idx_offset,0);
  430.   /* Go Through Chunks */
  431.   for(i=0; i<=idx_cnt; i++)
  432.   { xaLONG off, vid_size, aud_size, ret;
  433.     if (ARM_Read_Line(xin,arm_line) == xaFALSE) return(xaFALSE); /*chunk count*/
  434.     ret = sscanf(arm_line,"%d,%d;%d",&off,&vid_size,&aud_size);
  435.     DEBUG_LEVEL1
  436.     {
  437.      fprintf(stderr,"  (%d) %d) off %08x  vid %08x  aud %08x\n",ret,i,
  438.                         off,vid_size,aud_size);
  439.     }
  440.     idx_off[i] = off;
  441.     idx_vsize[i] = vid_size;
  442.     idx_asize[i] = aud_size;
  443.  
  444.   } /* end of for */
  445.  
  446.  
  447.   for(i=0; i<=idx_cnt; i++)
  448.   { xaULONG j; xaULONG tot_dsize = 0;
  449.  
  450. DEBUG_LEVEL1 fprintf(stderr," idx %d) chunks %d\n",i, arm_hdr->fp_chunk);
  451.     /* VIDEO */
  452.     xin->Seek_FPos(xin,idx_off[i],0);
  453.     for(j=0; j < arm_hdr->fp_chunk; j++)
  454.     { xaULONG fpos,dsize;
  455.       fpos = xin->Get_FPos(xin);        /* save xin position */
  456.       dsize = ARM_Get_Length(xin,arm);    /* find length of delta */
  457.       xin->Seek_FPos(xin,fpos,0);        /* return to xin position */
  458.       ARM_Read_Frame(xin,anim_hdr,arm,arm_hdr,dsize);
  459.       tot_dsize += dsize;
  460.     }
  461.  
  462.     /* AUDIO */
  463.     if (arm_audio_attempt == xaTRUE) 
  464.     { xaLONG ret, snd_size = (xaLONG)idx_asize[i];
  465.       xaULONG snd_off = idx_off[i] + idx_vsize[i];
  466.       if (xin->load_flag & XA_IN_LOAD_FILE)
  467.       { xaLONG rets;
  468.     rets = XA_Add_Sound(anim_hdr,0,arm_audio_type, snd_off,
  469.                 arm_audio_freq, snd_size, 
  470.                 &arm->aud_time,&arm->aud_timelo, 0, 0);
  471.     if (rets==xaFALSE) arm_audio_attempt = xaFALSE;
  472.     if (snd_size > arm->max_faud_size) arm->max_faud_size = snd_size;
  473.       }
  474.       else
  475.       { xaUBYTE *snd = (xaUBYTE *)malloc(snd_size);
  476.     if (snd==0) TheEnd1("ARM: snd malloc err");
  477.         xin->Seek_FPos(xin,snd_off,0); /* seek to audio info */
  478.     ret = xin->Read_Block(xin, snd, snd_size);
  479.     if (ret < snd_size) fprintf(stderr,"ARM: snd rd err(size %x\n",snd_size);
  480.     else
  481.     { int rets;
  482.           /*NOTE: don't free snd */
  483.       rets = XA_Add_Sound(anim_hdr,snd,arm_audio_type, -1,
  484.                 arm_audio_freq, snd_size,
  485.                 &arm->aud_time, &arm->aud_timelo, 0, 0);
  486.       if (rets==xaFALSE) arm_audio_attempt = xaFALSE;
  487.     }
  488.       }
  489.     } /* end of audio attempt */
  490.   }
  491.   free(idx_off);
  492.   free(idx_vsize);
  493.   free(idx_asize);
  494.   return(xaTRUE);
  495. }
  496.  
  497. /* Assuming xin is pointing to start of delta.
  498.  * leaves xin just after end of delta.
  499.  */
  500. void ARM_Read_Frame(xin,anim_hdr,arm,arm_hdr,vsize)
  501. XA_INPUT *xin;
  502. XA_ANIM_HDR *anim_hdr;
  503. XA_ANIM_SETUP *arm;
  504. ARM_HDR *arm_hdr;
  505. xaLONG vsize;
  506. { XA_ACTION *act;
  507.   xaULONG dlta_len = vsize;
  508.   ACT_DLTA_HDR *dlta_hdr;
  509.  
  510.   act = ACT_Get_Action(anim_hdr,ACT_DELTA);
  511.   if (xin->load_flag & XA_IN_LOAD_FILE)
  512.   {
  513.     dlta_hdr = (ACT_DLTA_HDR *) malloc(sizeof(ACT_DLTA_HDR));
  514.     if (dlta_hdr == 0) TheEnd1("ARM: dlta malloc err");
  515.     act->data = (xaUBYTE *)dlta_hdr;
  516.     dlta_hdr->flags = ACT_SNGL_BUF;
  517.     dlta_hdr->fsize = dlta_len;
  518.     dlta_hdr->fpos  = xin->Get_FPos(xin);
  519.     if (dlta_len > arm->max_fvid_size) arm->max_fvid_size = dlta_len;
  520.     xin->Seek_FPos(xin,dlta_len,1);
  521.   }
  522.   else
  523.   { xaULONG d; xaLONG ret;
  524.     d = dlta_len + (sizeof(ACT_DLTA_HDR));
  525.     dlta_hdr = (ACT_DLTA_HDR *) malloc( d );
  526.     if (dlta_hdr == 0) TheEnd1("QT rle: malloc failed");
  527.     act->data = (xaUBYTE *)dlta_hdr;
  528.     dlta_hdr->flags = ACT_SNGL_BUF | DLTA_DATA;
  529.     dlta_hdr->fpos = 0; dlta_hdr->fsize = dlta_len;
  530.     ret = xin->Read_Block(xin, dlta_hdr->data, dlta_len);
  531.     if (ret < dlta_len) { fprintf(stderr,"ARM: read err\n"); return; }
  532.   }
  533.   ARM_Add_Frame(arm->vid_time,arm->vid_timelo,act);
  534.   dlta_hdr->xpos = dlta_hdr->ypos = 0;
  535.   dlta_hdr->xsize = arm->imagex;
  536.   dlta_hdr->ysize = arm->imagey;
  537.   dlta_hdr->special = 0;
  538.   if (arm_hdr->vid_codec == ARM_VIDEO_MOVL_YUV)
  539.         dlta_hdr->extra = (void *)(ARM_VIDEO_YUV);
  540.   else        dlta_hdr->extra = (void *)(ARM_VIDEO_RGB);
  541.   dlta_hdr->xapi_rev = 0x0001;
  542.   dlta_hdr->delta = ARM_Decode_MLINES;
  543.   ACT_Setup_Delta(arm,act,dlta_hdr,xin);
  544. }
  545.  
  546.  
  547.  
  548. #define ARM_15YUV(pix,y,u,v) { \
  549.   v = (pix >> 10) & 0x1f; u = (pix >> 5) & 0x1f; y = pix & 0x1f; \
  550.   u ^= 0x10; v ^= 0x10; \
  551.   y = (y << 3) | (y >> 2); u = (u << 3) | (u >> 2); v = (v << 3) | (v >> 2); \
  552. } 
  553.  
  554. #define ARM_16YUV(pix,y,u,v) { \
  555.   v = (pix >> 11) & 0x1f; u = (pix >> 6) & 0x1f; y = (pix >> 1) & 0x1f; \
  556.   u ^= 0x10; v ^= 0x10; \
  557.   y = (y << 3) | (y >> 2); u = (u << 3) | (u >> 2); v = (v << 3) | (v >> 2); \
  558. }
  559.  
  560. #define ARM_GET_CODE(dp,code) {code = (*dp++); code |= (*dp++) << 8; }
  561.  
  562. xaULONG ARM_Get_RGB_Pixel(pix,map_flag,map,chdr)
  563. xaULONG pix,map_flag,*map;
  564. XA_CHDR *chdr;
  565. { xaULONG r,g,b;
  566.   r = (pix >> 10) & 0x1f; g = (pix >> 5) & 0x1f; b = pix & 0x1f;
  567.   r = (r << 3) | (r >> 2); g = (g << 3) | (g >> 2); b = (b << 3) | (b >> 2);
  568.   return( XA_RGB24_To_CLR32(r,g,b,map_flag,map,chdr) );
  569. } 
  570.  
  571. xaULONG ARM_Get_YUV_Pixel(pix,map_flag,map,chdr)
  572. xaULONG pix,map_flag,*map;
  573. XA_CHDR *chdr;
  574. { xaULONG y,u,v,r,g,b;
  575.   v = (pix >> 10) & 0x1f; u = (pix >> 5) & 0x1f; y = pix & 0x1f;
  576.   u ^= 0x10; v ^= 0x10;
  577.   y = (y << 3) | (y >> 2); u = (u << 3) | (u >> 2); v = (v << 3) | (v >> 2);
  578.   yuv_to_rgb(y,u,v,&r,&g,&b); 
  579.   return( XA_RGB24_To_CLR32(r,g,b,map_flag,map,chdr) );
  580. } 
  581.  
  582. xaULONG ARM_Get_RGB_RGB(pix,ir,ig,ib)
  583. xaULONG pix;
  584. xaULONG *ir,*ig,*ib;
  585. { xaULONG r,g,b;
  586.   r = (pix >> 10) & 0x1f; g = (pix >> 5) & 0x1f; b = pix & 0x1f;
  587.   r = (r << 3) | (r >> 2); g = (g << 3) | (g >> 2); b = (b << 3) | (b >> 2);
  588.   *ir = r; *ig = g; *ib = b;
  589.   return(1);
  590. } 
  591.  
  592. xaULONG ARM_Get_YUV_RGB(pix,ir,ig,ib)
  593. xaULONG pix;
  594. xaULONG *ir,*ig,*ib;
  595. { xaULONG y,u,v;
  596.   v = (pix >> 10) & 0x1f; u = (pix >> 5) & 0x1f; y = pix & 0x1f;
  597.   u ^= 0x10; v ^= 0x10;
  598.   y = (y << 3) | (y >> 2); u = (u << 3) | (u >> 2); v = (v << 3) | (v >> 2);
  599.   yuv_to_rgb(y,u,v,ir,ig,ib); 
  600.   return(1);
  601. } 
  602.  
  603. /* TEST */
  604. xaULONG
  605. ARM_Decode_MLINES(image,delta,dsize,dec_info)
  606. xaUBYTE *image;         /* Image Buffer. */
  607. xaUBYTE *delta;         /* delta data. */
  608. xaULONG dsize;          /* delta size */
  609. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  610. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  611.   xaULONG map_flag = dec_info->map_flag;        xaULONG *map = dec_info->map;
  612.   xaULONG special = dec_info->special;          void *extra = dec_info->extra;
  613.   XA_CHDR *chdr = dec_info->chdr;
  614.   xaUBYTE *dp = delta;
  615.   xaULONG special_flag = special & 0x0001;
  616.   xaLONG i_cnt,im_size = imagex * imagey;
  617.   xaULONG code;
  618.   xaUBYTE *pptr = ARM_prev_buff;
  619.   xaULONG vid_type = (xaULONG)(extra);
  620.   xaULONG (*arm_get_pixel)();
  621.   
  622.   if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
  623.  
  624.   /* Need to copy previous image, since Temporal references it */
  625.   { i_cnt  = im_size * ((special_flag)?(3):(x11_bytes_pixel));
  626.     memcpy((char *)(pptr),(char *)(image),(i_cnt));
  627.   }
  628.  
  629. /* */
  630.   if (special)
  631.   {
  632.     if (vid_type == ARM_VIDEO_YUV) arm_get_pixel = ARM_Get_YUV_RGB;
  633.     else arm_get_pixel = ARM_Get_RGB_RGB;
  634.   }
  635.   else
  636.   {
  637.     if (vid_type == ARM_VIDEO_YUV) arm_get_pixel = ARM_Get_YUV_Pixel;
  638.     else arm_get_pixel = ARM_Get_RGB_Pixel;
  639.   }
  640.  
  641.   i_cnt = 0;
  642.  
  643.  if (special)
  644.  { xaUBYTE *iptr = image;
  645.   while(i_cnt < im_size)
  646.   { ARM_GET_CODE(dp,code); 
  647.     if (code & 0x01)
  648.     { xaULONG test,cnt;
  649.       if (code == 0xe601) { i_cnt = im_size; break; }    /* End of Frame */
  650.       test = code >> 7;        cnt = ((code >> 1) & 0x3f) + 2;
  651.       if (test < 0x1cc)            /* Temporal/Spatial */
  652.       { xaUBYTE *isp;
  653.         if (test < 0x120) { isp = pptr; isp += (3 * i_cnt); } /* temporal */
  654.     else isp = iptr; /* spatial */
  655.     isp += 3 * (ARM_MOVL_X[test] + (ARM_MOVL_Y[test] * imagex));
  656.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  657.     while(cnt--) { *iptr++ = *isp++; *iptr++ = *isp++; *iptr++ = *isp++; }
  658.       }
  659.       else if (test >= 0x1e0)
  660.       { cnt = ((code >> 1) & 0x3ff) + 1;
  661.     if (test >=0x1f0)                /* New N Pixels */
  662.     { xaLONG  arm_bcnt   = ((((cnt * 15) + 15) >> 4) << 1); /* dp bytes */
  663.       xaLONG  arm_b_bnum = 0;    xaULONG arm_b_bbuf = 0;
  664.       DEBUG_LEVEL1  fprintf(stderr,"New N Pixels %d\n",cnt);
  665.       i_cnt += cnt; if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  666.       while(cnt--)  /* pixels */
  667.       { xaULONG r,g,b; /* Little Endian */
  668.         while(arm_b_bnum < 15) { arm_b_bbuf |=  (*dp++) << arm_b_bnum;
  669.                         arm_b_bnum += 8; arm_bcnt--; }
  670.         arm_get_pixel(arm_b_bbuf,&r,&g,&b);
  671.         *iptr++ = (xaUBYTE)r; *iptr++ = (xaUBYTE)g; *iptr++ = (xaUBYTE)b;
  672.         arm_b_bbuf >>= 15;        arm_b_bnum -= 15;
  673.       }
  674.       while(arm_bcnt--) dp++; /* left overs */
  675.     } else { iptr += (3 * cnt);  i_cnt += cnt; }        /* Copy/Skip */
  676.       }
  677.       else if (test == 0x1cc)
  678.       { xaULONG r,g,b,pixel;
  679.     ARM_GET_CODE(dp,pixel);
  680.     arm_get_pixel(pixel,&r,&g,&b);
  681.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  682.     while(cnt--) { *iptr++ = (xaUBYTE)r; 
  683.                 *iptr++ = (xaUBYTE)g; *iptr++ = (xaUBYTE)b; }
  684.       } else fprintf(stderr,"ARM decode ERROR: %04x\n",code);
  685.     }
  686.     else            /* New Pixel */
  687.     { xaULONG r,g,b; arm_get_pixel((code>>1),&r,&g,&b);  i_cnt++;
  688.       *iptr++ = (xaUBYTE)r; *iptr++ = (xaUBYTE)g; *iptr++ = (xaUBYTE)b;
  689.     }
  690.   } 
  691.  }
  692.  else if ( (x11_bytes_pixel==1) || (map_flag == xaFALSE) )
  693.  { xaUBYTE *iptr = image;
  694.   while(i_cnt < im_size)
  695.   { ARM_GET_CODE(dp,code); 
  696.     if (code & 0x01)
  697.     { xaULONG test,cnt;
  698.       if (code == 0xe601) { i_cnt = im_size; break; }    /* End of Frame */
  699.       test = code >> 7;        cnt = ((code >> 1) & 0x3f) + 2;
  700.       if (test < 0x1cc)            /* Temporal/Spatial */
  701.       { xaUBYTE *isp;
  702.         if (test < 0x120) { isp = pptr; isp += i_cnt; } /* temporal */
  703.     else isp = iptr; /* spatial */
  704.     isp += (ARM_MOVL_X[test] + (ARM_MOVL_Y[test] * imagex));
  705.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  706.     while(cnt--) *iptr++ = *isp++;
  707.       }
  708.       else if (test >= 0x1e0)
  709.       { cnt = ((code >> 1) & 0x3ff) + 1;
  710.     if (test >=0x1f0)                /* New N Pixels */
  711.     { xaLONG  arm_bcnt   = ((((cnt * 15) + 15) >> 4) << 1); /* dp bytes */
  712.       xaLONG  arm_b_bnum = 0;    xaULONG arm_b_bbuf = 0;
  713.       DEBUG_LEVEL1  fprintf(stderr,"New N Pixels %d\n",cnt);
  714.       i_cnt += cnt; if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  715.       while(cnt--)  /* pixels */
  716.       { /* Little Endian */
  717.         while(arm_b_bnum < 15) { arm_b_bbuf |=  (*dp++) << arm_b_bnum;
  718.                         arm_b_bnum += 8; arm_bcnt--; }
  719.         *iptr++ = (xaUBYTE)arm_get_pixel(arm_b_bbuf,map_flag,map,chdr);
  720.         arm_b_bbuf >>= 15;        arm_b_bnum -= 15;
  721.       }
  722.       while(arm_bcnt--) dp++; /* left overs */
  723.     } else { iptr += cnt;  i_cnt += cnt; }        /* Copy/Skip */
  724.       }
  725.       else if (test == 0x1cc)
  726.       { xaULONG pixel; xaUBYTE d;
  727.     ARM_GET_CODE(dp,pixel);
  728.     d = (xaUBYTE)arm_get_pixel(pixel,map_flag,map,chdr);
  729.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  730.     while(cnt--) *iptr++ = d;
  731.       } else fprintf(stderr,"ARM decode ERROR: %04x\n",code);
  732.     }
  733.     else            /* New Pixel */
  734.     { *iptr++ = (xaUBYTE)arm_get_pixel((code>>1),map_flag,map,chdr);  i_cnt++; }
  735.   } 
  736.  } /* end of byte 1 */
  737.  else if (x11_bytes_pixel==4)
  738.  { xaULONG *iptr = (xaULONG *)image;
  739.   while(i_cnt < im_size)
  740.   { ARM_GET_CODE(dp,code); 
  741.     if (code & 0x01)
  742.     { xaULONG test,cnt;
  743.       if (code == 0xe601) { i_cnt = im_size; break; }    /* End of Frame */
  744.       test = code >> 7;        cnt = ((code >> 1) & 0x3f) + 2;
  745.       if (test < 0x1cc)            /* Temporal/Spatial */
  746.       { xaULONG *isp;
  747.         if (test < 0x120) { isp = (xaULONG *)pptr; isp += i_cnt; }/*temporal */
  748.     else isp = (xaULONG *)iptr; /* spatial */
  749.     isp += (ARM_MOVL_X[test] + (ARM_MOVL_Y[test] * imagex));
  750.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  751.     while(cnt--) *iptr++ = *isp++;
  752.       }
  753.       else if (test >= 0x1e0)
  754.       { cnt = ((code >> 1) & 0x3ff) + 1;
  755.     if (test >=0x1f0)                /* New N Pixels */
  756.     { xaLONG  arm_bcnt   = ((((cnt * 15) + 15) >> 4) << 1); /* dp bytes */
  757.       xaLONG  arm_b_bnum = 0;    xaULONG arm_b_bbuf = 0;
  758.       DEBUG_LEVEL1  fprintf(stderr,"New N Pixels %d\n",cnt);
  759.       i_cnt += cnt; if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  760.       while(cnt--)  /* pixels */
  761.       { /* Little Endian */
  762.         while(arm_b_bnum < 15) { arm_b_bbuf |=  (*dp++) << arm_b_bnum;
  763.                         arm_b_bnum += 8; arm_bcnt--; }
  764.         *iptr++ = (xaULONG)arm_get_pixel(arm_b_bbuf,map_flag,map,chdr);
  765.         arm_b_bbuf >>= 15;        arm_b_bnum -= 15;
  766.       }
  767.       while(arm_bcnt--) dp++; /* left overs */
  768.     } else { iptr += cnt;  i_cnt += cnt; }        /* Copy/Skip */
  769.       }
  770.       else if (test == 0x1cc)
  771.       { xaULONG pixel; xaULONG d;
  772.     ARM_GET_CODE(dp,pixel);
  773.     d = (xaULONG)arm_get_pixel(pixel,map_flag,map,chdr);
  774.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  775.     while(cnt--) *iptr++ = d;
  776.       } else fprintf(stderr,"ARM decode ERROR: %04x\n",code);
  777.     }
  778.     else            /* New Pixel */
  779.     { *iptr++ = (xaULONG)arm_get_pixel((code>>1),map_flag,map,chdr);  i_cnt++; }
  780.   } 
  781.  } /* end of byte 4 */
  782.  else /* if (x11_bytes_pixel==2) */
  783.  { xaUSHORT *iptr = (xaUSHORT *)image;
  784.   while(i_cnt < im_size)
  785.   { ARM_GET_CODE(dp,code); 
  786.     if (code & 0x01)
  787.     { xaULONG test,cnt;
  788.       if (code == 0xe601) { i_cnt = im_size; break; }    /* End of Frame */
  789.       test = code >> 7;        cnt = ((code >> 1) & 0x3f) + 2;
  790.       if (test < 0x1cc)            /* Temporal/Spatial */
  791.       { xaUSHORT *isp;
  792.         if (test < 0x120) { isp = (xaUSHORT *)pptr; isp += i_cnt; }/*temporal */
  793.     else isp = (xaUSHORT *)iptr; /* spatial */
  794.     isp += (ARM_MOVL_X[test] + (ARM_MOVL_Y[test] * imagex));
  795.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  796.     while(cnt--) *iptr++ = *isp++;
  797.       }
  798.       else if (test >= 0x1e0)
  799.       { cnt = ((code >> 1) & 0x3ff) + 1;
  800.     if (test >=0x1f0)                /* New N Pixels */
  801.     { xaLONG  arm_bcnt   = ((((cnt * 15) + 15) >> 4) << 1); /* dp bytes */
  802.       xaLONG  arm_b_bnum = 0;    xaULONG arm_b_bbuf = 0;
  803.       DEBUG_LEVEL1  fprintf(stderr,"New N Pixels %d\n",cnt);
  804.       i_cnt += cnt; if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  805.       while(cnt--)  /* pixels */
  806.       { /* Little Endian */
  807.         while(arm_b_bnum < 15) { arm_b_bbuf |=  (*dp++) << arm_b_bnum;
  808.                         arm_b_bnum += 8; arm_bcnt--; }
  809.         *iptr++ = (xaUSHORT)arm_get_pixel(arm_b_bbuf,map_flag,map,chdr);
  810.         arm_b_bbuf >>= 15;        arm_b_bnum -= 15;
  811.       }
  812.       while(arm_bcnt--) dp++; /* left overs */
  813.     } else { iptr += cnt;  i_cnt += cnt; }        /* Copy/Skip */
  814.       }
  815.       else if (test == 0x1cc)
  816.       { xaULONG pixel; xaUSHORT d;
  817.     ARM_GET_CODE(dp,pixel);
  818.     d = (xaUSHORT)arm_get_pixel(pixel,map_flag,map,chdr);
  819.     i_cnt += cnt;    if (i_cnt >= im_size) cnt -= (i_cnt - im_size);
  820.     while(cnt--) *iptr++ = d;
  821.       } else fprintf(stderr,"ARM decode ERROR: %04x\n",code);
  822.     }
  823.     else            /* New Pixel */
  824.     { *iptr++ = (xaUSHORT)arm_get_pixel((code>>1),map_flag,map,chdr); i_cnt++; }
  825.   } 
  826.  } /* end of byte 2 */
  827.  
  828.   dec_info->xs = dec_info->ys = 0; dec_info->xe = imagex; dec_info->ye = imagey;
  829.   if (map_flag==xaTRUE) return(ACT_DLTA_MAPD);
  830.   else return(ACT_DLTA_NORM);
  831. }
  832.  
  833.  
  834. xaULONG ARM_Get_Length(xin,arm)
  835. XA_INPUT *xin;
  836. XA_ANIM_SETUP *arm;
  837. { xaULONG d_cnt = 0;
  838.   xaLONG i = arm->imagex * arm->imagey;
  839.   xaULONG code;
  840.  
  841.   while(i > 0)
  842.   {
  843.     if ( xin->At_EOF(xin,-1) ) return(0);
  844.     code = xin->Read_LSB_U16(xin); d_cnt += 2; 
  845.  
  846.     if (code & 0x01)
  847.     { xaULONG test,cnt;
  848.  
  849.       if (code == 0xe601) return(d_cnt);    /* End of Frame */
  850.       test = code >> 7;        
  851.       cnt = ((code >> 1) & 0x3f) + 2;
  852.       if (test < 0x120)        { i -= cnt; }    /* Temporal */
  853.       else if (test < 0x1cc)    { i -= cnt; }    /* Spatial */ 
  854.       else if (test >= 0x1e0)            /* New N Pix */
  855.       { cnt = ((code >> 1) & 0x3ff) + 1;
  856.     if (test >=0x1f0)            /* New N Pixels */
  857.     { xaULONG bs = ((cnt * 15) + 15) >> 4;
  858.       i -= cnt;
  859.       while(bs--) { xin->Read_LSB_U16(xin); d_cnt += 2; } 
  860.     }
  861.     else    { i -= cnt; }            /* Copy/Skip */
  862.       }
  863.       else if (test == 0x1cc)                /* Duplicate */
  864.       {
  865.         if (cnt <= 2) {fprintf(stderr,"DUP CNT ERR\n"); continue; }
  866.         xin->Read_LSB_U16(xin); d_cnt += 2;
  867.     i -= cnt;
  868.       }
  869.       else 
  870.       {
  871.     fprintf(stderr,"ARM Get len error: %04x\n",code);
  872.       }
  873.     }
  874.     else { i--; }                /* New Pixel */
  875.   }
  876.   code = xin->Read_LSB_U16(xin); 
  877.   if (code == 0xe601) d_cnt += 2;
  878.   return(d_cnt);
  879. }
  880.  
  881. void arm_yuv_to_rgb(iy,iu,iv,ir,ig,ib)
  882. xaULONG iy,iu,iv;
  883. xaULONG *ir,*ig,*ib;
  884. { float yy,uu,vv;
  885.   float u2,u3,v2,v3;
  886.   float DD;
  887.   float rr,gg,bb;
  888.   
  889.  
  890.   DD = 255.0;
  891.   yy =  ((float)(iy)/31.0);
  892.   vv =  ((float)(iv)/15.0);
  893.   uu =  ((float)(iu)/15.0);
  894.   if (vv > 1.0) vv = -((31.0 - (float)(iv) ) / 15.0);
  895.   if (uu > 1.0) uu = -((31.0 - (float)(iu) ) / 15.0);
  896.   v2 = vv * 0.701;
  897.   u2 = uu * 0.886;
  898.   v3 = vv * (0.299 * 0.701 / 0.587);
  899.   u3 = uu * (0.114 * 0.886 / 0.587);
  900.  
  901.   bb = (yy + u2);
  902.   rr = (yy + v2);
  903.   gg = (yy - u3 - v3);
  904.   DEBUG_LEVEL1 
  905.     fprintf(stderr,"rr = %f gg = %f bb = %f\n",rr,gg,bb);
  906.   bb *= 255.0;
  907.   rr *= 255.0;
  908.   gg *= 255.0;
  909.  
  910.   if (bb > 255.0) bb = 255.0; if (bb < 0.0) bb = 0.0;
  911.   if (rr > 255.0) rr = 255.0; if (rr < 0.0) rr = 0.0;
  912.   if (gg > 255.0) gg = 255.0; if (gg < 0.0) gg = 0.0;
  913.   *ir = (xaULONG)(rr);
  914.   *ig = (xaULONG)(gg);
  915.   *ib = (xaULONG)(bb);
  916.  
  917.   DEBUG_LEVEL1
  918.     fprintf(stderr,"YUV %d %d %d  RGB %d %d %d\n",iy,iu,iv,*ir,*ig,*ib);
  919. }
  920.  
  921.  
  922. /*****************************
  923.  *  Function To allocate and initialized the following tables and buffers:
  924.  *
  925.  *********/
  926. void ARM_Init_Tables(anim_hdr,imagex,imagey)
  927. XA_ANIM_HDR *anim_hdr;
  928. xaULONG imagex,imagey;
  929. { xaULONG i; xaLONG x,y;
  930.  
  931.  XA_Add_Func_To_Free_Chain(anim_hdr,ARM_Free_Stuff);
  932.  /* Prev Buffer Allocation */
  933.  if (cmap_color_func == 4)  i = xaMAX(3,x11_bytes_pixel);
  934.  else i = x11_bytes_pixel;
  935.  i *= imagex * imagey;
  936.  
  937.  if (ARM_prev_buff == 0)
  938.  { ARM_prev_buff_size = i;
  939.    ARM_prev_buff = (xaUBYTE *)malloc( ARM_prev_buff_size );
  940.  }
  941.  else if (i > ARM_prev_buff_size)
  942.  { ARM_prev_buff_size = i;
  943.    ARM_prev_buff = (xaUBYTE *)realloc( ARM_prev_buff, ARM_prev_buff_size );
  944.  }
  945.  if (ARM_prev_buff == 0) TheEnd1("ARM: prev_buff malloc err");
  946.  
  947.  /* Spatial/Temporal Tables Allocation */
  948.  if (ARM_MOVL_X == 0)
  949.  { ARM_MOVL_X = (xaLONG *)malloc( 459 * sizeof(xaLONG) );
  950.    if (ARM_MOVL_X==0) TheEnd1("ARM: MOVL_X malloc err");
  951.  }
  952.  if (ARM_MOVL_Y == 0)
  953.  { ARM_MOVL_Y = (xaLONG *)malloc( 459 * sizeof(xaLONG) );
  954.    if (ARM_MOVL_Y==0) TheEnd1("ARM: MOVL_Y malloc err");
  955.  }
  956.  /* Temporal Encoding */
  957.  x = y = -8;
  958.  for(i = 0; i < 288; i++)
  959.  { ARM_MOVL_X[i] = x;
  960.    ARM_MOVL_Y[i] = y;
  961.    x++; if (x > 8) { x = -8; y++; }
  962.    if ((x==0) && (y==0))  x++; /* skip x = y = 0 case */
  963.  }
  964.  /* Spatial Encoding */
  965.  x = y = -9;
  966.  for(i = 288; i < 459; i++)
  967.  { ARM_MOVL_X[i] = x;
  968.    ARM_MOVL_Y[i] = y;
  969.    x++; if (x > 9) { x = -9; y++; }
  970.  }
  971. }
  972.  
  973. /*****************************
  974.  *  Function To Free  the following tables and buffers.
  975.  *
  976.  *********/
  977. void ARM_Free_Stuff()
  978. {
  979.   if (ARM_MOVL_X) { free(ARM_MOVL_X); ARM_MOVL_X = 0; }
  980.   if (ARM_MOVL_Y) { free(ARM_MOVL_Y); ARM_MOVL_Y = 0; }
  981.   if (ARM_prev_buff) { free(ARM_prev_buff); ARM_prev_buff = 0; }
  982. }
  983.  
  984.  
  985.