filesys.c

本程序为ST公司开发的源代码

    if (local_filesys_inevent & FILESYS_TAG_COMMAND_EVENT)
    {
#if (1 == HAVE_WMDRM)
      /* Only USB device and WMDRM device. */
      if ( fs_tag_params.xfile->fs_type == FS_WMDRM_TYPE )
      { 
        /* USB device is WMDRM-NDT and Media Session still open !! */
        if ( IS_USBDeviceSuppport_WMDRM_ND && IS_USBDeviceMediaSession_Open )
        {
          DRM_RESULT dr;

          /* Still exist previous Media Session, Should close it. */
          dr = WmdrmNet_TASK_transition( WMDRM_CLOSE_MEDIA_SESSION );
          if ( DRM_FAILED(dr) )
          {
            return E_FAIL;
          }
        }  
        
        ProximityContext.USBDeviceConfig &= MASK_USBDeviceSessionConfig; /* Reset flag for previous song. */
        ProximityContext.ObjectHandle = fs_tag_params.xfile->extent_lba; /* Copy Object Handle of next song. In "extent_lba" : DUMMY. */
      }
#endif

      if (fs_tag_params.flags)
      {
        FSM_activate(&filesys_fsm_tag, 5, 1); // activate bitrate parser
      }
      else
      {
        FSM_activate(&filesys_fsm_tag, 0, 1); // default
      }
      local_filesys_inevent &= ~FILESYS_TAG_COMMAND_EVENT;
    }

    local_filesys_inevent &= ~FILESYS_COMMAND_EVENT;
  }

  return READY;
}

RETVAL filesys_process_postevents(void)
{
  if (filesys_outevent & FS_TAG_DECODE_FINISHED)
  {
    event_set_tag_filesys(READY);
  }

  if (filesys_outevent & FS_MOUNT_FINISHED)
  {
    if (filesys_fsm_mount.error_reason)
    {
      event_set_mount_filesys(filesys_fsm_mount.error_reason);
    }
    else
    {
      event_set_mount_filesys(READY);
    }
  }

  if (filesys_outevent & FS_INIT_FINISHED)
  {
    event_set_init_filesys(READY);
  }

  if (filesys_outevent & FS_STOP_FINISHED)
  {
    event_set_stop_filesys(READY);
  }

  if (filesys_outevent & FS_MOUNT_RESUME)
  {
    OSAL_wake_thread(OSAL_THREAD_FilesysTask); // wake up filesys to continue fs processing
  }

  return READY;
}

void filesys_tag_decode_stop(void)
{
  if (filesys_fsm_tag.state == FSM_RUN)
  {
    filesys_fsm_tag.state = FSM_ERROR;
    filesys_fsm_tag.error_reason = E_FORCED_TERMINATION;
    if (filesys_fsm_tag.parent_notify)
      filesys_outevent |= FS_TAG_DECODE_FINISHED;
  }
  else
    filesys_fsm_tag.state = FSM_IDLE;
}

void filesys_mount_stop(void)
{
//int i;
  if (filesys_fsm_mount.state == FSM_RUN)
  {
    if (fs_scan_struct.volume && (filesys_fsm_mount.transition >= FS_MOUNT_STATE_SCAN_DIR))   // partition detection done already
    {
      XAR_SetLastNode(XAR_VolumeNode(fs_scan_struct.volume)); // restore
#if HAVE_EXTERNAL_XARRAY            
      writeSDRAM32((int16*)&X_POOL_TOP,string_top);				// restore strings pool position
#else
      X_POOL_TOP = string_top;
#endif

    }

    filesys_fsm_mount.state = FSM_ERROR;
    filesys_fsm_mount.error_reason = E_FORCED_TERMINATION;
    //if(filesys_fsm_mount.parent_notify)
    filesys_outevent |= FS_MOUNT_FINISHED;
  }
  else
    filesys_fsm_mount.state = FSM_IDLE;
}

void filesys_init_for_new_disc(void)
{
  XAR_DisableTOCVolume();
}

void filesys_fsm(void)
{
  //   filesys_outevent = 0;

  do
  {
    filesys_transition_results = 0;

    if (filesys_fsm_init.state == FSM_RUN)
      filesys_transition_results |= filesys_init_transition();

    if (filesys_fsm_stop.state == FSM_RUN)
      filesys_transition_results |= filesys_stop_transition();

    if (filesys_fsm_tag.state == FSM_RUN)
      filesys_transition_results |= filesys_tag_decode_transition();

    if (filesys_fsm_mount.state == FSM_RUN)
      filesys_transition_results |= filesys_mount_transition();
  }
  while (filesys_transition_results);
}


uint16 filesys_init_transition(void)
{
  switch (filesys_fsm_init.transition)
  {
  case 0:
    if (filesys_fsm_stop.transition == FSM_RUN)
    {
      filesys_fsm_init.transition = FS_INIT_STATE_WAIT_FOR_STOP;
      return 0;
    }
    FSM_activate(&filesys_fsm_stop, 0, 0);
    filesys_fsm_init.transition = FS_INIT_STATE_WAIT_FOR_STOP;
    return FS_TRAN_RESULT_INIT;

  case FS_INIT_STATE_WAIT_FOR_STOP:
    if (filesys_fsm_stop.transition == FSM_RUN)
    {
      return 0;
    }

    XAR_ClearXArray();
    XAR_AddTOCVolume();
    filesys_fsm_init.state = FSM_DONE;
    if (filesys_fsm_init.parent_notify)
      filesys_outevent |= FS_INIT_FINISHED;
    return FS_TRAN_RESULT_INIT;
  }

  return 0;
}


uint16 filesys_stop_transition(void)
{
      
  if ((filesys_fsm_tag.state == FSM_RUN)&&(fs_stop_params.flags & FS_STOP_TAG))
  {
      filesys_tag_decode_stop();
  }

  if ((filesys_fsm_mount.state == FSM_RUN)&&(fs_stop_params.flags & FS_STOP_MOUNT))
  {
    filesys_mount_stop();
  }

  if (filesys_fsm_stop.parent_notify)
    filesys_outevent |= FS_STOP_FINISHED;


  filesys_fsm_stop.state = FSM_DONE;
  return FS_TRAN_RESULT_STOP;
}


uint16 filesys_tag_decode_transition(void)
{
  // *** ID3tag or WMA_ASF decoding *** //
  GRESULT res;

  switch (filesys_fsm_tag.transition)
  {
  case 0:
    if (fs_tag_params.xfile->type == CAFILE_WMA)        //[LL]
    {
#if HAVE_WMA
      res = WMA_TagDecode(fs_tag_params.xfile, 0);    //[LL]
#endif
    }
#if (0 != HAVE_AAC)
    else if (fs_tag_params.xfile->type == CAFILE_AAC)
    {
	  if(BITSTREAM_TYPE_AAC_ADTS == fs_tag_params.xfile->bitstreamType)
	  {
	    ID3_TagDecode(fs_tag_params.xfile, 0);
	  }
      res = AAC_TagDecode(fs_tag_params.xfile, 0);
    }
#endif
    else                      //[LL]
      res = ID3_TagDecode(fs_tag_params.xfile, 0);

    if(res != S_OK)
    { //error in tag decoding
      filesys_fsm_tag.state = FSM_ERROR;
      filesys_fsm_tag.error_reason = res;
      filesys_outevent |= FS_TAG_DECODE_FINISHED;
      return FS_TRAN_RESULT_TAG;
    }

    fs_tag_params.xfile->curr_start_offset = fs_tag_params.xfile->start_offset;  // 0 or ID3tag length
    XAR_SeekFile(fs_tag_params.xfile, fs_tag_params.xfile->start_offset, 1);

    filesys_fsm_tag.state = FSM_DONE;
    filesys_outevent |= FS_TAG_DECODE_FINISHED;

    return FS_TRAN_RESULT_TAG;

  case 5:
#if (0 != HAVE_AAC)
    if(fs_tag_params.xfile->type == CAFILE_AAC)
    {
      res = AAC_GetBitRate(fs_tag_params.xfile);
    }
    else
#endif
    res = GetBitRate(fs_tag_params.xfile);

    if(res == S_OK)
    {
      filesys_fsm_tag.state = FSM_DONE;
    }
    else
    {
      filesys_fsm_tag.state = FSM_ERROR;
      filesys_fsm_tag.error_reason = res;
    }

    filesys_outevent |= FS_TAG_DECODE_FINISHED;

    return FS_TRAN_RESULT_TAG;
  }

  filesys_fsm_tag.state = FSM_ERROR;
  filesys_fsm_tag.error_reason = E_UNEXPECTED;
  filesys_outevent |= FS_TAG_DECODE_FINISHED;

  return FS_TRAN_RESULT_TAG;
}

uint16 filesys_mount_transition(void)
{
  int8 fstype;
  uint16 xid = 0;
  GRESULT i, res, vol, file_ext_res;
  DIR_ITEM item;


  if (filesys_outevent & FS_MOUNT_RESUME)  // if resume scheduled already
    return 0;

  switch (filesys_fsm_mount.transition)
  {
  case 0:
    // check if device ready
    if (DEV_ATTR_READY & SYS_DeviceAttributes(fs_mount_params.devid))
    {
      //if(DEV_CD_ID == SYS_DeviceType(fs_mount_params.devid))
      if (DEV_CD_ID == fs_mount_params.devid)
      {
        // check DISCID
        vol = XAR_FindVolumeByDevice(DEV_CD_ID);
        if (CD_IsDISCIDValid() && (!fs_mount_params.force_execution))
        {
          if (vol > 0)
          {
            // fs is already present in memory
            X_array[XAR_VolumeNode(vol)].nodetype.i &= ~FLAG_VOLUME_INACTIVE;
            filesys_fsm_mount.state = FSM_DONE;
            filesys_fsm_mount.error_reason = NO_ERROR_REASON;
            filesys_outevent |= FS_MOUNT_FINISHED;
            return FS_TRAN_RESULT_MOUNT;
          }
        }
        else
        {
          if (vol > 0)
          {
            XAR_DeleteVolume(vol);
          }
          // CD_UpdateDISCID();  removed by BB
        }
      }
#if (0 != HAVE_USB)
      //if(DEV_USB_ID == SYS_DeviceType(fs_mount_params.devid))
      if (DEV_USB_ID == fs_mount_params.devid)
      {
        // check DISCID
        while (1)
        {
          vol = XAR_FindVolumeByDevice(DEV_USB_ID);
          if (vol > 0)
          {
            XAR_DeleteVolume(vol);
          }
          else
            break;
        }
      }
#endif
#if (0 != HAVE_SDC)
      //if(DEV_SDC_ID == SYS_DeviceType(fs_mount_params.devid))
      if (DEV_SDC_ID == fs_mount_params.devid)
      {
        while (1)
        {
          vol = XAR_FindVolumeByDevice(DEV_SDC_ID);
          if (vol > 0)
          {
            XAR_DeleteVolume(vol);
          }
          else
            break;
        }
      }
#endif /* HAVE_SDC */

      
      ItemsAdded = 0;
      
      ItemsThrown = 0;
      
      
        
      if (0 > SYS_DetectPartitions(fs_mount_params.devid, filesys_sectbuf))
      {
        filesys_fsm_mount.error_reason = E_NO_FS_CARRIER;  /* BB060929a */
        filesys_fsm_mount.transition = FS_MOUNT_STATE_ERROR;
        return FS_TRAN_RESULT_MOUNT; // continue and terminate with error
      }
      else
      {
        fs_scan_struct.partition = 0;
        fs_scan_struct.fs_check = 0;
        string_top = X_POOL_TOP;
#if ((1 == HAVE_HOST_UPDATE) || (1 == HAVE_HOST_UPDATE_NEW))
        host_update_file_index = 0;
#endif
#if (HAVE_FSHRINK == 1)
        file_shrink_mode = FILE_SHRINK_MODE_MAX;
        dir_shrink_mode = DIR_SHRINK_MODE_MAX;
#endif
        filesys_fsm_mount.transition = FS_MOUNT_STATE_DETECT;
        filesys_outevent |= FS_MOUNT_RESUME;
        return 0;
      }
    }
    else
    {
      filesys_fsm_mount.error_reason = E_DEVICE_NOT_AVAILABLE;
      filesys_fsm_mount.transition = FS_MOUNT_STATE_ERROR;
      filesys_outevent |= FS_MOUNT_FINISHED;
      return FS_TRAN_RESULT_MOUNT;
    }

  case FS_MOUNT_STATE_DETECT:
    if (fs_scan_struct.partition
     >= SYS_DeviceInfoStruct(SYS_GetDeviceID(fs_mount_params.devid))->NumPartitions)
    {
#if (1 == HAVE_WMDRM)                     
      /* Complete to parse file system information. */
      if ((fs_scan_struct.fs_descriptor->FSType == FS_WMDRM_TYPE) && IS_USBDeviceSuppport_WMDRM_ND )
      {
        DRM_RESULT dr;
        
        /* Start Registration/Proximity Detection sequence for WMDRM contents playback. */
        dr = WmdrmNet_TASK_transition( WMDRM_GET_REGISTRATION );
        if ( DRM_FAILED(dr) )
        {
          return E_FAIL;
        }
      }
#endif
      // everything is done
      filesys_fsm_mount.state = FSM_DONE;
      filesys_outevent |= FS_MOUNT_FINISHED;
      return FS_TRAN_RESULT_MOUNT;
    }

    fstype = SYS_PreferedFSType(fs_mount_params.devid, fs_scan_struct.fs_check);
    if (FS_INVALID == fstype) // no idea which fs to test, skip partition
    {
      fs_scan_struct.partition++;
      fs_scan_struct.fs_check = 0;
      return FS_TRAN_RESULT_MOUNT; // force new transition run
    }

    fsid = SYS_DetectFileSystem(SYS_GetDeviceID(fs_mount_params.devid),
                                fstype,
                                fs_scan_struct.partition,
                                &fs_descriptor);

    if(fsid == E_FORCED_UNPLUG)
    { //stop requested, detected in IO_read()
      filesys_fsm_mount.state = FSM_ERROR;
      filesys_fsm_mount.error_reason = E_FORCED_TERMINATION;
      filesys_outevent |= FS_STOP_FINISHED;
      return FS_TRAN_RESULT_MOUNT; // continue and terminate with error        
    }
    
    if (fsid <= 0)
    {
      filesys_outevent |= FS_MOUNT_RESUME;
      fs_scan_struct.fs_check++;
/* BB060929a - BEGIN */
      if (fsid != E_FS_TRYNEXTTRACK)
      {
        filesys_fsm_mount.error_reason = E_NO_FS_FOUND;
      }
      else
      {
        filesys_fsm_mount.error_reason = E_FS_TRYNEXTTRACK;
      }
/* BB060929a - END */
      return 0;
    }

    //to inform CTR that some FS was detected
    filesys_fsm_mount.error_reason = NO_ERROR_REASON;  /* BB060929a */

    // we can continue with scanning
fs_addvol:
    fs_scan_struct.volume = XAR_AddVolume(fsid);
    if (fs_scan_struct.volume < 1)  // check if volume node was created
    {
       if (fs_scan_struct.volume == E_FAIL)
            goto fs_addvol3;
            
#if (HAVE_FSHRINK == 1)
fs_addvol2: