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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
Fx_ufer.c
资源名称：tb_i86_wr_1019_1102.　[点击查看]
上传用户：super_houu
上传日期：2008-09-21
资源大小：4099k
文件大小：14k
源码类别：

DVD

开发平台：

Others

Fx_ufer.c：源码内容
  1. /**************************************************************************/ 
  2. /*                                                                        */ 
  3. /*            Copyright (c) 1996-2002 by Express Logic Inc.               */ 
  4. /*                                                                        */ 
  5. /*  This software is copyrighted by and is the sole property of Express   */ 
  6. /*  Logic, Inc.  All rights, title, ownership, or other interests         */ 
  7. /*  in the software remain the property of Express Logic, Inc.  This      */ 
  8. /*  software may only be used in accordance with the corresponding        */ 
  9. /*  license agreement.  Any unauthorized use, duplication, transmission,  */ 
  10. /*  distribution, or disclosure of this software is expressly forbidden.  */ 
  11. /*                                                                        */
  12. /*  This Copyright notice may not be removed or modified without prior    */ 
  13. /*  written consent of Express Logic, Inc.                                */ 
  14. /*                                                                        */ 
  15. /*  Express Logic, Inc. reserves the right to modify this software        */ 
  16. /*  without notice.                                                       */ 
  17. /*                                                                        */ 
  18. /*  Express Logic, Inc.                     info@expresslogic.com         */
  19. /*  11423 West Bernardo Court               http://www.expresslogic.com   */
  20. /*  San Diego, CA  92127                                                  */
  21. /*                                                                        */
  22. /**************************************************************************/
  25. /**************************************************************************/
  26. /**************************************************************************/
  27. /**                                                                       */ 
  28. /** FileX Component                                                       */ 
  29. /**                                                                       */
  30. /**   Utility (UTI)                                                       */
  31. /**                                                                       */
  32. /**************************************************************************/
  33. /**************************************************************************/
  35. #include "Config.h" // Global Configuration - do not remove!
  37. #ifdef ENABLE_FILEX
  39. #ifdef _DEBUG
  40. #undef IFTRACE
  41. #define IFTRACE if (gTraceFileSys)
  42. #include "DebugDbgMain.h"
  43. #endif //_DEBUG
  45. #define FX_SOURCE_CODE
  48. /* Include necessary system files.  */
  50. #include "PlaycoreFileSysFileXfx_api.h"
  51. #include "PlaycoreFileSysFileXfx_sys.h"
  52. #include "PlaycoreFileSysFileXfx_uti.h"
  55. /**************************************************************************/ 
  56. /*                                                                        */ 
  57. /*  FUNCTION                                               RELEASE        */ 
  58. /*                                                                        */ 
  59. /*    _fx_utility_FAT_entry_read                          PORTABLE C      */ 
  60. /*                                                           3.0          */ 
  61. /*  AUTHOR                                                                */ 
  62. /*                                                                        */ 
  63. /*    William E. Lamie, Express Logic, Inc.                               */ 
  64. /*                                                                        */ 
  65. /*  DESCRIPTION                                                           */ 
  66. /*                                                                        */ 
  67. /*    This function reads the supplied FAT entry from the first FAT of    */ 
  68. /*    the media.  Both 12-bit and 16-bit FAT reading is supported, while  */ 
  69. /*    only 16-bit information is returned.                                */ 
  70. /*                                                                        */ 
  71. /*  INPUT                                                                 */ 
  72. /*                                                                        */ 
  73. /*    media_ptr                             Media control block pointer   */ 
  74. /*    cluster                               Cluster entry number          */ 
  75. /*    entry_ptr                             Pointer to destination for    */ 
  76. /*                                            the FAT entry               */ 
  77. /*                                                                        */ 
  78. /*  OUTPUT                                                                */ 
  79. /*                                                                        */ 
  80. /*    return status                                                       */ 
  81. /*                                                                        */ 
  82. /*  CALLS                                                                 */ 
  83. /*                                                                        */ 
  84. /*    _fx_utility_16_unsigned_read          Read a UINT from FAT buffer   */ 
  85. /*    _fx_utility_log_sector_read           Read FAT sector into memory   */ 
  86. /*                                                                        */ 
  87. /*  CALLED BY                                                             */ 
  88. /*                                                                        */ 
  89. /*    FileX System Functions                                              */ 
  90. /*                                                                        */ 
  91. /*  RELEASE HISTORY                                                       */ 
  92. /*                                                                        */ 
  93. /*    DATE              NAME                      DESCRIPTION             */ 
  94. /*                                                                        */ 
  95. /*  01-01-1999     William E. Lamie         Initial Version 1.0           */ 
  96. /*  03-01-2000     William E. Lamie         Modified comment(s), modified */ 
  97. /*                                            12-bit sign extension, and  */ 
  98. /*                                            modified byte offsets for   */ 
  99. /*                                            16-bit FAT entries,         */ 
  100. /*                                            resulting in version 1.0b.  */ 
  101. /*  01-28-2001     William E. Lamie         Modified comment(s),          */ 
  102. /*                                            resulting in version 2.0.   */
  103. /*  03-01-2002     Mohammad N. Minhaz       Modified comment(s), and      */ 
  104. /*                                            added logic for reading     */ 
  105. /*                                            FAT32 entries, resulting in */ 
  106. /*                                            version 3.0.                */ 
  107. /*                                                                        */ 
  108. /**************************************************************************/ 
  109. UINT  _fx_utility_FAT_entry_read(FX_MEDIA *media_ptr, ULONG cluster, ULONG *entry_ptr)
  110. {
  112. ULONG       FAT_sector;
  113. ULONG       byte_offset, entry32;
  114. UCHAR_PTR   FAT_ptr;
  115. UINT        entry;
  116. UINT        status;
  119.     /* Determine which type of FAT is present.  */
  120.     if (media_ptr -> fx_media_12_bit_FAT)
  121.     {
  123.         /* Calculate the byte offset to the cluster entry.  */
  124.         byte_offset =  (((ULONG) cluster << 1) + cluster) >> 1;
  126.         /* Calculate the FAT sector the requested FAT entry resides in.  */
  127.         FAT_sector =  (byte_offset / media_ptr -> fx_media_bytes_per_sector) +
  128.                         (ULONG) media_ptr -> fx_media_reserved_sectors;
  130.         /* Read the sector in.  */
  131.         status =  _fx_utility_log_sector_read(media_ptr, (ULONG) FAT_sector, 
  132.                                         media_ptr -> fx_media_memory_buffer, (ULONG) 1);
  134.         /* Determine if an error occurred.  */
  135.         if (status != FX_SUCCESS)
  136.         {
  137.             /* Return the error status.  */
  138.             return(status);
  139.         }
  142.         /* Now calculate the byte offset into this FAT sector.  */
  143.         byte_offset =  byte_offset -  
  144.                     ((FAT_sector - (ULONG) media_ptr -> fx_media_reserved_sectors) *
  145.                         media_ptr -> fx_media_bytes_per_sector); 
  147.         /* Setup a pointer into the buffer.  */
  148.         FAT_ptr =  (UCHAR_PTR) media_ptr -> fx_media_memory_buffer + (UINT) byte_offset;
  150.         /* Determine if the cluster entry is odd or even.  */
  151.         if (cluster & 1)
  152.         {
  154.             /* Odd cluster number.  */
  156.             /* Pickup the lower nibble of the FAT entry.  */
  157.             entry =  (((UINT) *FAT_ptr) & 0xF0) >> 4;
  158.             
  159.             /* Move to the next byte of the FAT entry.  */
  160.             FAT_ptr++;
  162.             /* Determine if we are now past the end of the FAT buffer in memory.  */
  163.             if (byte_offset == (ULONG) (media_ptr -> fx_media_bytes_per_sector - 1))
  164.             {
  166.                 /* Yes, we need to read the next sector.  */
  167.                 FAT_sector++;
  168.                 status =  _fx_utility_log_sector_read(media_ptr, (ULONG) FAT_sector, 
  169.                                         media_ptr -> fx_media_memory_buffer, (ULONG) 1);
  171.                 /* Determine if an error occurred.  */
  172.                 if (status != FX_SUCCESS)
  173.                 {
  175.                     /* Return the error status.  */
  176.                     return(status);
  177.                 }
  179.                 /* Setup a pointer into the buffer.  */
  180.                 FAT_ptr =  (UCHAR_PTR) media_ptr -> fx_media_memory_buffer;
  181.             }
  183.             /* Pickup the upper 8 bits of the FAT entry.  */
  184.             entry =  entry | (((UINT) *FAT_ptr) << 4);
  185.         }
  186.         else
  187.         {
  188.           
  189.             /* Even cluster number.  */
  191.             /* Pickup the lower byte of the FAT entry.  */
  192.             entry =  (UINT) (((UINT) *FAT_ptr) & 0xFF);
  193.             
  194.             /* Move to the next nibble of the FAT entry.  */
  195.             FAT_ptr++;
  197.             /* Determine if we are now past the end of the FAT buffer in memory.  */
  198.             if (byte_offset == (ULONG) (media_ptr -> fx_media_bytes_per_sector - 1))
  199.             {
  201.                 /* Yes, we need to read the next sector.  */
  202.                 FAT_sector++;
  203.                 status =  _fx_utility_log_sector_read(media_ptr, (ULONG) FAT_sector, 
  204.                                         media_ptr -> fx_media_memory_buffer, (ULONG) 1);
  206.                 /* Determine if an error occurred.  */
  207.                 if (status != FX_SUCCESS)
  208.                     return(status);
  210.                 /* Setup a pointer into the buffer.  */
  211.                 FAT_ptr =  (UCHAR_PTR) media_ptr -> fx_media_memory_buffer;
  212.             }
  214.             /* Pickup the upper 4 bits of the FAT entry.  */
  215.             entry =  entry | ((((UINT) *FAT_ptr) & 0x0F) << 8);
  216.         }
  218.         /* Determine if we need to do sign extension on the 12-bit eof value.  */
  219.         if (entry >= FX_MAX_12BIT_CLUST)
  220.         {
  222.             /* Yes, we need to sign extend.  */
  223.             entry =  entry | FX_SIGN_EXTEND;
  224.         }
  226.         *entry_ptr =  entry;
  227.     }
  228.     else if (! media_ptr -> fx_media_32_bit_FAT)
  229.     {
  231.         /* 16-bit FAT is present.  */
  233.         /* Calculate the byte offset to the cluster entry.  */
  234.         byte_offset =  (((ULONG) cluster) * 2); 
  236.         /* Calculate the FAT sector the requested FAT entry resides in.  */
  237.         FAT_sector =  (byte_offset / media_ptr -> fx_media_bytes_per_sector) +
  238.                         (ULONG) media_ptr -> fx_media_reserved_sectors;
  240.         /* Read the FAT sector.  */
  241.         status =  _fx_utility_log_sector_read(media_ptr, (ULONG) FAT_sector, 
  242.                                         media_ptr -> fx_media_memory_buffer, (ULONG) 1);
  244.         /* Determine if an error occurred.  */
  245.         if (status != FX_SUCCESS)
  246.         {
  247.     
  248.             /* Return the error code.  */
  249.             return(status);
  250.         }
  252.         /* Now calculate the byte offset into this FAT sector.  */
  253.         byte_offset =  byte_offset -  
  254.                     ((FAT_sector - (ULONG) media_ptr -> fx_media_reserved_sectors) *
  255.                         media_ptr -> fx_media_bytes_per_sector); 
  257.         /* Setup a pointer into the buffer.  */
  258.         FAT_ptr =  (UCHAR_PTR) media_ptr -> fx_media_memory_buffer + (UINT) byte_offset;
  260.         /* Pickup the FAT entry.  */
  261.         entry =  _fx_utility_16_unsigned_read(FAT_ptr);
  263.         *entry_ptr =  entry;
  264.     }
  265.     else
  266.     {
  268.         /* 32 bit FAT present */
  269.         byte_offset =  (((ULONG) cluster) * 4); 
  271.         /* Calculate the FAT sector the requested FAT entry resides in.  */
  272.         FAT_sector =  (byte_offset / media_ptr -> fx_media_bytes_per_sector) +
  273.                         (ULONG) media_ptr -> fx_media_reserved_sectors;
  275.         byte_offset %= media_ptr -> fx_media_bytes_per_sector;
  278.         status =  _fx_utility_log_sector_read(media_ptr, (ULONG) FAT_sector, 
  279.                                         media_ptr -> fx_media_memory_buffer, (ULONG) 1);
  281.         /* Determine if an error occurred.  */
  282.         if (status != FX_SUCCESS)
  283.         {
  284.     
  285.             /* Return the error code.  */
  286.             return(status);
  287.         }
  289.         /* Setup a pointer into the buffer.  */
  290.         FAT_ptr =  (UCHAR_PTR) media_ptr -> fx_media_memory_buffer + byte_offset;
  292.         /* Pickup the FAT entry.  */
  293.         entry32 =  _fx_utility_32_unsigned_read(FAT_ptr);
  295.         entry32 &= 0x0FFFFFFFUL;
  296.         *entry_ptr =  entry32;
  297.     }
  299.     
  300.     /* Return success to the caller.  */
  301.     return(FX_SUCCESS);
  302. }
  304. #endif