开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
GIFLoader.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：28k
源码类别：

MTK

开发平台：

C/C++

GIFLoader.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*******************************************************************************
  37.  * Filename:
  38.  * ---------
  39.  *  GIFLoader.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  
  48.  *
  49.  * Author:
  50.  * -------
  51.  *  
  52.  *
  53.  *==============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  *
  59.  *------------------------------------------------------------------------------
  60.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  61.  *==============================================================================
  62.  *******************************************************************************/
  64. #include <stdio.h>
  65. #include <stdlib.h>
  66. #include <string.h>
  68. #include "ResDevice.h"
  69. #include "ResBytestream.h"
  70. #include "ImgDecoderDef.h"
  72. extern U32 image_static_row_data[];
  73. extern U32 image_static_palette[];
  74. extern U32 image_static_buffer[];
  76. /* GIF code from WINGUI.C  */
  79. /*****************************************************************************
  80.  * FUNCTION
  81.  *  GIF_get_byte
  82.  * DESCRIPTION
  83.  *  
  84.  * PARAMETERS
  85.  *  file        [?]     
  86.  * RETURNS
  87.  *  
  88.  *****************************************************************************/
  89. U8 GIF_get_byte(bytestream *file)
  90. {
  91.     /*----------------------------------------------------------------*/
  92.     /* Local Variables                                                */
  93.     /*----------------------------------------------------------------*/
  95.     /*----------------------------------------------------------------*/
  96.     /* Code Body                                                      */
  97.     /*----------------------------------------------------------------*/
  98.     return (bytestream_fgetbyte(file));
  99. }
  101. #if(!WINGUI_DIRECT_IMAGE_DISPLAY)
  104. /*****************************************************************************
  105.  * FUNCTION
  106.  *  GIF_write_line
  107.  * DESCRIPTION
  108.  *  
  109.  * PARAMETERS
  110.  *  ix                          [IN]        
  111.  *  iy                          [IN]        
  112.  *  b                           [?]         
  113.  *  buffer                      [?]         
  114.  *  length                      [IN]        
  115.  *  y                           [IN]        
  116.  *  palette                     [?]         
  117.  *  transparent_GIF             [IN]        
  118.  *  transparent_color_index     [IN]        
  119.  * RETURNS
  120.  *  void
  121.  *****************************************************************************/
  122. void GIF_write_line(
  123.         S32 ix,
  124.         S32 iy,
  125.         bitmap *b,
  126.         U8 *buffer,
  127.         S16 length,
  128.         S16 y,
  129.         U8 palette[][3],
  130.         U8 transparent_GIF,
  131.         U8 transparent_color_index)
  132. {
  133.     /*----------------------------------------------------------------*/
  134.     /* Local Variables                                                */
  135.     /*----------------------------------------------------------------*/
  137.     /*----------------------------------------------------------------*/
  138.     /* Code Body                                                      */
  139.     /*----------------------------------------------------------------*/
  140.     if (b == NULL)
  141.     {
  142.         return;
  143.     }
  144.     if (transparent_GIF)
  145.     {
  146.         {
  147.             S32 i;
  148.             U8 color_index;
  149.             U32 offset = (y + iy) * b->xsize + ix;
  150.             U16 *bitmap_data = (U16*) b->data;
  151.             U16 d;
  153.             for (i = 0; i < length; i++)
  154.             {
  155.                 color_index = (U8) buffer[i];
  156.                 d = MMI_RGB_TO_HW_FORMAT(palette[color_index][0], palette[color_index][1], palette[color_index][2]);
  157.                 if (color_index == transparent_color_index)
  158.                 {
  159.                     SET_RGB_TRANSPARENT_COLOR_16(d);
  160.                 }
  161.                 bitmap_data[offset++] = d;
  162.             }
  163.         }
  164.     }
  165.     else
  166.     {
  167.         {
  168.             S32 i;
  169.             U8 color_index;
  170.             U32 offset = (y + iy) * b->xsize + ix;
  171.             U16 *bitmap_data = (U16*) b->data;
  172.             U16 d;
  174.             for (i = 0; i < length; i++)
  175.             {
  176.                 color_index = (U8) buffer[i];
  177.                 d = MMI_RGB_TO_HW_FORMAT(palette[color_index][0], palette[color_index][1], palette[color_index][2]);
  178.                 bitmap_data[offset++] = d;
  179.             }
  180.         }
  181.     }
  182. }
  184. #endif /* (!WINGUI_DIRECT_IMAGE_DISPLAY) */ 
  186. #define GIF_MAX_CODES   4095
  188. S16 GIF_current_code_size, GIF_clear_code, GIF_end_code, GIF_new_codes, GIF_top_slot, GIF_slot;
  189. S16 GIF_navailable_bytes, GIF_nbits_left, GIF_b1;
  190. U8 GIF_byte_buffer[257], *GIF_pbytes;
  192. U16 GIF_code_mask[13] = {0x0000,
  193.     0x0001, 0x0003,
  194.     0x0007, 0x000f,
  195.     0x001f, 0x003f,
  196.     0x007f, 0x00ff,
  197.     0x01ff, 0x03ff,
  198.     0x07ff, 0x0fff
  199. };
  202. /*****************************************************************************
  203.  * FUNCTION
  204.  *  GIF_initialize_decoder
  205.  * DESCRIPTION
  206.  *  
  207.  * PARAMETERS
  208.  *  size        [IN]        
  209.  * RETURNS
  210.  *  void
  211.  *****************************************************************************/
  212. void GIF_initialize_decoder(S16 size)
  213. {
  214.     /*----------------------------------------------------------------*/
  215.     /* Local Variables                                                */
  216.     /*----------------------------------------------------------------*/
  218.     /*----------------------------------------------------------------*/
  219.     /* Code Body                                                      */
  220.     /*----------------------------------------------------------------*/
  221.     GIF_current_code_size = (S16) (size + 1);
  222.     GIF_top_slot = (S16) (1 << GIF_current_code_size);
  223.     GIF_clear_code = (S16) (1 << size);
  224.     GIF_end_code = (S16) (GIF_clear_code + 1);
  225.     GIF_slot = (GIF_new_codes) = (S16) (GIF_end_code + 1);
  226.     GIF_navailable_bytes = GIF_nbits_left = (S16) 0;
  227. }
  230. /*****************************************************************************
  231.  * FUNCTION
  232.  *  GIF_get_next_code
  233.  * DESCRIPTION
  234.  *  
  235.  * PARAMETERS
  236.  *  file        [?]     
  237.  * RETURNS
  238.  *  
  239.  *****************************************************************************/
  240. S16 GIF_get_next_code(bytestream *file)
  241. {
  242.     /*----------------------------------------------------------------*/
  243.     /* Local Variables                                                */
  244.     /*----------------------------------------------------------------*/
  245.     S16 i, x, ret;
  247.     /*----------------------------------------------------------------*/
  248.     /* Code Body                                                      */
  249.     /*----------------------------------------------------------------*/
  250.     if (GIF_nbits_left == 0)
  251.     {
  252.         if (GIF_navailable_bytes <= 0)
  253.         {
  254.             GIF_pbytes = GIF_byte_buffer;
  255.             GIF_navailable_bytes = GIF_get_byte(file);
  256.             if (GIF_navailable_bytes < 0)
  257.             {
  258.                 return (GIF_navailable_bytes);
  259.             }
  260.             else if (GIF_navailable_bytes > 0)
  261.             {
  262.                 for (i = 0; i < GIF_navailable_bytes; i++)
  263.                 {
  264.                     x = GIF_get_byte(file);
  265.                     if (x < 0)
  266.                     {
  267.                         return (x);
  268.                     }
  269.                     GIF_byte_buffer[i] = (U8) x;
  270.                 }
  271.             }
  272.         }
  273.         GIF_b1 = *GIF_pbytes++;
  274.         GIF_nbits_left = 8;
  275.         GIF_navailable_bytes--;
  276.     }
  277.     ret = (S16) (GIF_b1 >> (8 - GIF_nbits_left));
  278.     while (GIF_current_code_size > GIF_nbits_left)
  279.     {
  280.         if (GIF_navailable_bytes <= 0)
  281.         {
  282.             GIF_pbytes = GIF_byte_buffer;
  283.             GIF_navailable_bytes = GIF_get_byte(file);
  284.             if (GIF_navailable_bytes < 0)
  285.             {
  286.                 return (GIF_navailable_bytes);
  287.             }
  288.             else if (GIF_navailable_bytes > 0)
  289.             {
  290.                 for (i = 0; i < GIF_navailable_bytes; i++)
  291.                 {
  292.                     x = GIF_get_byte(file);
  293.                     if (x < 0)
  294.                     {
  295.                         return (x);
  296.                     }
  297.                     GIF_byte_buffer[i] = (U8) x;
  298.                 }
  299.             }
  300.         }
  301.         GIF_b1 = *GIF_pbytes++;
  302.         ret |= GIF_b1 << GIF_nbits_left;
  303.         GIF_nbits_left += 8;
  304.         GIF_navailable_bytes--;
  305.     }
  306.     GIF_nbits_left = (S16) (GIF_nbits_left - GIF_current_code_size);
  307.     ret &= GIF_code_mask[GIF_current_code_size];
  308.     return (ret);
  309. }
  311. S16 GIF_stack[GIF_MAX_CODES + 1];
  312. S16 GIF_suffix[GIF_MAX_CODES + 1];
  313. S16 GIF_prefix[GIF_MAX_CODES + 1];
  316. /*****************************************************************************
  317.  * FUNCTION
  318.  *  GIF_interlace_pass
  319.  * DESCRIPTION
  320.  *  
  321.  * PARAMETERS
  322.  *  y           [?]         
  323.  *  pass        [?]         
  324.  *  ysize       [IN]        
  325.  * RETURNS
  326.  *  void
  327.  *****************************************************************************/
  328. void GIF_interlace_pass(S16 *y, S16 *pass, S16 ysize)
  329. {
  330.     /*----------------------------------------------------------------*/
  331.     /* Local Variables                                                */
  332.     /*----------------------------------------------------------------*/
  334.     /*----------------------------------------------------------------*/
  335.     /* Code Body                                                      */
  336.     /*----------------------------------------------------------------*/
  337.     switch (*pass)
  338.     {
  339.         case 0:
  340.             (*y) += 8;
  341.             if (*y >= ysize)
  342.             {
  343.                 *y = 4;
  344.                 (*pass)++;
  345.             }
  346.             break;
  347.         case 1:
  348.             (*y) += 8;
  349.             if (*y >= ysize)
  350.             {
  351.                 *y = 2;
  352.                 (*pass)++;
  353.             }
  354.             break;
  355.         case 2:
  356.             (*y) += 4;
  357.             if (*y >= ysize)
  358.             {
  359.                 *y = 1;
  360.                 (*pass)++;
  361.             }
  362.             break;
  363.         case 3:
  364.             (*y) += 2;
  365.             break;
  366.     }
  367. }
  369. // #if(!WINGUI_DIRECT_IMAGE_DISPLAY)
  372. /*****************************************************************************
  373.  * FUNCTION
  374.  *  GIF_decoder
  375.  * DESCRIPTION
  376.  *  
  377.  * PARAMETERS
  378.  *  ix                          [IN]        
  379.  *  iy                          [IN]        
  380.  *  file                        [?]         
  381.  *  b                           [?]         
  382.  *  xsize                       [IN]        
  383.  *  ysize                       [IN]        
  384.  *  interlaced                  [IN]        
  385.  *  palette                     [?]         
  386.  *  transparent_GIF             [IN]        
  387.  *  transparent_color_index     [IN]        
  388.  * RETURNS
  389.  *  void
  390.  *****************************************************************************/
  391. void GIF_decoder(
  392.         S32 ix,
  393.         S32 iy,
  394.         bytestream *file,
  395.         bitmap *b,
  396.         S16 xsize,
  397.         S16 ysize,
  398.         U8 interlaced,
  399.         U8 palette[][3],
  400.         U8 transparent_GIF,
  401.         U8 transparent_color_index)
  402. {
  403.     /*----------------------------------------------------------------*/
  404.     /* Local Variables                                                */
  405.     /*----------------------------------------------------------------*/
  406.     S16 *stack_pointer;
  407.     U8 *buffer_pointer;
  408.     U8 *buffer;
  409.     S16 code, fc, oc, buffer_count, c, size, y = 0, pass = 0;
  411.     /*----------------------------------------------------------------*/
  412.     /* Code Body                                                      */
  413.     /*----------------------------------------------------------------*/
  414.     size = GIF_get_byte(file);
  415.     if (size < 0)
  416.     {
  417.         return;
  418.     }
  419.     GIF_initialize_decoder(size);
  420.     oc = fc = 0;
  421.     buffer = (U8*) image_static_row_data;
  422.     stack_pointer = GIF_stack;
  423.     buffer_pointer = buffer;
  424.     buffer_count = xsize;
  425.     while ((c = GIF_get_next_code(file)) != GIF_end_code)
  426.     {
  427.         if (c < 0)
  428.         {
  429.             return;
  430.         }
  431.         if (c == GIF_clear_code)
  432.         {
  433.             GIF_current_code_size = (S16) (size + 1);
  434.             GIF_slot = GIF_new_codes;
  435.             GIF_top_slot = (S16) (1 << GIF_current_code_size);
  436.             while ((c = GIF_get_next_code(file)) == GIF_clear_code);
  437.             if (c == GIF_end_code)
  438.             {
  439.                 break;
  440.             }
  441.             if (c >= GIF_slot)
  442.             {
  443.                 c = 0;
  444.             }
  445.             oc = fc = c;
  446.             *buffer_pointer++ = (U8) c;
  447.             if (--buffer_count == 0)
  448.             {
  449.                 GIF_write_line(ix, iy, b, buffer, xsize, y, palette, transparent_GIF, transparent_color_index);
  450.                 if (interlaced)
  451.                 {
  452.                     GIF_interlace_pass(&y, &pass, ysize);
  453.                 }
  454.                 else
  455.                 {
  456.                     y++;
  457.                 }
  458.                 buffer_pointer = buffer;
  459.                 buffer_count = xsize;
  460.             }
  461.         }
  462.         else
  463.         {
  464.             code = c;
  465.             if (code >= GIF_slot)
  466.             {
  467.                 code = oc;
  468.                 *stack_pointer++ = fc;
  469.             }
  470.             while (code >= GIF_new_codes)
  471.             {
  472.                 *stack_pointer++ = GIF_suffix[code];
  473.                 code = GIF_prefix[code];
  474.             }
  475.             *stack_pointer++ = code;
  476.             if (GIF_slot < GIF_top_slot)
  477.             {
  478.                 GIF_suffix[GIF_slot] = fc = code;
  479.                 GIF_prefix[GIF_slot++] = oc;
  480.                 oc = c;
  481.             }
  482.             if (GIF_slot >= GIF_top_slot)
  483.             {
  484.                 if (GIF_current_code_size < 12)
  485.                 {
  486.                     GIF_top_slot <<= 1;
  487.                     GIF_current_code_size++;
  488.                 }
  489.             }
  490.             while (stack_pointer > GIF_stack)
  491.             {
  492.                 *buffer_pointer++ = (U8) * (--stack_pointer);
  493.                 if (--buffer_count == 0)
  494.                 {
  495.                     GIF_write_line(ix, iy, b, buffer, xsize, y, palette, transparent_GIF, transparent_color_index);
  496.                     if (interlaced)
  497.                     {
  498.                         GIF_interlace_pass(&y, &pass, ysize);
  499.                     }
  500.                     else
  501.                     {
  502.                         y++;
  503.                     }
  504.                     buffer_pointer = buffer;
  505.                     buffer_count = xsize;
  506.                 }
  507.             }
  508.         }
  509.     }
  510.     if (buffer_count != xsize)
  511.     {
  512.         GIF_write_line(ix, iy, b, buffer, xsize, y, palette, transparent_GIF, transparent_color_index);
  513.     }
  514.     if (interlaced)
  515.     {
  516.         GIF_interlace_pass(&y, &pass, ysize);
  517.     }
  518.     else
  519.     {
  520.         y++;
  521.     }
  522. }
  525. /*****************************************************************************
  526.  * FUNCTION
  527.  *  Load_GIF
  528.  * DESCRIPTION
  529.  *  
  530.  * PARAMETERS
  531.  *  file                [?]     
  532.  *  total_frames        [?]     
  533.  * RETURNS
  534.  *  
  535.  *****************************************************************************/
  536. U8 Load_GIF(bytestream *file, S32 *total_frames)
  537. {
  538.     /*----------------------------------------------------------------*/
  539.     /* Local Variables                                                */
  540.     /*----------------------------------------------------------------*/
  541.     S8 gif_signature[4];
  542.     S8 descriptor_flags;
  543.     S16 bits_per_pixel;
  544.     S16 i, j, ncolors;
  545.     S16 x, y, xsize, ysize;
  546.     S8 interlace = 0;
  547.     S8 gif_done;
  548.     S16 screen_xsize, screen_ysize;
  549.     U8 transparent_color_index = 0;
  550.     U8 transparent_GIF = 0;
  551.     U8 palette[256][3];
  552.     S16 frame_counter = 0;
  553.     S16 dest_row_bytes = 0;
  554.     S32 bitmap_size;
  555.     S32 first_frame_xsize = -1, first_frame_ysize = -1;
  557.     /*----------------------------------------------------------------*/
  558.     /* Code Body                                                      */
  559.     /*----------------------------------------------------------------*/
  560.     if (file == NULL)
  561.     {
  562.         return (0);
  563.     }
  564.     /*   read the GIF file signature   */
  565.     bytestream_fseek(file, 0, SEEK_SET);
  566.     bytestream_fread((U8*) gif_signature, 1, 3, file);
  567.     gif_signature[3] = '';
  568.     if (strcmp((const char*)gif_signature, (const char*)"GIF"))
  569.     {
  570.         return (0);
  571.     }
  572.     bytestream_fseek(file, 3, SEEK_CUR);
  573.     screen_xsize = bytestream_fgetword(file);
  574.     screen_ysize = bytestream_fgetword(file);
  575.     printf("Screen Width=%d, Screen Height=%dn", screen_xsize, screen_ysize);
  576.     descriptor_flags = bytestream_fgetbyte(file);
  577.     bytestream_fseek(file, 2, SEEK_CUR);
  578.     if (descriptor_flags & 0x80)
  579.     {
  580.         bits_per_pixel = (S16) ((descriptor_flags & 0x07) + 1);
  581.         ncolors = (S16) (1 << bits_per_pixel);
  582.         /*  Read the global color palette */
  583.         for (i = 0; i < ncolors; i++)
  584.         {
  585.             for (j = 0; j < 3; j++)
  586.             {
  587.                 palette[i][j] = bytestream_fgetbyte(file);
  588.             }
  589.         }
  590.     }
  591.     gif_done = 0;
  592.     do
  593.     {
  594.         char block_type = bytestream_fgetbyte(file);
  596.         switch (block_type)
  597.         {
  598.             case '!':   /* Process the GIF extension block  */
  599.             {
  600.                 S32 block_size;
  601.                 S32 i;
  602.                 U8 label = bytestream_fgetbyte(file);
  603.                 U8 flags, color_index;
  605.                 if (label == 0xf9)
  606.                 {
  607.                     bytestream_fgetbyte(file);
  608.                     flags = bytestream_fgetbyte(file);
  609.                     bytestream_fgetbyte(file);
  610.                     bytestream_fgetbyte(file);
  611.                     color_index = bytestream_fgetbyte(file);
  612.                     if (flags & 0x01)
  613.                     {
  614.                         transparent_GIF = 1;
  615.                         transparent_color_index = color_index;
  616.                         printf("The image is has transparent color:");
  617.                         printf(
  618.                             "(%d,%d,%d)n",
  619.                             palette[color_index][0],
  620.                             palette[color_index][1],
  621.                             palette[color_index][2]);
  622.                     }
  623.                 }
  624.                 else
  625.                 {
  626.                     while ((block_size = bytestream_fgetbyte(file)) != 0)
  627.                     {
  628.                         for (i = 0; i < block_size; i++)
  629.                         {
  630.                             bytestream_fgetbyte(file);
  631.                         }
  632.                     }
  633.                 }
  634.             }
  635.                 break;
  636.             case ',':   /* Process the GIF image   */
  637.             {
  638.                 x = bytestream_fgetword(file);
  639.                 y = bytestream_fgetword(file);
  640.                 xsize = bytestream_fgetword(file);
  641.                 ysize = bytestream_fgetword(file);
  642.                 descriptor_flags = bytestream_fgetbyte(file);
  643.                 if (descriptor_flags & 0x80)
  644.                 {
  645.                     bits_per_pixel = (S16) ((descriptor_flags & 0x07) + 1);
  646.                     ncolors = (S16) (1 << bits_per_pixel);
  647.                     /* Read the local color palette  */
  648.                     for (i = 0; i < ncolors; i++)
  649.                     {
  650.                         for (j = 0; j < 3; j++)
  651.                         {
  652.                             palette[i][j] = bytestream_fgetbyte(file);
  653.                         }
  654.                     }
  655.                     printf("number of color:%dn", ncolors);
  656.                 }
  657.                 if (descriptor_flags & 0x40)
  658.                 {
  659.                     interlace = 1;
  660.                 }
  661.                 if (first_frame_xsize < 0)
  662.                 {
  663.                     first_frame_xsize = xsize;
  664.                     first_frame_ysize = ysize;
  665.                     bitmap_size = dest_row_bytes * ysize;
  666.                 }
  667.                 //                                                      GIF_decoder(x,y,file,b,xsize,ysize,interlace,palette,transparent_GIF,transparent_color_index);
  668.                 //                                                      if((frame_counter>=frame_number) && (b!=NULL)) gif_done=1;
  669.                 frame_counter++;
  670.             }
  671.                 break;
  672.             case '':
  673.                 if (bytestream_feof(file))
  674.                 {
  675.                     gif_done = 1;
  676.                 }
  677.                 break;
  678.             case ';':
  679.                 gif_done = 1;
  680.                 break;
  681.         }
  682.     } while (!gif_done);
  683.     *total_frames = frame_counter;
  684.     printf("Number of frames:%dn", frame_counter);
  685.     return (1);
  686. }
  688. #if 0
  689. /* under construction !*/
  690. /* under construction !*/
  691. /* under construction !*/
  692. /* under construction !*/
  693. /* under construction !*/
  694. /* under construction !*/
  695. /* under construction !*/
  696. /* under construction !*/
  697. /* under construction !*/
  698. /* under construction !*/
  699. /* under construction !*/
  700. /* under construction !*/
  701. /* under construction !*/
  702. /* under construction !*/
  703. /* under construction !*/
  704. /* under construction !*/
  705. /* under construction !*/
  706. /* under construction !*/
  707. /* under construction !*/
  708. /* under construction !*/
  709. /* under construction !*/
  710. /* under construction !*/
  711. /* under construction !*/
  712. /* under construction !*/
  713. /* under construction !*/
  714. /* under construction !*/
  715. /* under construction !*/
  716. /* under construction !*/
  717. /* under construction !*/
  718. /* under construction !*/
  719. /* under construction !*/
  720. /* under construction !*/
  721. /* under construction !*/
  722. /* under construction !*/
  723. /* under construction !*/
  724. /* under construction !*/
  725. /* under construction !*/
  726. /* under construction !*/
  727. /* under construction !*/
  728. /* under construction !*/
  729. /* under construction !*/
  730. /* under construction !*/
  731. /* under construction !*/
  732. /* under construction !*/
  733. /* under construction !*/
  734. /* under construction !*/
  735. /* under construction !*/
  736. /* under construction !*/
  737. /* under construction !*/
  738. /* under construction !*/
  739. /* under construction !*/
  740. /* under construction !*/
  741. /* under construction !*/
  742. /* under construction !*/
  743. /* under construction !*/
  744. /* under construction !*/
  745. /* under construction !*/
  746. /* under construction !*/
  747. /* under construction !*/
  748. /* under construction !*/
  749. /* under construction !*/
  750. /* under construction !*/
  751. /* under construction !*/
  752. /* under construction !*/
  753. /* under construction !*/
  754. /* under construction !*/
  755. /* under construction !*/
  756. /* under construction !*/
  757. /* under construction !*/
  758. /* under construction !*/
  759. /* under construction !*/
  760. /* under construction !*/
  761. /* under construction !*/
  762. /* under construction !*/
  763. /* under construction !*/
  764. /* under construction !*/
  765. /* under construction !*/
  766. /* under construction !*/
  767. /* under construction !*/
  768. /* under construction !*/
  769. /* under construction !*/
  770. /* under construction !*/
  771. /* under construction !*/
  772. /* under construction !*/
  773. /* under construction !*/
  774. /* under construction !*/
  775. /* under construction !*/
  776. /* under construction !*/
  777. /* under construction !*/
  778. /* under construction !*/
  779. /* under construction !*/
  780. /* under construction !*/
  781. /* under construction !*/
  782. /* under construction !*/
  783. /* under construction !*/
  784. /* under construction !*/
  785. /* under construction !*/
  786. /* under construction !*/
  787. /* under construction !*/
  788. /* under construction !*/
  789. /* under construction !*/
  790. /* under construction !*/
  791. /* under construction !*/
  792. /* under construction !*/
  793. /* under construction !*/
  794. /* under construction !*/
  795. /* under construction !*/
  796. /* under construction !*/
  797. /* under construction !*/
  798. /* under construction !*/
  799. /* under construction !*/
  800. /* under construction !*/
  801. /* under construction !*/
  802. /* under construction !*/
  803. /* under construction !*/
  804. /* under construction !*/
  805. /* under construction !*/
  806. /* under construction !*/
  807. /* under construction !*/
  808. /* under construction !*/
  809. /* under construction !*/
  810. /* under construction !*/
  811. /* under construction !*/
  812. /* under construction !*/
  813. /* under construction !*/
  814. /* under construction !*/
  815. /* under construction !*/
  816. /* under construction !*/
  817. /* under construction !*/
  818. /* under construction !*/
  819. /* under construction !*/
  820. /* under construction !*/
  821. /* under construction !*/
  822. /* under construction !*/
  823. /* under construction !*/
  824. /* under construction !*/
  825. /* under construction !*/
  826. /* under construction !*/
  827. /* under construction !*/
  828. /* under construction !*/
  829. /* under construction !*/
  830. #endif /* 0 */ 
  833. /*****************************************************************************
  834.  * FUNCTION
  835.  *  GIFLoader
  836.  * DESCRIPTION
  837.  *  
  838.  * PARAMETERS
  839.  *  in_filename         [?]     
  840.  *  out_filename        [?]     
  841.  * RETURNS
  842.  *  
  843.  *****************************************************************************/
  844. int GIFLoader(char *in_filename, char *out_filename)
  845. {
  846.     /*----------------------------------------------------------------*/
  847.     /* Local Variables                                                */
  848.     /*----------------------------------------------------------------*/
  849.     bitmap outimage;
  850.     FILE *infile;
  851.     FILE *outfile;
  852.     bytestream inimage;
  853.     S32 file_length;
  854.     U8 *buffer;
  855.     S32 i, bitmap_size;
  856.     S32 n_frames, frame_counter, temp_n_frames;
  857.     S32 total_data_size;
  859.     /*----------------------------------------------------------------*/
  860.     /* Code Body                                                      */
  861.     /*----------------------------------------------------------------*/
  862.     infile = fopen(in_filename, "rb");
  863.     if (infile == NULL)
  864.     {
  865.         printf("nError opening %s", in_filename);
  866.         return 0;
  867.     }
  869.     fseek(infile, 0, SEEK_END);
  870.     file_length = ftell(infile);
  871.     fseek(infile, 0, SEEK_SET);
  873.     buffer = (U8*) malloc(file_length);
  874.     if (buffer == NULL)
  875.     {
  876.         printf("nError allocating memory of size %d bytes", file_length);
  877.         fclose(infile);
  878.         return 0;
  879.     }
  881.     fread(buffer, 1, file_length, infile);
  882.     fclose(infile);
  883.     bytestream_initialize(&inimage, buffer, file_length);
  884.     /* Get the number of frames   */
  885.     Load_GIF(&inimage, &n_frames);
  886.     /* GIF_load(&inimage,NULL,DEVICE_COLOR_DEPTH,0,&n_frames); */
  887.     frame_counter = 0;
  889.     free(buffer);
  890.     return 1;
  891. }