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

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

MTK

开发平台：

C/C++

ResBytestream.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.  *  ResBytestream.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. /**
  65.  * Copyright Notice
  66.  * (c) 2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  67.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  68.  *  (It is illegal to remove this copyright notice from this software or any
  69.  *  portion of it)
  70.  */
  72. /**********************************************************************************
  73.    External tool required for the MMI
  75.    Filename:      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 "ResBytestream.h"
  85. /*****************************************************************************
  86.  * FUNCTION
  87.  *  bytestream_initialize
  88.  * DESCRIPTION
  89.  *  
  90.  * PARAMETERS
  91.  *  file        [?]         
  92.  *  data        [?]         
  93.  *  size        [IN]        
  94.  * RETURNS
  95.  *  void
  96.  *****************************************************************************/
  97. void bytestream_initialize(bytestream *file, U8 *data, long int size)
  98. {
  99.     /*----------------------------------------------------------------*/
  100.     /* Local Variables                                                */
  101.     /*----------------------------------------------------------------*/
  103.     /*----------------------------------------------------------------*/
  104.     /* Code Body                                                      */
  105.     /*----------------------------------------------------------------*/
  106.     file->data = data;
  107.     file->size = size;
  108.     file->current_offset = 0;
  109. }
  112. /*****************************************************************************
  113.  * FUNCTION
  114.  *  bytestream_fclose
  115.  * DESCRIPTION
  116.  *  
  117.  * PARAMETERS
  118.  *  file        [?]     
  119.  * RETURNS
  120.  *  void
  121.  *****************************************************************************/
  122. void bytestream_fclose(bytestream *file)
  123. {
  124.     /*----------------------------------------------------------------*/
  125.     /* Local Variables                                                */
  126.     /*----------------------------------------------------------------*/
  128.     /*----------------------------------------------------------------*/
  129.     /* Code Body                                                      */
  130.     /*----------------------------------------------------------------*/
  131.     file->data = NULL;
  132.     file->size = 0;
  133.     file->current_offset = 0;
  134. }
  137. /*****************************************************************************
  138.  * FUNCTION
  139.  *  bytestream_fseek
  140.  * DESCRIPTION
  141.  *  
  142.  * PARAMETERS
  143.  *  file        [?]         
  144.  *  offset      [IN]        
  145.  *  mode        [IN]        
  146.  * RETURNS
  147.  *  
  148.  *****************************************************************************/
  149. U8 bytestream_fseek(bytestream *file, long int offset, int mode)
  150. {
  151.     /*----------------------------------------------------------------*/
  152.     /* Local Variables                                                */
  153.     /*----------------------------------------------------------------*/
  154.     int start_offset, final_offset;
  156.     /*----------------------------------------------------------------*/
  157.     /* Code Body                                                      */
  158.     /*----------------------------------------------------------------*/
  159.     switch (mode)
  160.     {
  161.         case SEEK_END:
  162.             start_offset = file->size - 1;
  163.             break;
  164.         case SEEK_SET:
  165.             start_offset = 0;
  166.             break;
  167.         case SEEK_CUR:
  168.         default:
  169.             start_offset = file->current_offset;
  170.             break;
  171.     }
  172.     final_offset = start_offset + offset;
  173.     if (final_offset < 0 || final_offset >= file->size)
  174.     {
  175.         return (1);
  176.     }
  177.     else
  178.     {
  179.         file->current_offset = final_offset;
  180.         return (0);
  181.     }
  182. }
  185. /*****************************************************************************
  186.  * FUNCTION
  187.  *  bytestream_feof
  188.  * DESCRIPTION
  189.  *  
  190.  * PARAMETERS
  191.  *  file        [?]     
  192.  * RETURNS
  193.  *  
  194.  *****************************************************************************/
  195. U8 bytestream_feof(bytestream *file)
  196. {
  197.     /*----------------------------------------------------------------*/
  198.     /* Local Variables                                                */
  199.     /*----------------------------------------------------------------*/
  201.     /*----------------------------------------------------------------*/
  202.     /* Code Body                                                      */
  203.     /*----------------------------------------------------------------*/
  204.     if (file->current_offset >= file->size)
  205.     {
  206.         return (1);
  207.     }
  208.     else
  209.     {
  210.         return (0);
  211.     }
  212. }
  215. /*****************************************************************************
  216.  * FUNCTION
  217.  *  bytestream_fgetbyte
  218.  * DESCRIPTION
  219.  *  
  220.  * PARAMETERS
  221.  *  file        [?]     
  222.  * RETURNS
  223.  *  
  224.  *****************************************************************************/
  225. U8 bytestream_fgetbyte(bytestream *file)
  226. {
  227.     /*----------------------------------------------------------------*/
  228.     /* Local Variables                                                */
  229.     /*----------------------------------------------------------------*/
  230.     U8 c;
  232.     /*----------------------------------------------------------------*/
  233.     /* Code Body                                                      */
  234.     /*----------------------------------------------------------------*/
  235.     if (bytestream_feof(file))
  236.     {
  237.         return (0);
  238.     }
  239.     c = file->data[file->current_offset];
  240.     file->current_offset++;
  241.     return (c);
  242. }
  245. /*****************************************************************************
  246.  * FUNCTION
  247.  *  bytestream_fputbyte
  248.  * DESCRIPTION
  249.  *  
  250.  * PARAMETERS
  251.  *  file        [?]         
  252.  *  c           [IN]        
  253.  * RETURNS
  254.  *  
  255.  *****************************************************************************/
  256. U8 bytestream_fputbyte(bytestream *file, U8 c)
  257. {
  258.     /*----------------------------------------------------------------*/
  259.     /* Local Variables                                                */
  260.     /*----------------------------------------------------------------*/
  262.     /*----------------------------------------------------------------*/
  263.     /* Code Body                                                      */
  264.     /*----------------------------------------------------------------*/
  265.     if (bytestream_feof(file))
  266.     {
  267.         return (0);
  268.     }
  269.     file->data[file->current_offset] = c;
  270.     file->current_offset++;
  271.     return (1);
  272. }
  275. /*****************************************************************************
  276.  * FUNCTION
  277.  *  bytestream_fread
  278.  * DESCRIPTION
  279.  *  
  280.  * PARAMETERS
  281.  *  buffer      [?]         
  282.  *  size        [IN]        
  283.  *  number      [IN]        
  284.  *  file        [?]         
  285.  * RETURNS
  286.  *  
  287.  *****************************************************************************/
  288. size_t bytestream_fread(U8 *buffer, size_t size, size_t number, bytestream *file)
  289. {
  290.     /*----------------------------------------------------------------*/
  291.     /* Local Variables                                                */
  292.     /*----------------------------------------------------------------*/
  293.     unsigned long int count = 0, i;
  295.     /*----------------------------------------------------------------*/
  296.     /* Code Body                                                      */
  297.     /*----------------------------------------------------------------*/
  298.     for (i = 0; i < (long)size * number; i++)
  299.     {
  300.         if (bytestream_feof(file))
  301.         {
  302.             break;
  303.         }
  304.         buffer[count++] = bytestream_fgetbyte(file);
  305.     }
  306.     return (count);
  307. }
  310. /*****************************************************************************
  311.  * FUNCTION
  312.  *  bytestream_fgetword
  313.  * DESCRIPTION
  314.  *  
  315.  * PARAMETERS
  316.  *  file        [?]     
  317.  * RETURNS
  318.  *  
  319.  *****************************************************************************/
  320. U16 bytestream_fgetword(bytestream *file)
  321. {
  322.     /*----------------------------------------------------------------*/
  323.     /* Local Variables                                                */
  324.     /*----------------------------------------------------------------*/
  325.     U16 MSB, LSB;
  327.     /*----------------------------------------------------------------*/
  328.     /* Code Body                                                      */
  329.     /*----------------------------------------------------------------*/
  330.     LSB = bytestream_fgetbyte(file);
  331.     MSB = bytestream_fgetbyte(file);
  332.     return ((MSB << 8) | LSB);
  333. }
  336. /*****************************************************************************
  337.  * FUNCTION
  338.  *  bytestream_fgetdword
  339.  * DESCRIPTION
  340.  *  
  341.  * PARAMETERS
  342.  *  file        [?]     
  343.  * RETURNS
  344.  *  
  345.  *****************************************************************************/
  346. U32 bytestream_fgetdword(bytestream *file)
  347. {
  348.     /*----------------------------------------------------------------*/
  349.     /* Local Variables                                                */
  350.     /*----------------------------------------------------------------*/
  351.     U32 MSB, LSB;
  353.     /*----------------------------------------------------------------*/
  354.     /* Code Body                                                      */
  355.     /*----------------------------------------------------------------*/
  356.     LSB = bytestream_fgetword(file);
  357.     MSB = bytestream_fgetword(file);
  358.     return ((MSB << 16) | LSB);
  359. }
  362. /*****************************************************************************
  363.  * FUNCTION
  364.  *  bytestream_fputword
  365.  * DESCRIPTION
  366.  *  
  367.  * PARAMETERS
  368.  *  file        [?]         
  369.  *  w           [IN]        
  370.  * RETURNS
  371.  *  
  372.  *****************************************************************************/
  373. U8 bytestream_fputword(bytestream *file, U16 w)
  374. {
  375.     /*----------------------------------------------------------------*/
  376.     /* Local Variables                                                */
  377.     /*----------------------------------------------------------------*/
  378.     U8 MSB, LSB, rvalue;
  380.     /*----------------------------------------------------------------*/
  381.     /* Code Body                                                      */
  382.     /*----------------------------------------------------------------*/
  383.     LSB = w & 0xff;
  384.     MSB = w >> 8;
  385.     rvalue = bytestream_fputbyte(file, LSB);
  386.     rvalue = bytestream_fputbyte(file, MSB);
  387.     return (rvalue);
  388. }
  391. /*****************************************************************************
  392.  * FUNCTION
  393.  *  bytestream_fputword_bigendian
  394.  * DESCRIPTION
  395.  *  
  396.  * PARAMETERS
  397.  *  file        [?]         
  398.  *  w           [IN]        
  399.  * RETURNS
  400.  *  
  401.  *****************************************************************************/
  402. U8 bytestream_fputword_bigendian(bytestream *file, U16 w)
  403. {
  404.     /*----------------------------------------------------------------*/
  405.     /* Local Variables                                                */
  406.     /*----------------------------------------------------------------*/
  407.     U8 MSB, LSB, rvalue;
  409.     /*----------------------------------------------------------------*/
  410.     /* Code Body                                                      */
  411.     /*----------------------------------------------------------------*/
  412.     LSB = w & 0xff;
  413.     MSB = w >> 8;
  414.     rvalue = bytestream_fputbyte(file, MSB);
  415.     rvalue = bytestream_fputbyte(file, LSB);
  416.     return (rvalue);
  417. }
  420. /*****************************************************************************
  421.  * FUNCTION
  422.  *  bytestream_fputdword
  423.  * DESCRIPTION
  424.  *  
  425.  * PARAMETERS
  426.  *  file        [?]         
  427.  *  d           [IN]        
  428.  * RETURNS
  429.  *  
  430.  *****************************************************************************/
  431. U8 bytestream_fputdword(bytestream *file, U32 d)
  432. {
  433.     /*----------------------------------------------------------------*/
  434.     /* Local Variables                                                */
  435.     /*----------------------------------------------------------------*/
  436.     U16 MSB, LSB;
  437.     U8 rvalue;
  439.     /*----------------------------------------------------------------*/
  440.     /* Code Body                                                      */
  441.     /*----------------------------------------------------------------*/
  442.     LSB = (U16) d & 0xffff;
  443.     MSB = (U16) d >> 16;
  444.     rvalue = bytestream_fputword(file, LSB);
  445.     rvalue = bytestream_fputword(file, MSB);
  446.     return (rvalue);
  447. }
  450. /*****************************************************************************
  451.  * FUNCTION
  452.  *  bytestream_fputdword_bigendian
  453.  * DESCRIPTION
  454.  *  
  455.  * PARAMETERS
  456.  *  file        [?]         
  457.  *  d           [IN]        
  458.  * RETURNS
  459.  *  
  460.  *****************************************************************************/
  461. U8 bytestream_fputdword_bigendian(bytestream *file, U32 d)
  462. {
  463.     /*----------------------------------------------------------------*/
  464.     /* Local Variables                                                */
  465.     /*----------------------------------------------------------------*/
  466.     U16 MSB, LSB;
  467.     U8 rvalue;
  469.     /*----------------------------------------------------------------*/
  470.     /* Code Body                                                      */
  471.     /*----------------------------------------------------------------*/
  472.     LSB = (U16) d & 0xffff;
  473.     MSB = (U16) d >> 16;
  474.     rvalue = bytestream_fputword_bigendian(file, MSB);
  475.     rvalue = bytestream_fputword_bigendian(file, LSB);
  476.     return (rvalue);
  477. }
  480. /*****************************************************************************
  481.  * FUNCTION
  482.  *  bytestream_fgetword_bigendian
  483.  * DESCRIPTION
  484.  *  
  485.  * PARAMETERS
  486.  *  file        [?]     
  487.  * RETURNS
  488.  *  
  489.  *****************************************************************************/
  490. U16 bytestream_fgetword_bigendian(bytestream *file)
  491. {
  492.     /*----------------------------------------------------------------*/
  493.     /* Local Variables                                                */
  494.     /*----------------------------------------------------------------*/
  495.     U16 MSB, LSB;
  497.     /*----------------------------------------------------------------*/
  498.     /* Code Body                                                      */
  499.     /*----------------------------------------------------------------*/
  500.     MSB = bytestream_fgetbyte(file);
  501.     LSB = bytestream_fgetbyte(file);
  502.     return ((MSB << 8) | LSB);
  503. }
  506. /*****************************************************************************
  507.  * FUNCTION
  508.  *  bytestream_fgetdword_bigendian
  509.  * DESCRIPTION
  510.  *  
  511.  * PARAMETERS
  512.  *  file        [?]     
  513.  * RETURNS
  514.  *  
  515.  *****************************************************************************/
  516. U32 bytestream_fgetdword_bigendian(bytestream *file)
  517. {
  518.     /*----------------------------------------------------------------*/
  519.     /* Local Variables                                                */
  520.     /*----------------------------------------------------------------*/
  521.     U32 MSB, LSB;
  523.     /*----------------------------------------------------------------*/
  524.     /* Code Body                                                      */
  525.     /*----------------------------------------------------------------*/
  526.     MSB = bytestream_fgetword_bigendian(file);
  527.     LSB = bytestream_fgetword_bigendian(file);
  528.     return ((MSB << 16) | LSB);
  529. }
  531. /* Used to read variable length data: Useful only for MIDI files  */
  534. /*****************************************************************************
  535.  * FUNCTION
  536.  *  bytestream_fgetvdata
  537.  * DESCRIPTION
  538.  *  
  539.  * PARAMETERS
  540.  *  file        [?]     
  541.  * RETURNS
  542.  *  
  543.  *****************************************************************************/
  544. U32 bytestream_fgetvdata(bytestream *file)
  545. {
  546.     /*----------------------------------------------------------------*/
  547.     /* Local Variables                                                */
  548.     /*----------------------------------------------------------------*/
  549.     U32 rvalue;
  550.     U8 b;
  552.     /*----------------------------------------------------------------*/
  553.     /* Code Body                                                      */
  554.     /*----------------------------------------------------------------*/
  555.     if ((rvalue = bytestream_fgetbyte(file)) & 0x80)
  556.     {
  557.         rvalue &= 0x7f;
  558.         do
  559.         {
  560.             rvalue = (rvalue << 7) + ((b = bytestream_fgetbyte(file)) & 0x7f);
  561.         } while (b & 0x80);
  562.     }
  563.     return (rvalue);
  564. }