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

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

MTK

开发平台：

C/C++

gui_bytestream.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.  *
  38.  * Filename:
  39.  * ---------
  40.  *   gui_bytestream.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   Bytestream Interface for Image Decoder
  49.  *
  50.  *   (Deprecated by gdi_bytestream.c)
  51.  *
  52.  * Author:
  53.  * -------
  54.  *
  55.  *============================================================================
  56.  *             HISTORY
  57.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  58.  *------------------------------------------------------------------------------
  59.  * removed!
  60.  *
  61.  *------------------------------------------------------------------------------
  62.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  63.  *============================================================================
  64.  ****************************************************************************/
  66. /**
  67.  * Copyright Notice
  68.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  69.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  70.  *  (It is illegal to remove this copyright notice from this software or any
  71.  *  portion of it)
  72.  */
  74. /**********************************************************************************
  75.    Filename:      gui_bytestream.c
  76.    Author:        manju
  77.    Date Created:  June-10-2002
  78.    Contains:      bytestream data type
  79.                These are used to process ROM images of binary files
  80. **********************************************************************************/
  82. #include "gui_bytestream.h"
  84. #define GUI_BYTESTREAM_IRAM_PLACEMENT     0
  86. #if(GUI_BYTESTREAM_IRAM_PLACEMENT)
  87. #ifdef __MTK_TARGET__
  88. #pragma arm section code = "INTERNCODE"
  89. #endif 
  90. #endif /* (GUI_BYTESTREAM_IRAM_PLACEMENT) */ 
  93. /*****************************************************************************
  94.  * FUNCTION
  95.  *  bytestream_initialize
  96.  * DESCRIPTION
  97.  *  initialize a bytestraem
  98.  * PARAMETERS
  99.  *  file        [IN]        
  100.  *  data        [IN]        
  101.  *  size        [IN]        
  102.  * RETURNS
  103.  *  void
  104.  *****************************************************************************/
  105. void bytestream_initialize(bytestream *file, U8 *data, S32 size)
  106. {
  107.     /*----------------------------------------------------------------*/
  108.     /* Local Variables                                                */
  109.     /*----------------------------------------------------------------*/
  111.     /*----------------------------------------------------------------*/
  112.     /* Code Body                                                      */
  113.     /*----------------------------------------------------------------*/
  114.     file->data = data;
  115.     file->size = size;
  116.     file->current_offset = 0;
  117. }
  120. /*****************************************************************************
  121.  * FUNCTION
  122.  *  bytestream_fclose
  123.  * DESCRIPTION
  124.  *  close teh file
  125.  * PARAMETERS
  126.  *  file        [IN]        
  127.  * RETURNS
  128.  *  void
  129.  *****************************************************************************/
  130. void bytestream_fclose(bytestream *file)
  131. {
  132.     /*----------------------------------------------------------------*/
  133.     /* Local Variables                                                */
  134.     /*----------------------------------------------------------------*/
  136.     /*----------------------------------------------------------------*/
  137.     /* Code Body                                                      */
  138.     /*----------------------------------------------------------------*/
  139.     file->data = NULL;
  140.     file->size = 0;
  141.     file->current_offset = 0;
  142. }
  145. /*****************************************************************************
  146.  * FUNCTION
  147.  *  bytestream_fseek
  148.  * DESCRIPTION
  149.  *  seek a file pointer to particular position
  150.  * PARAMETERS
  151.  *  file        [IN]        
  152.  *  offset      [IN]        
  153.  *  mode        [IN]        
  154.  * RETURNS
  155.  *  byte- //true or false
  156.  *****************************************************************************/
  157. U8 bytestream_fseek(bytestream *file, S32 offset, S32 mode)
  158. {
  159.     /*----------------------------------------------------------------*/
  160.     /* Local Variables                                                */
  161.     /*----------------------------------------------------------------*/
  162.     S32 start_offset, final_offset;
  164.     /*----------------------------------------------------------------*/
  165.     /* Code Body                                                      */
  166.     /*----------------------------------------------------------------*/
  167.     switch (mode)
  168.     {
  169.         case SEEK_END:
  170.             start_offset = file->size - 1;
  171.             break;
  172.         case SEEK_SET:
  173.             start_offset = 0;
  174.             break;
  175.         case SEEK_CUR:
  176.         default:
  177.             start_offset = file->current_offset;
  178.             break;
  179.     }
  180.     final_offset = start_offset + offset;
  181.     if (final_offset < 0 || final_offset >= file->size)
  182.     {
  183.         return (1);
  184.     }
  185.     else
  186.     {
  187.         file->current_offset = final_offset;
  188.         return (0);
  189.     }
  190. }
  193. /*****************************************************************************
  194.  * FUNCTION
  195.  *  bytestream_feof
  196.  * DESCRIPTION
  197.  *  check if end of file
  198.  * PARAMETERS
  199.  *  file        [IN]        
  200.  * RETURNS
  201.  *  byte- //true or false
  202.  *****************************************************************************/
  203. U8 bytestream_feof(bytestream *file)
  204. {
  205.     /*----------------------------------------------------------------*/
  206.     /* Local Variables                                                */
  207.     /*----------------------------------------------------------------*/
  209.     /*----------------------------------------------------------------*/
  210.     /* Code Body                                                      */
  211.     /*----------------------------------------------------------------*/
  212.     if (file->current_offset >= file->size)
  213.     {
  214.         return (1);
  215.     }
  216.     else
  217.     {
  218.         return (0);
  219.     }
  220. }
  223. /*****************************************************************************
  224.  * FUNCTION
  225.  *  bytestream_fgetbyte
  226.  * DESCRIPTION
  227.  *  read a byte from fiel
  228.  * PARAMETERS
  229.  *  file        [IN]        
  230.  * RETURNS
  231.  *  byte-
  232.  *****************************************************************************/
  233. U8 bytestream_fgetbyte(bytestream *file)
  234. {
  235.     /*----------------------------------------------------------------*/
  236.     /* Local Variables                                                */
  237.     /*----------------------------------------------------------------*/
  238.     U8 c;
  240.     /*----------------------------------------------------------------*/
  241.     /* Code Body                                                      */
  242.     /*----------------------------------------------------------------*/
  243.     if (bytestream_feof(file))
  244.     {
  245.         return (0);
  246.     }
  247.     c = file->data[file->current_offset];
  248.     file->current_offset++;
  249.     return (c);
  250. }
  253. /*****************************************************************************
  254.  * FUNCTION
  255.  *  bytestream_fputbyte
  256.  * DESCRIPTION
  257.  *  insert a byte in file
  258.  * PARAMETERS
  259.  *  file        [IN]        
  260.  *  c           [IN]        
  261.  * RETURNS
  262.  *  byte- true or flase
  263.  *****************************************************************************/
  264. U8 bytestream_fputbyte(bytestream *file, U8 c)
  265. {
  266.     /*----------------------------------------------------------------*/
  267.     /* Local Variables                                                */
  268.     /*----------------------------------------------------------------*/
  270.     /*----------------------------------------------------------------*/
  271.     /* Code Body                                                      */
  272.     /*----------------------------------------------------------------*/
  273.     if (bytestream_feof(file))
  274.     {
  275.         return (0);
  276.     }
  277.     file->data[file->current_offset] = c;
  278.     file->current_offset++;
  279.     return (1);
  280. }
  283. /*****************************************************************************
  284.  * FUNCTION
  285.  *  bytestream_fread
  286.  * DESCRIPTION
  287.  *  get  word
  288.  * PARAMETERS
  289.  *  buffer      [OUT]       Data read from file
  290.  *  size        [IN]        // size of data
  291.  *  number      [IN]        // number of bytes to read
  292.  *  file        [IN]        File pointer
  293.  * RETURNS
  294.  *  size_t return number of bytes read from file
  295.  *****************************************************************************/
  296. size_t bytestream_fread(U8 *buffer, size_t size, size_t number, bytestream *file)
  297. {
  298.     /*----------------------------------------------------------------*/
  299.     /* Local Variables                                                */
  300.     /*----------------------------------------------------------------*/
  301.     U32 count = 0, i;
  303.     /*----------------------------------------------------------------*/
  304.     /* Code Body                                                      */
  305.     /*----------------------------------------------------------------*/
  306.     for (i = (U32) size * number; i; i--)
  307.     {
  308.         if (bytestream_feof(file))
  309.         {
  310.             break;
  311.         }
  312.         buffer[count++] = bytestream_fgetbyte(file);
  313.     }
  314.     return (count);
  315. }
  318. /*****************************************************************************
  319.  * FUNCTION
  320.  *  bytestream_fgetword
  321.  * DESCRIPTION
  322.  *  get  word
  323.  * PARAMETERS
  324.  *  file            [?]         
  325.  *  pointer(?)      [IN]        Of file
  326.  * RETURNS
  327.  *  word
  328.  *****************************************************************************/
  329. U16 bytestream_fgetword(bytestream *file)
  330. {
  331.     /*----------------------------------------------------------------*/
  332.     /* Local Variables                                                */
  333.     /*----------------------------------------------------------------*/
  334.     U16 MSB, LSB;
  336.     /*----------------------------------------------------------------*/
  337.     /* Code Body                                                      */
  338.     /*----------------------------------------------------------------*/
  339.     LSB = bytestream_fgetbyte(file);
  340.     MSB = bytestream_fgetbyte(file);
  341.     return ((U16) ((MSB << 8) | LSB));
  342. }
  345. /*****************************************************************************
  346.  * FUNCTION
  347.  *  bytestream_fgetdword
  348.  * DESCRIPTION
  349.  *  get  U32
  350.  * PARAMETERS
  351.  *  file            [?]         
  352.  *  pointer(?)      [IN]        Of file
  353.  * RETURNS
  354.  *  U32
  355.  *****************************************************************************/
  356. U32 bytestream_fgetdword(bytestream *file)
  357. {
  358.     /*----------------------------------------------------------------*/
  359.     /* Local Variables                                                */
  360.     /*----------------------------------------------------------------*/
  361.     U32 MSB, LSB;
  363.     /*----------------------------------------------------------------*/
  364.     /* Code Body                                                      */
  365.     /*----------------------------------------------------------------*/
  366.     LSB = bytestream_fgetword(file);
  367.     MSB = bytestream_fgetword(file);
  368.     return ((MSB << 16) | LSB);
  369. }
  372. /*****************************************************************************
  373.  * FUNCTION
  374.  *  bytestream_fputword
  375.  * DESCRIPTION
  376.  *  insert  word in  big endian format in file
  377.  * PARAMETERS
  378.  *  file            [?]         
  379.  *  w               [IN]        
  380.  *  word(?)         [IN]        D
  381.  *  pointer(?)      [IN]        Of file
  382.  * RETURNS
  383.  *  byte
  384.  *****************************************************************************/
  385. U8 bytestream_fputword(bytestream *file, U16 w)
  386. {
  387.     /*----------------------------------------------------------------*/
  388.     /* Local Variables                                                */
  389.     /*----------------------------------------------------------------*/
  390.     U8 MSB, LSB, rvalue;
  392.     /*----------------------------------------------------------------*/
  393.     /* Code Body                                                      */
  394.     /*----------------------------------------------------------------*/
  395.     LSB = (U8) (w & 0xff);
  396.     MSB = (U8) (w >> 8);
  397.     rvalue = bytestream_fputbyte(file, LSB);
  398.     rvalue = bytestream_fputbyte(file, MSB);
  399.     return (rvalue);
  400. }
  403. /*****************************************************************************
  404.  * FUNCTION
  405.  *  bytestream_fputword_bigendian
  406.  * DESCRIPTION
  407.  *  insert  word in  big endian format in file
  408.  * PARAMETERS
  409.  *  file            [?]         
  410.  *  w               [IN]        
  411.  *  word(?)         [IN]        D
  412.  *  pointer(?)      [IN]        Of file
  413.  * RETURNS
  414.  *  byte
  415.  *****************************************************************************/
  416. U8 bytestream_fputword_bigendian(bytestream *file, U16 w)
  417. {
  418.     /*----------------------------------------------------------------*/
  419.     /* Local Variables                                                */
  420.     /*----------------------------------------------------------------*/
  421.     U8 MSB, LSB, rvalue;
  423.     /*----------------------------------------------------------------*/
  424.     /* Code Body                                                      */
  425.     /*----------------------------------------------------------------*/
  426.     LSB = (U8) (w & 0xff);
  427.     MSB = (U8) (w >> 8);
  428.     rvalue = bytestream_fputbyte(file, MSB);
  429.     rvalue = bytestream_fputbyte(file, LSB);
  430.     return (rvalue);
  431. }
  434. /*****************************************************************************
  435.  * FUNCTION
  436.  *  bytestream_fputdword
  437.  * DESCRIPTION
  438.  *  insert  U32 in  big endian format in file
  439.  * PARAMETERS
  440.  *  file            [?]         
  441.  *  d               [IN]        
  442.  *  pointer(?)      [IN]        Of file
  443.  * RETURNS
  444.  *  byte
  445.  *****************************************************************************/
  446. U8 bytestream_fputdword(bytestream *file, U32 d)
  447. {
  448.     /*----------------------------------------------------------------*/
  449.     /* Local Variables                                                */
  450.     /*----------------------------------------------------------------*/
  451.     U16 MSB, LSB;
  452.     U8 rvalue;
  454.     /*----------------------------------------------------------------*/
  455.     /* Code Body                                                      */
  456.     /*----------------------------------------------------------------*/
  457.     LSB = (U16) (d & 0xffff);
  458.     MSB = (U16) (d >> 16);
  459.     rvalue = bytestream_fputword(file, LSB);
  460.     rvalue = bytestream_fputword(file, MSB);
  461.     return (rvalue);
  462. }
  465. /*****************************************************************************
  466.  * FUNCTION
  467.  *  bytestream_fputdword_bigendian
  468.  * DESCRIPTION
  469.  *  insert  U32 in  big endian format in file
  470.  * PARAMETERS
  471.  *  file            [?]         
  472.  *  d               [IN]        
  473.  *  pointer(?)      [IN]        Of file
  474.  * RETURNS
  475.  *  byte
  476.  *****************************************************************************/
  477. U8 bytestream_fputdword_bigendian(bytestream *file, U32 d)
  478. {
  479.     /*----------------------------------------------------------------*/
  480.     /* Local Variables                                                */
  481.     /*----------------------------------------------------------------*/
  482.     U16 MSB, LSB;
  483.     U8 rvalue;
  485.     /*----------------------------------------------------------------*/
  486.     /* Code Body                                                      */
  487.     /*----------------------------------------------------------------*/
  488.     LSB = (U16) (d & 0xffff);
  489.     MSB = (U16) (d >> 16);
  490.     rvalue = bytestream_fputword_bigendian(file, MSB);
  491.     rvalue = bytestream_fputword_bigendian(file, LSB);
  492.     return (rvalue);
  493. }
  496. /*****************************************************************************
  497.  * FUNCTION
  498.  *  bytestream_fgetword_bigendian
  499.  * DESCRIPTION
  500.  *  get word in  big endian format fron file
  501.  * PARAMETERS
  502.  *  file            [?]         
  503.  *  pointer(?)      [IN]        Of file
  504.  * RETURNS
  505.  *  word
  506.  *****************************************************************************/
  507. U16 bytestream_fgetword_bigendian(bytestream *file)
  508. {
  509.     /*----------------------------------------------------------------*/
  510.     /* Local Variables                                                */
  511.     /*----------------------------------------------------------------*/
  512.     U16 MSB, LSB;
  514.     /*----------------------------------------------------------------*/
  515.     /* Code Body                                                      */
  516.     /*----------------------------------------------------------------*/
  517.     MSB = bytestream_fgetbyte(file);
  518.     LSB = bytestream_fgetbyte(file);
  519.     return ((U16) ((MSB << 8) | LSB));
  520. }
  523. /*****************************************************************************
  524.  * FUNCTION
  525.  *  bytestream_fgetdword_bigendian
  526.  * DESCRIPTION
  527.  *  get dwordin big endian format fron file
  528.  * PARAMETERS
  529.  *  file            [?]         
  530.  *  pointer(?)      [IN]        Of file
  531.  * RETURNS
  532.  *  U32
  533.  *****************************************************************************/
  534. U32 bytestream_fgetdword_bigendian(bytestream *file)
  535. {
  536.     /*----------------------------------------------------------------*/
  537.     /* Local Variables                                                */
  538.     /*----------------------------------------------------------------*/
  539.     U32 MSB, LSB;
  541.     /*----------------------------------------------------------------*/
  542.     /* Code Body                                                      */
  543.     /*----------------------------------------------------------------*/
  544.     MSB = bytestream_fgetword_bigendian(file);
  545.     LSB = bytestream_fgetword_bigendian(file);
  546.     return ((MSB << 16) | LSB);
  547. }
  549. #if(GUI_BYTESTREAM_IRAM_PLACEMENT)
  550. #ifdef __MTK_TARGET__
  551. #pragma arm section code
  552. #endif 
  553. #endif /* (GUI_BYTESTREAM_IRAM_PLACEMENT) */ 
  556. /*****************************************************************************
  557.  * FUNCTION
  558.  *  bytestream_fgetvdata
  559.  * DESCRIPTION
  560.  *  Used to read variable length data: Useful only for MIDI files
  561.  * PARAMETERS
  562.  *  file            [?]         
  563.  *  pointer(?)      [IN]        Of file
  564.  * RETURNS
  565.  *  void
  566.  *****************************************************************************/
  567. /* Used to read variable length data: Useful only for MIDI files  */
  568. U32 bytestream_fgetvdata(bytestream *file)
  569. {
  570.     /*----------------------------------------------------------------*/
  571.     /* Local Variables                                                */
  572.     /*----------------------------------------------------------------*/
  573.     U32 rvalue;
  574.     U8 b;
  576.     /*----------------------------------------------------------------*/
  577.     /* Code Body                                                      */
  578.     /*----------------------------------------------------------------*/
  579.     if ((rvalue = bytestream_fgetbyte(file)) & 0x80)
  580.     {
  581.         rvalue &= 0x7f;
  582.         do
  583.         {
  584.             rvalue = (rvalue << 7) + ((b = bytestream_fgetbyte(file)) & 0x7f);
  585.         } while (b & 0x80);
  586.     }
  587.     return (rvalue);
  588. }