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

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

DVD

开发平台：

Others

FX_FS.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. /**   File (FIL)                                                          */
  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_dir.h"
  53. #include "PlaycoreFileSysFileXfx_fil.h"
  54. #include "PlaycoreFileSysFileXfx_uti.h"
  57. /**************************************************************************/ 
  58. /*                                                                        */ 
  59. /*  FUNCTION                                               RELEASE        */ 
  60. /*                                                                        */ 
  61. /*    _fx_file_seek                                       PORTABLE C      */ 
  62. /*                                                           3.0          */ 
  63. /*  AUTHOR                                                                */ 
  64. /*                                                                        */ 
  65. /*    William E. Lamie, Express Logic, Inc.                               */ 
  66. /*                                                                        */ 
  67. /*  DESCRIPTION                                                           */ 
  68. /*                                                                        */ 
  69. /*    This function positions the internal file pointers to the specified */ 
  70. /*    byte offset such that the next read or write operation will be      */ 
  71. /*    performed there.  If the byte offset is greater than the size, the  */ 
  72. /*    file pointers will be positioned to the end of the file.            */ 
  73. /*                                                                        */ 
  74. /*  INPUT                                                                 */ 
  75. /*                                                                        */ 
  76. /*    file_ptr                              File control block pointer    */ 
  77. /*    byte_offset                           Byte offset into the file     */ 
  78. /*                                                                        */ 
  79. /*  OUTPUT                                                                */ 
  80. /*                                                                        */ 
  81. /*    return status                                                       */ 
  82. /*                                                                        */ 
  83. /*  CALLS                                                                 */ 
  84. /*                                                                        */ 
  85. /*    _fx_utility_FAT_entry_read            Read a FAT entry              */ 
  86. /*                                                                        */ 
  87. /*  CALLED BY                                                             */ 
  88. /*                                                                        */ 
  89. /*    Application Code                                                    */ 
  90. /*                                                                        */ 
  91. /*  RELEASE HISTORY                                                       */ 
  92. /*                                                                        */ 
  93. /*    DATE              NAME                      DESCRIPTION             */ 
  94. /*                                                                        */ 
  95. /*  01-01-1999     William E. Lamie         Initial Version 1.0           */ 
  96. /*  04-19-1999     William E. Lamie         Added logic to seek to the    */ 
  97. /*                                            end of a file whose size    */ 
  98. /*                                            is evenly divisible by      */ 
  99. /*                                            the media's cluster size,   */ 
  100. /*                                            resulting in version 1.0a.  */ 
  101. /*  03-01-2000     William E. Lamie         Modified comment(s),          */ 
  102. /*                                            resulting in version 1.0b.  */ 
  103. /*  01-28-2001     William E. Lamie         Modified comment(s),          */ 
  104. /*                                            resulting in version 2.0.   */ 
  105. /*  03-01-2002     Mohammad N. Minhaz       Modified comment(s),          */ 
  106. /*                                            changed to 32 bit variables,*/ 
  107. /*                                            fixed possible infinite loop*/ 
  108. /*                                            caused by a corrupt FAT,    */ 
  109. /*                                            and added logic to determine*/ 
  110. /*                                            consecutive clusters,       */ 
  111. /*                                            resulting in version 3.0.   */ 
  112. /*                                                                        */ 
  113. /**************************************************************************/ 
  114. UINT  _fx_file_seek(FX_FILE *file_ptr, ULONG byte_offset)
  115. {
  117. UINT        status;
  118. ULONG       cluster;
  119. ULONG       contents;
  120. ULONG       bytes_per_cluster;
  121. ULONG       last_cluster;
  122. ULONG       cluster_count;
  123. ULONG       bytes_remaining;
  124. FX_MEDIA    *media_ptr;
  125. ULONG       fat_reserved;
  128.     /* First, determine if the file is still open.  */
  129.     if (file_ptr -> fx_file_id != FX_FILE_ID)
  130.     {
  132.         /* Return the file not open error status.  */
  133.         return(FX_NOT_OPEN);
  134.     }
  136.     /* Setup pointer to associated media control block.  */
  137.     media_ptr =  file_ptr -> fx_file_media_ptr;
  139.     /* Determine the type of FAT and setup variables accordingly.  */
  140.     if (media_ptr -> fx_media_32_bit_FAT) fat_reserved = FX_RESERVED_1_32;
  141.     else fat_reserved = FX_RESERVED_1;
  143.     /* Protect against other threads accessing the media.  */
  144.     FX_PROTECT
  146.     /* Calculate the number of bytes per cluster.  */
  147.     bytes_per_cluster =  ((ULONG) media_ptr -> fx_media_bytes_per_sector) *
  148.                          ((ULONG) media_ptr -> fx_media_sectors_per_cluster);
  150.     /* See if we need to adjust the byte offset.  */
  151.     if (byte_offset > file_ptr -> fx_file_current_file_size)
  152.     {
  154.         /* Adjust the byte offset down to the file size. */
  155.         byte_offset =  file_ptr -> fx_file_current_file_size;
  156.     }
  158.     /* check if the desired position within the leading consecutive clusters */    
  159.     if (byte_offset >= file_ptr -> fx_file_consecutive_cluster * bytes_per_cluster)
  160.     {
  162.         /* At this point, we are ready to walk list of clusters to setup the
  163.            seek position of this file.  */
  165.         /* check if byte_offset is greater than where we were left off earlier */
  166.         if (file_ptr -> fx_file_current_relative_cluster * bytes_per_cluster < byte_offset)
  167.         {
  169.             cluster =    file_ptr -> fx_file_current_physical_cluster;
  171.             bytes_remaining =   byte_offset - 
  172.                                     file_ptr -> fx_file_current_relative_cluster * bytes_per_cluster;
  174.             cluster_count = file_ptr -> fx_file_current_relative_cluster;
  175.             last_cluster = 0;
  176.         }
  177.         else 
  178.         {
  180.             cluster =    file_ptr -> fx_file_first_physical_cluster +
  181.                                     (file_ptr -> fx_file_consecutive_cluster - 1);
  182.             bytes_remaining =   byte_offset - 
  183.                                 (file_ptr -> fx_file_consecutive_cluster - 1)* bytes_per_cluster;
  185.             last_cluster =      0;
  186.             cluster_count =     (file_ptr -> fx_file_consecutive_cluster - 1);
  187.         }
  190.         /* Follow the link of FAT entries.  */
  191.         while ((cluster >= FX_FAT_ENTRY_START) && (cluster < fat_reserved))
  192.         {
  194.             /* Increment the number of clusters.  */
  195.             cluster_count++;
  197.             /* Read the current cluster entry from the FAT.  */
  198.             status =  _fx_utility_FAT_entry_read(media_ptr, cluster, &contents);
  200.             /* Check the return value.  */
  201.             if (status != FX_SUCCESS)
  202.             {
  204.                 /* Release media protection.  */
  205.                 FX_UNPROTECT
  207.                 /* Return the error status.  */
  208.                 return(status);
  209.             }
  211.             /* Save the last valid cluster.  */
  212.             last_cluster =  cluster;
  214.             /* Setup for the next cluster.  */
  215.             cluster =  contents;
  217.             /* Determine if this is the last written cluster.  */
  218.             if (bytes_remaining > bytes_per_cluster)
  219.             {
  221.                 /* Still more seeking, just decrement the working byte offset.  */
  222.                 bytes_remaining =  bytes_remaining - bytes_per_cluster;
  223.             }
  224.             else
  225.             {
  227.                 /* Remember this cluster number.  */
  228.                 file_ptr -> fx_file_current_physical_cluster =  last_cluster;
  230.                 /* Remember the relative cluster.  */
  231.                 file_ptr -> fx_file_current_relative_cluster =  cluster_count-1;
  233.                 /* If the remaining bytes exactly fits the cluster size, check for 
  234.                    a possible adjustment to the next cluster.  */
  235.                 if ((bytes_remaining == bytes_per_cluster) &&
  236.                     (cluster >= FX_FAT_ENTRY_START) && (cluster < fat_reserved))
  237.                 {
  239.                     /* We need to position to next allocated cluster.  */
  240.                     file_ptr -> fx_file_current_physical_cluster =  cluster;
  241.                     file_ptr -> fx_file_current_relative_cluster++;
  243.                     /* Clear the remaining bytes.  */
  244.                     bytes_remaining =  0;
  245.                 }
  247.                 /* This is the cluster that contains the seek position.  */
  248.                 break;
  249.             }
  250.         }        
  251.     }
  252.     else
  253.     {
  255.         /* we should directly access the desired cluster */
  256.         file_ptr -> fx_file_current_relative_cluster = byte_offset/bytes_per_cluster; 
  258.         file_ptr -> fx_file_current_physical_cluster = 
  259.         file_ptr -> fx_file_first_physical_cluster + file_ptr -> fx_file_current_relative_cluster; 
  261.         bytes_remaining =  byte_offset % bytes_per_cluster;  
  262.     }
  265.     /* Determine if the remaining bytes fit exactly into the cluster size.  */
  266.     if (bytes_remaining == bytes_per_cluster)
  267.     {
  269.         /* Position to the end of the cluster.  */
  270.         file_ptr -> fx_file_current_logical_sector =    ((ULONG) media_ptr -> fx_media_data_sector_start) +
  271.                                                         (((ULONG) file_ptr -> fx_file_current_physical_cluster - FX_FAT_ENTRY_START) *
  272.                                                         ((ULONG) media_ptr -> fx_media_sectors_per_cluster)) +
  273.                                                         ((bytes_remaining-1) / (ULONG) media_ptr -> fx_media_bytes_per_sector);
  274.         file_ptr -> fx_file_current_relative_sector =   (UINT) (((bytes_remaining-1) / (ULONG) media_ptr -> fx_media_bytes_per_sector));
  275.         file_ptr -> fx_file_current_file_offset =       byte_offset;
  276.         file_ptr -> fx_file_current_logical_offset =    media_ptr -> fx_media_bytes_per_sector;
  277.     }
  278.     else
  279.     {
  281.         /* Position the pointers to the new offset.  */
  282.         file_ptr -> fx_file_current_logical_sector =    ((ULONG) media_ptr -> fx_media_data_sector_start) +
  283.                                                         (((ULONG) file_ptr -> fx_file_current_physical_cluster - FX_FAT_ENTRY_START) *
  284.                                                         ((ULONG) media_ptr -> fx_media_sectors_per_cluster)) +
  285.                                                         (bytes_remaining / (ULONG) media_ptr -> fx_media_bytes_per_sector);
  286.         file_ptr -> fx_file_current_relative_sector =   (UINT) ((bytes_remaining / (ULONG) media_ptr -> fx_media_bytes_per_sector));
  287.         file_ptr -> fx_file_current_file_offset =       byte_offset;
  288.         file_ptr -> fx_file_current_logical_offset =    bytes_remaining % ((ULONG) media_ptr -> fx_media_bytes_per_sector);
  289.     }
  290.     
  291.     /* Release media protection.  */
  292.     FX_UNPROTECT
  294.     /* Seek is complete, return successful status.  */
  295.     return(FX_SUCCESS);
  296. }
  298. #endif