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

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

DVD

开发平台：

Others

Fx_dnefn.c：源码内容
  1. /**************************************************************************/ 
  2. /*                                                                        */ 
  3. /*            Copyright (c) 2003 by Zoran                                 */ 
  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 Zoran  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 Zoran                                              */ 
  14. /*                                                                        */ 
  15. /*  Zoran reserves the right to modify this software         */ 
  16. /*  without notice.                                                       */ 
  17. /*                                                                        */ 
  18. /*                                                                        */
  19. /**************************************************************************/
  22. /**************************************************************************/
  23. /**************************************************************************/
  24. /**                                                                       */ 
  25. /** FileX Component                                                       */ 
  26. /**                                                                       */
  27. /**   Directory (DIR)                                                     */
  28. /**                                                                       */
  29. /**************************************************************************/
  30. /**************************************************************************/
  32. #include "Config.h" // Global Configuration - do not remove!
  34. #ifdef ENABLE_FILEX
  36. #ifdef _DEBUG
  37. #undef IFTRACE
  38. #define IFTRACE if (gTraceFileSys)
  39. #include "DebugDbgMain.h"
  40. #endif //_DEBUG
  41. #define FX_SOURCE_CODE
  44. /* Include necessary system files.  */
  46. #include "PlaycoreFileSysFileXfx_api.h"
  47. #include "PlaycoreFileSysFileXfx_dir.h"
  48. #include "PlaycoreFileSysFileXfx_uti.h"
  50. #ifndef TX_NO_LOCAL_PATH
  51. extern TX_THREAD *_tx_thread_current_ptr;
  52. #endif
  54. /**************************************************************************/ 
  55. /*                                                                        */ 
  56. /*  FUNCTION                                               RELEASE        */ 
  57. /*                                                                        */ 
  58. /*    _fx_directory_next_entry_find_new                   PORTABLE C      */ 
  59. /*                                                           3.0          */ 
  60. /*  AUTHOR                                                                */ 
  61. /*                                                                        */ 
  62. /*    Brizguine Alexei, Zoran                                              */ 
  63. /*                                                                        */ 
  64. /*  DESCRIPTION                                                           */ 
  65. /*                                                                        */ 
  66. /*    This function returns the name of the next entry in the current     */ 
  67. /*    working directory.  The function that returns the first name in the */ 
  68. /*    current directory must be called prior to this function.            */ 
  69. /*                                                                        */ 
  70. /*  INPUT                                                                 */ 
  71. /*                                                                        */ 
  72. /*    media_ptr                             Media control block pointer   */ 
  73. /*    dir_ptr                               Destination for directory     */ 
  74. /*                                            parameters                  */ 
  75. /*                                                                        */ 
  76. /*  OUTPUT                                                                */ 
  77. /*                                                                        */ 
  78. /*    return status                                                       */ 
  79. /*                                                                        */ 
  80. /*  CALLS                                                                 */ 
  81. /*                                                                        */ 
  82. /*    _fx_directory_entry_read              Read entries from root dir    */ 
  83. /*    _fx_utlity_FAT_entry_read             Read FAT entries to calculate */ 
  84. /*                                            the sub-directory size      */ 
  85. /*                                                                        */ 
  86. /*  CALLED BY                                                             */ 
  87. /*                                                                        */ 
  88. /*    Application Code and                                                */ 
  89. /*    FileX System Functions                                              */ 
  90. /*                                                                        */ 
  91. /*  RELEASE HISTORY                                                       */ 
  92. /*                                                                        */ 
  93. /*    DATE              NAME                      DESCRIPTION             */ 
  94. /*                                                                        */ 
  95. /*  29-05-2003     Brizguine Alexei         Modified comment(s),          */ 
  96. /*                                            changed to 32 bit variables,*/ 
  97. /*                                            fixed possible infinite loop*/ 
  98. /*                                            caused by FAT corruption,   */ 
  99. /*                                            and fixed status corruption,*/ 
  100. /*                                            resulting in version 3.0.   */ 
  101. /*                                                                        */ 
  102. /**************************************************************************/ 
  103. UINT   _fx_directory_next_entry_find_new(FX_MEDIA *media_ptr, FX_DIR_ENTRY* entry)
  104. {
  106. ULONG           i;
  107. UINT            status;
  108. UINT            temp_status;
  109. ULONG           cluster, next_cluster;
  110. ULONG           directory_size;
  111. //FX_DIR_ENTRY    entry;
  112. FX_DIR_ENTRY    *search_dir_ptr;
  113. FX_PATH         *path_ptr;
  114. ULONG           fat_reserved;
  117.     /* Check the media to make sure it is open.  */
  118.     if (media_ptr -> fx_media_id != FX_MEDIA_ID)
  119.     {
  121.         /* Return the media not opened error.  */
  122.         return(FX_MEDIA_NOT_OPEN);
  123.     }
  125.     /* Determine the type of FAT and setup variables accordingly.  */
  126.     if (media_ptr -> fx_media_32_bit_FAT) fat_reserved = FX_RESERVED_1_32;
  127.     else fat_reserved = FX_RESERVED_1;
  129.     /* Protect against other threads accessing the media.  */
  130.     FX_PROTECT
  132.     /* First check for a local path pointer stored in the thread control block.  This
  133.        is only available in ThreadX Version 4 and above.  */
  134. #ifndef FX_NO_LOCAL_PATH
  135.     if (_tx_thread_current_ptr -> tx_filex_ptr)
  136.     {
  138.         /* Setup the default path pointer.  */
  139.         path_ptr =  (FX_PATH *) _tx_thread_current_ptr -> tx_filex_ptr;
  141.         /* Determine if we are at the root directory.  */
  142.         if (path_ptr -> fx_path_directory.fx_dir_entry_name[0])
  143.         {
  145.             /* No, we are not at the root directory.  */
  146.             
  147.             /* Set the internal pointer to the search directory as well.  */
  148.             search_dir_ptr =  &path_ptr -> fx_path_directory;
  149.         }
  150.         else
  151.         {
  153.             /* The current default directory is the root so just set the
  154.                search directory pointer to NULL.  */
  155.             search_dir_ptr =  FX_NULL;
  156.         }
  158.     } else
  159. #endif
  161.     /* Set the initial search directory to the current working 
  162.        directory - if there is one.  */
  163.     if (media_ptr -> fx_media_default_path.fx_path_directory.fx_dir_entry_name[0])
  164.     {
  165.         
  166.         /* Setup the path pointer to the global media path.  */
  167.         path_ptr =  &media_ptr -> fx_media_default_path;
  168.             
  169.         /* Set the internal pointer to the search directory as well.  */
  170.         search_dir_ptr =  &path_ptr -> fx_path_directory;
  171.     }
  172.     else
  173.     {
  175.         /* Setup the path pointer to the global media path.  */
  176.         path_ptr =  &media_ptr -> fx_media_default_path;
  178.         /* The current default directory is the root so just set the
  179.            search directory pointer to NULL.  */
  180.         search_dir_ptr =  FX_NULL;
  181.     }
  183.     /* Calculate the directory size.  */
  184.     if (search_dir_ptr)
  185.     {
  187.         /* Calculate the directory size by counting the allocated
  188.            clusters for it.  */
  189.         if (media_ptr -> fx_media_default_path.fx_path_current_entry !=  0)
  190.             directory_size = search_dir_ptr->fx_dir_entry_file_size ;
  191.         else
  192.         {
  193.             i =        0;
  194.             cluster =  search_dir_ptr -> fx_dir_entry_cluster;
  195.             while ((cluster >= FX_FAT_ENTRY_START) && (cluster < fat_reserved))
  196.             {
  198.                 /* Increment the cluster count.  */
  199.                 i++;
  201.                 /* Read the next FAT entry.  */
  202.                 status =  _fx_utility_FAT_entry_read(media_ptr, cluster, &next_cluster);
  205.                 /* Check the return status.  */
  206.                 if (status != FX_SUCCESS)
  207.                 {
  209.                     /* Release media protection.  */
  210.                     FX_UNPROTECT
  212.                     /* Return the bad status.  */
  213.                     return(status);
  214.                 }                
  216.                 if ((cluster == next_cluster) || (i > media_ptr -> fx_media_total_clusters)) 
  217.                 {
  219.                     /* Release media protection.  */
  220.                     FX_UNPROTECT
  222.                     /* Return the bad status.  */
  223.                     return(FX_FAT_READ_ERROR);
  224.                 }
  226.                 cluster = next_cluster;
  227.             }
  229.             /* Now we can calculate the directory size.  */
  230.             directory_size =  (((ULONG) media_ptr -> fx_media_bytes_per_sector) *
  231.                                    ((ULONG) media_ptr -> fx_media_sectors_per_cluster) * i)
  232.                                     / (ULONG) FX_DIR_ENTRY_SIZE;
  233.             search_dir_ptr->fx_dir_entry_file_size = directory_size ;
  234.         }
  235.     }
  236.     else
  237.     {
  239.         /* Directory size is the number of entries in the root directory.  */
  240.         directory_size =  (ULONG) media_ptr -> fx_media_root_directory_entries;
  241.     }
  243.     /* Preset status with an error return.  */
  244.     status =  FX_NO_MORE_ENTRIES;
  246.     /* Determine if the current entry is inside of the directory's range.  */
  247.     while (path_ptr -> fx_path_current_entry < directory_size)
  248.     {
  250.         /* Read an entry from the directory.  */
  251.         temp_status =  _fx_directory_entry_read(media_ptr, search_dir_ptr, 
  252.                                     &(path_ptr -> fx_path_current_entry), entry);
  254.         /* Check for error status.  */
  255.         if (temp_status != FX_SUCCESS)
  256.         {
  258.             /* Release media protection.  */
  259.             FX_UNPROTECT
  261.             /* Return error status.  */
  262.             return(status);
  263.         }
  265.         /* Check to see if the entry has something in it.  */
  266.         if (entry->fx_dir_entry_name[0] == (CHAR) FX_DIR_ENTRY_FREE)
  267.         {
  269.             /* Current entry is free, skip to next entry and continue the loop.  */
  270.             path_ptr -> fx_path_current_entry++;
  271.             continue;
  272.         }
  274. //JERRYC_2004AUG25        else if (entry->fx_dir_entry_name[0] != (CHAR) FX_DIR_ENTRY_DONE)
  275.         else if (entry->fx_dir_entry_name[0] != (CHAR) FX_DIR_ENTRY_DONE || 0 == path_ptr -> fx_path_current_entry)
  276.         {
  278.             /* A valid directory entry is present.  */
  280.             /* Copy the name into the destination.  */
  281. /*            for (i = 0; entry.fx_dir_entry_name[i]; i++)
  282.             {
  283.                 
  284.                 *directory_name = entry.fx_dir_entry_name[i];
  285.                 directory_name++;
  286.             }
  288.             *directory_name =  (CHAR) 0;
  289. */
  290.             /* Increment the current entry for the media.  */
  291.             path_ptr -> fx_path_current_entry++;
  293.             /* Set return status to success.  */
  294.             status =  FX_SUCCESS;
  296.             /* Get out of the loop.  */
  297.             break;
  298.         }
  299.         else 
  300.         {
  302.             /* Set the error code.  */
  303.             status =  FX_NO_MORE_ENTRIES;
  305.             /* Get out of the loop.  */
  306.             break;
  307.         }
  308.     }
  310.     /* Release media protection.  */
  311.     FX_UNPROTECT
  313.     /* Return status to the caller.  */
  314.     return(status);
  315. }
  316. #endif