xfile.c

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

#else
      X_array[X_NEXTFREE_ITEM].data.xfile.name = X_POOL_TOP;
      *pt = item->file.NameLength;
      memcpy(pt - (item->file.NameLength), item->file.Name, item->file.NameLength);
      X_POOL_TOP += item->file.NameLength + 1;
#endif
    }
    else
    {
      X_array[X_NEXTFREE_ITEM].data.xfile.name = 0xffff;    // no name
    }
  }

  X_NEXTFREE_ITEM++;
  return X_NEXTFREE_ITEM - 1;
}

#ifdef APM_PICKUP
void XAR_PrintNode(UInt item)
{
  uint8 *pt;
  uint8 l;
  int i;
  if (X_array[item].type == XTYPE_DIRECTORY)
  {
    printf(">>>>> DIRECTORY >>>>>\n");
    printf("X node %d, type 0x%X\n", item, X_array[item].type);
    printf("LBA : %X\n",X_array[item].data.xdir.lba);
    printf("entry offset : %X\n", X_array[item].data.xdir.address);
    pt = ((uint8 *)&X_array[XFILE_NODES_NUM]) - X_array[item].data.xdir.name - 1;
  }
  else if (X_array[item].type == XTYPE_TRACK)
  {
    printf(">>>>> TRACK >>>>>\n");
    printf("X node %d, type 0x%X\n", item, X_array[item].type);
    printf("LBA : %X\n",X_array[item].data.xtrack.lba);
    printf("size : %d B\n", X_array[item].data.xtrack.size);
    return;
  }
  else
  {
    printf(">>>>> FILE >>>>>\n");
    printf("X node %d, type 0x%X\n", item, X_array[item].type);
    printf("LBA : %X\n",X_array[item].data.xfile.lba);
#ifndef APM_PICKUP
    printf("entry : %X\n", X_array[item].data.xfile.address);
#endif
    printf("size : %d B\n", X_array[item].data.xfile.size);
    pt = ((uint8 *)&X_array[XFILE_NODES_NUM]) - X_array[item].data.xfile.name - 1;
  }
  l = *pt;
  pt -= l;
  printf("String length: %d\n", l);
  printf("String address: %d\n", X_array[item].data.xdir.name);

  for (i = 0; i < l; i++,pt++)
  {
    printf("%c", *pt);
  }
  printf("\n");
}
#endif


int16 XAR_LastIndex(void)
{
  //return X_last_item-1;
  return X_NEXTFREE_ITEM - 1;
}

uint32 XAR_DirRecordLba(int16 index)
{
  uint32 type;

  type = XAR_NodeType(index);
  if (type == XTYPE_DIRECTORY)
#if HAVE_EXTERNAL_XARRAY
    return X_array[index].data.xdir.lba;
#else
    return X_array[index].data.xdir.lba_lsp + (((uint32)X_array[index].data.xdir.lba_msp) << 16);    ;
#endif
  //M.Ch.

  if ((type == XTYPE_DATA_FILE) | (type == XTYPE_FILE_EXTEND))
#if HAVE_EXTERNAL_XARRAY
    return X_array[index].data.xfile.lba;
#else
    return X_array[index].data.xfile.lba_lsp + (((uint32)X_array[index].data.xfile.lba_msp) << 16);
#endif
  return 0;
}

int16 XAR_DirFirstFile(int16 index)
{
  if (XAR_NodeType(index) != XTYPE_DIRECTORY)
    return 0;
  return X_array[index].data.xdir.first_file;
}

GRESULT XAR_SetDirFirstFile(int16 parent, int16 file)
{
  ASSERT((XAR_NodeType(parent) == XTYPE_DIRECTORY), "XAR_SetDirFirstFile wrong parameter");
  /*if(XAR_NodeType(parent) != XTYPE_DIRECTORY)
      return E_FAIL;*/

  X_array[parent].data.xdir.first_file = file;
  return S_OK;
}

GRESULT XAR_SetDirParent(int16 child, int16 parent)
{
  ASSERT((XAR_NodeType(child) == XTYPE_DIRECTORY), "XAR_SetDirParent wrong child");
  /*if(XAR_NodeType(child) != XTYPE_DIRECTORY)
    return E_FAIL; */

  X_array[child].data.xdir.parent = parent;
  return S_OK;
}

GRESULT XAR_DirChild(int16 parent)
{
  if (XAR_NodeType(parent) != XTYPE_DIRECTORY)
    return 0;
  return X_array[parent].data.xdir.child;
}

GRESULT XAR_DirParent(int16 dir)
{
  if (XAR_NodeType(dir) != XTYPE_DIRECTORY)
    return 0;
  return X_array[dir].data.xdir.parent;
}

GRESULT XAR_SetDirChild(int16 parent, int16 child)
{
  ASSERT((XAR_NodeType(parent) == XTYPE_DIRECTORY), "XAR_SetDirChild wrong parent");
  /*if(XAR_NodeType(parent) != XTYPE_DIRECTORY)
     return E_FAIL;*/

  X_array[parent].data.xdir.child = child;
  return S_OK;
}

GRESULT XAR_IsDirectory(int16 item)
{
  if (XAR_NodeType(item) == XTYPE_DIRECTORY)
    return S_TRUE;
  return S_FALSE;
}

void XAR_ClearXArray(void)
{
  X_NEXTFREE_ITEM = 0;
#if HAVE_EXTERNAL_XARRAY  
  writeSDRAM32((int16*)&X_POOL_TOP,0);
#else
  X_POOL_TOP = 0;
#endif
  
}


#define VALID_VOLUME_NODE(_item) ((_item) >= 0)

/******************************************************************************/
/* Function:  XAR_VolumeNode                                                    */
/*                                                                            */
/*! \brief    returns index of volume node
 *  \param    index of volume to acquire
 *  \return
 *  \remark
 */
/******************************************************************************/
GRESULT XAR_VolumeNode(char volume)  // volume should be indexed 1,2,...
{
  uint16 index_vol = 0, index = 0;

  while (1)
  {
    if ((index >= X_NEXTFREE_ITEM) || (XTYPE_VOLUME != XAR_NodeType(index)))
      return E_FAIL;
    index_vol++;
    if (index_vol == volume)
      return index;
    index = index + X_array[index].data.xvolume.nodes_num + 1;
    if (index > XFILE_NODES_NUM)
      return E_FS_INTEGRITY_ERROR;
  }
}

GRESULT XAR_NextDir(uint16 current)
{
  uint16 i;

  if (!XAR_IsDirectory(current))
  {
    ASSERT(0, "XAR_NextDir invalid parameter");
    return E_FAIL;
  }

  i = current;
  while ((i < XAR_LastIndex()) && (XAR_NodeType(i) != XTYPE_VOLUME))
  {
    i++;
    if (XAR_IsDirectory(i))
    {
      if (XAR_DirParent(current) == XAR_DirParent(i))
        return i;
      return S_NOT_FOUND;  // 0
    }
  }
  return S_NOT_FOUND;
}

#if XARREM
GRESULT XAR_RootDir(char volume)
{
  GRESULT res;

  res = XAR_VolumeNode(volume);
  if (!VALID_VOLUME_NODE(res))
    return S_NOT_FOUND;

  if (XAR_NodeType(res + 1) == XTYPE_DIRECTORY)  // first directory in volume should be root
    return res + 1;

  return S_NOT_FOUND;
}


GRESULT XAR_PrevDir(uint16 current)
{
  uint16 i;

  if (!XAR_IsDirectory(current))
    return S_NOT_FOUND;

  i = current;
  while ((i > 2) && (XAR_NodeType(i) != XTYPE_VOLUME))
  {
    i--;
    if (XAR_IsDirectory(i))
    {
      if (XAR_DirParent(current) == XAR_DirParent(i))
        return i;
      return S_NOT_FOUND;  // 0
    }
  }
  return S_NOT_FOUND;
}

GRESULT XAR_DirStopFromDir(uint16 dir)
{
  uint16 i;
  uint16 j;

  i = dir;
  while ((i < XAR_LastIndex()) && (XAR_NodeType(i) != XTYPE_VOLUME))
  {
    i++;
    if (XAR_IsDirectory(i))
    {
      j = XAR_DirFirstFile(i);
      if (j)
      {
        return j;
      }
    }
  }

  //  if(!X_dir_stop)
  //      X_dir_stop=i+1;

  return i + 1;
}

GRESULT XAR_FindFile(uint16 dir, uint16 index)
{
  uint16 count;
  uint16 i;
  //uint16 curr_dir = dir;
  uint16 dir_first, dir_stop;

  if (!XAR_IsDirectory(dir))
  {
    ASSERT(0, "XAR_FindFile wrong dir parameter");
    return E_FAIL;
  }
  //  X_curr_dir = dir;

  //  X_dir_first=XAR_DirFirstFile(dir);
  dir_first = XAR_DirFirstFile(dir);

  if (2 > dir_first)
    return S_NOT_FOUND;    // 0

  if (1 == index)
    return dir_first;

  //  X_dir_stop = 0;
  dir_stop = XAR_DirStopFromDir(dir);


  // now X_dir_stop first file assigned to different directory or top of X-files

  if (index < 0x7fff)
  {
    //      i=X_dir_first;
    i = dir_first;

    count = 1;
    while ((i < XAR_LastIndex()) && (XAR_NodeType(i) != XTYPE_VOLUME))
    {
      i++;
      //          if(i>=X_dir_stop)
      if (i >= dir_stop)
      {
        return S_NOT_FOUND;
      }
      if ((XTYPE_DATA_FILE == XAR_NodeType(i))
//TODO       || (XTYPE_TRACK == XAR_NodeType(i))
         )
      {
        count++;
        if (index == count)
          return i;
      }
    }
  }
  else  // find last file in directory
  {
    //      i=X_dir_stop;
    i = dir_stop;
    //      while(i>X_dir_first)
    while (i > dir_first)
    {
      i--;
      if ((XTYPE_DATA_FILE == XAR_NodeType(i))
//TODO       || (XTYPE_TRACK == XAR_NodeType(i))
         )
      {
        return i;
      }
    }
  }

  return S_NOT_FOUND;
}


GRESULT XAR_NextFile(uint16 i,uint16 dirstop)
{
  uint16 dir_stop;

  if ((XTYPE_DATA_FILE != XAR_NodeType(i))
//TODO   || (XTYPE_TRACK != XAR_NodeType(i))
   || (!i))
    return S_NOT_FOUND;

  dir_stop = dirstop;
  if(!dirstop)
    dir_stop = XAR_DirStopFromFile(i);
  

  //   if((!X_dir_stop)||(!i))
  //       return S_NOT_FOUND;

  i++;
  //   while(i<X_dir_stop)
  while (i < dir_stop)
  {
    if ((XTYPE_DATA_FILE == XAR_NodeType(i))
//TODO     || (XTYPE_TRACK != XAR_NodeType(i))
       )
      return i;
    i++;
  }
  return S_NOT_FOUND;
}


GRESULT XAR_PrevFile(uint16 i)
{
  uint16 dir_first;

  //   if(!X_dir_first)
  //       return S_NOT_FOUND;
  dir_first = XAR_DirFirstFromFile(i);

  i--;
  //   while(i>=X_dir_first)
  while (i >= dir_first)
  {
    if ((XTYPE_DATA_FILE == XAR_NodeType(i))
//TODO     || (XTYPE_TRACK == XAR_NodeType(i))
       )
      return i;
    i--;
  }
  return S_NOT_FOUND;
}


GRESULT XAR_ForwDir(uint16 dir, uint16 root)
{
  GRESULT res;
  uint16 dir2;
  //bool flag;

  if (0 < (res = XAR_DirChild(dir)))
  {
    //  XAR_SetDirRange(res);
    return res;
  }

  if (root)
  {
    if (dir == root)
      return S_NOT_FOUND;
  }
  else
  {
    if (!XAR_DirParent(dir))
      return S_NOT_FOUND;
  }

  dir2 = dir;

  //  flag=true;
  do
  {
    dir2 = XAR_NextDir(dir);

    if (dir2 > 0)
    {
      //  XAR_SetDirRange(dir2);
      return dir2;
    }

    dir2 = XAR_DirParent(dir);
    if (!dir2)
      return S_NOT_FOUND;
    dir = dir2;

    if (root)
    {
      if (dir == root)
        return S_NOT_FOUND;
    }
    else
    {
      if (!XAR_DirParent(dir))
        return S_NOT_FOUND;
    }
  }
  while (1);
}


GRESULT XAR_BackwDir(uint16 dir, uint16 root)
{
  uint16 dir2, rootd;

  if ((XAR_NodeType(dir) != XTYPE_DIRECTORY) || (!XAR_DirParent(dir)))
    return S_NOT_FOUND;
  if (root)
  {
    if (dir == root)
      return S_NOT_FOUND;
  }


  dir2 = XAR_PrevDir(dir);


  DEBUG_LOG("Backwdir: step previous attempt %d\n", dir2)

  if (dir2 == S_NOT_FOUND)
  {
    dir2 = XAR_DirParent(dir);
    DEBUG_LOG("Backwdir: step parent done %d\n", dir2)
  }
  else
  {
    rootd = dir2;
    do
    {
      dir = dir2;
      dir2 = XAR_ForwDir(dir, rootd);
      DEBUG_LOG("Backwdir: step forward done %d\n", dir2)
    }
    while (dir2 > 0);

    return dir;
  }

  return dir2;
}



GRESULT XAR_NextSong2(uint16, uint16, uint16);
GRESULT XAR_NextSong(uint16 vol, uint16 cur,uint16 use_last_dirstop)
{
  GRESULT tmp;

  tmp = cur;
  do
  {
    tmp = XAR_NextSong2(vol, tmp, use_last_dirstop);
    if(tmp==S_NOT_FOUND)
        return tmp;         
  }
  while (!XAR_IsPlayableFile(tmp));

  return tmp;
}




/******************************************************************************/
/* Function:  XAR_NextSong                                                    */
/*                                                                            */
/*! \brief    returns index of song following current one, use it for CA only
 *  \params
 *    vol - index of volume to acquire, can be 0 - only cur is considered
 *    cur - index of current song, can be 0 - then first song from volume is selected