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

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

DVD

开发平台：

Others

Fx_dnef.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. /**   Directory (DIR)                                                     */
  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_uti.h"
  55. #ifndef TX_NO_LOCAL_PATH
  56. extern TX_THREAD *_tx_thread_current_ptr;
  57. #endif
  59. /**************************************************************************/ 
  60. /*                                                                        */ 
  61. /*  FUNCTION                                               RELEASE        */ 
  62. /*                                                                        */ 
  63. /*    _fx_directory_next_entry_find                       PORTABLE C      */ 
  64. /*                                                           3.0          */ 
  65. /*  AUTHOR                                                                */ 
  66. /*                                                                        */ 
  67. /*    William E. Lamie, Express Logic, Inc.                               */ 
  68. /*                                                                        */ 
  69. /*  DESCRIPTION                                                           */ 
  70. /*                                                                        */ 
  71. /*    This function returns the name of the next entry in the current     */ 
  72. /*    working directory.  The function that returns the first name in the */ 
  73. /*    current directory must be called prior to this function.            */ 
  74. /*                                                                        */ 
  75. /*  INPUT                                                                 */ 
  76. /*                                                                        */ 
  77. /*    media_ptr                             Media control block pointer   */ 
  78. /*    directory_name                        Destination for directory     */ 
  79. /*                                            name                        */ 
  80. /*                                                                        */ 
  81. /*  OUTPUT                                                                */ 
  82. /*                                                                        */ 
  83. /*    return status                                                       */ 
  84. /*                                                                        */ 
  85. /*  CALLS                                                                 */ 
  86. /*                                                                        */ 
  87. /*    _fx_directory_entry_read              Read entries from root dir    */ 
  88. /*    _fx_utlity_FAT_entry_read             Read FAT entries to calculate */ 
  89. /*                                            the sub-directory size      */ 
  90. /*                                                                        */ 
  91. /*  CALLED BY                                                             */ 
  92. /*                                                                        */ 
  93. /*    Application Code and                                                */ 
  94. /*    FileX System Functions                                              */ 
  95. /*                                                                        */ 
  96. /*  RELEASE HISTORY                                                       */ 
  97. /*                                                                        */ 
  98. /*    DATE              NAME                      DESCRIPTION             */ 
  99. /*                                                                        */ 
  100. /*  01-01-1999     William E. Lamie         Initial Version 1.0           */ 
  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) and       */ 
  104. /*                                            deleted old directory cache */ 
  105. /*                                            invalidate code, resulting  */ 
  106. /*                                            in version 2.0.             */  
  107. /*  03-01-2002     Mohammad N. Minhaz       Modified comment(s),          */ 
  108. /*                                            changed to 32 bit variables,*/ 
  109. /*                                            fixed possible infinite loop*/ 
  110. /*                                            caused by FAT corruption,   */ 
  111. /*                                            and fixed status corruption,*/ 
  112. /*                                            resulting in version 3.0.   */ 
  113. /*                                                                        */ 
  114. /**************************************************************************/ 
  115. UINT  _fx_directory_next_entry_find(FX_MEDIA *media_ptr, CHAR *directory_name)
  116. {
  118. ULONG           i;
  119. UINT            status;
  120. UINT            temp_status;
  121. ULONG           cluster, next_cluster;
  122. ULONG           directory_size;
  123. FX_DIR_ENTRY    entry;
  124. FX_DIR_ENTRY    *search_dir_ptr;
  125. FX_PATH         *path_ptr;
  126. ULONG           fat_reserved;
  129.     /* Check the media to make sure it is open.  */
  130.     if (media_ptr -> fx_media_id != FX_MEDIA_ID)
  131.     {
  133.         /* Return the media not opened error.  */
  134.         return(FX_MEDIA_NOT_OPEN);
  135.     }
  137.     /* Determine the type of FAT and setup variables accordingly.  */
  138.     if (media_ptr -> fx_media_32_bit_FAT) fat_reserved = FX_RESERVED_1_32;
  139.     else fat_reserved = FX_RESERVED_1;
  141.     /* Protect against other threads accessing the media.  */
  142.     FX_PROTECT
  144.     /* First check for a local path pointer stored in the thread control block.  This
  145.        is only available in ThreadX Version 4 and above.  */
  146. #ifndef FX_NO_LOCAL_PATH
  147.     if (_tx_thread_current_ptr -> tx_filex_ptr)
  148.     {
  150.         /* Setup the default path pointer.  */
  151.         path_ptr =  (FX_PATH *) _tx_thread_current_ptr -> tx_filex_ptr;
  153.         /* Determine if we are at the root directory.  */
  154.         if (path_ptr -> fx_path_directory.fx_dir_entry_name[0])
  155.         {
  157.             /* No, we are not at the root directory.  */
  158.             
  159.             /* Set the internal pointer to the search directory as well.  */
  160.             search_dir_ptr =  &path_ptr -> fx_path_directory;
  161.         }
  162.         else
  163.         {
  165.             /* The current default directory is the root so just set the
  166.                search directory pointer to NULL.  */
  167.             search_dir_ptr =  FX_NULL;
  168.         }
  170.     } else
  171. #endif
  173.     /* Set the initial search directory to the current working 
  174.        directory - if there is one.  */
  175.     if (media_ptr -> fx_media_default_path.fx_path_directory.fx_dir_entry_name[0])
  176.     {
  177.         
  178.         /* Setup the path pointer to the global media path.  */
  179.         path_ptr =  &media_ptr -> fx_media_default_path;
  180.             
  181.         /* Set the internal pointer to the search directory as well.  */
  182.         search_dir_ptr =  &path_ptr -> fx_path_directory;
  183.     }
  184.     else
  185.     {
  187.         /* Setup the path pointer to the global media path.  */
  188.         path_ptr =  &media_ptr -> fx_media_default_path;
  190.         /* The current default directory is the root so just set the
  191.            search directory pointer to NULL.  */
  192.         search_dir_ptr =  FX_NULL;
  193.     }
  195.     /* Calculate the directory size.  */
  196.     if (search_dir_ptr)
  197.     {
  199.         /* Calculate the directory size by counting the allocated
  200.            clusters for it.  */
  201.         if (media_ptr -> fx_media_default_path.fx_path_current_entry !=  0)
  202.             directory_size = search_dir_ptr->fx_dir_entry_file_size ;
  203.         else
  204.         {
  205.             i =        0;
  206.             cluster =  search_dir_ptr -> fx_dir_entry_cluster;
  207.             while ((cluster >= FX_FAT_ENTRY_START) && (cluster < fat_reserved))
  208.             {
  210.                 /* Increment the cluster count.  */
  211.                 i++;
  213.                 /* Read the next FAT entry.  */
  214.                 status =  _fx_utility_FAT_entry_read(media_ptr, cluster, &next_cluster);
  217.                 /* Check the return status.  */
  218.                 if (status != FX_SUCCESS)
  219.                 {
  221.                     /* Release media protection.  */
  222.                     FX_UNPROTECT
  224.                     /* Return the bad status.  */
  225.                     return(status);
  226.                 }                
  228.                 if ((cluster == next_cluster) || (i > media_ptr -> fx_media_total_clusters)) 
  229.                 {
  231.                     /* Release media protection.  */
  232.                     FX_UNPROTECT
  234.                     /* Return the bad status.  */
  235.                     return(FX_FAT_READ_ERROR);
  236.                 }
  238.                 cluster = next_cluster;
  239.             }
  241.             /* Now we can calculate the directory size.  */
  242.             directory_size =  (((ULONG) media_ptr -> fx_media_bytes_per_sector) *
  243.                                    ((ULONG) media_ptr -> fx_media_sectors_per_cluster) * i)
  244.                                     / (ULONG) FX_DIR_ENTRY_SIZE;
  245.             search_dir_ptr->fx_dir_entry_file_size = directory_size ;
  246.         }
  247.     }
  248.     else
  249.     {
  251.         /* Directory size is the number of entries in the root directory.  */
  252.         directory_size =  (ULONG) media_ptr -> fx_media_root_directory_entries;
  253.     }
  255.     /* Preset status with an error return.  */
  256.     status =  FX_NO_MORE_ENTRIES;
  258.     /* Determine if the current entry is inside of the directory's range.  */
  259.     while (path_ptr -> fx_path_current_entry < directory_size)
  260.     {
  262.         /* Read an entry from the directory.  */
  263.         temp_status =  _fx_directory_entry_read(media_ptr, search_dir_ptr, 
  264.                                     &(path_ptr -> fx_path_current_entry), &entry);
  266.         /* Check for error status.  */
  267.         if (temp_status != FX_SUCCESS)
  268.         {
  270.             /* Release media protection.  */
  271.             FX_UNPROTECT
  273.             /* Return error status.  */
  274.             return(status);
  275.         }
  277.         /* Check to see if the entry has something in it.  */
  278.         if (entry.fx_dir_entry_name[0] == (CHAR) FX_DIR_ENTRY_FREE)
  279.         {
  281.             /* Current entry is free, skip to next entry and continue the loop.  */
  282.             path_ptr -> fx_path_current_entry++;
  283.             continue;
  284.         }
  286.         else if (entry.fx_dir_entry_name[0] != (CHAR) FX_DIR_ENTRY_DONE)
  287.         {
  289.             /* A valid directory entry is present.  */
  291.             /* Copy the name into the destination.  */
  292.             for (i = 0; entry.fx_dir_entry_name[i]; i++)
  293.             {
  294.                 
  295.                 *directory_name = entry.fx_dir_entry_name[i];
  296.                 directory_name++;
  297.             }
  299.             /* Place a NULL at the end of the directory name.  */
  300.             *directory_name =  (CHAR) 0;
  302.             /* Increment the current entry for the media.  */
  303.             path_ptr -> fx_path_current_entry++;
  305.             /* Set return status to success.  */
  306.             status =  FX_SUCCESS;
  308.             /* Get out of the loop.  */
  309.             break;
  310.         }
  311.         else 
  312.         {
  314.             /* Set the error code.  */
  315.             status =  FX_NO_MORE_ENTRIES;
  317.             /* Get out of the loop.  */
  318.             break;
  319.         }
  320.     }
  322.     /* Release media protection.  */
  323.     FX_UNPROTECT
  325.     /* Return status to the caller.  */
  326.     return(status);
  327. }
  329. #endif