VLSI Solution Oy Evaluation MP3 Player Source Code Documentation

filesys.h File Reference

File system interface, Implemented: FAT16, FAT32. More...

#include "buffer.h"
#include "board.h"

Include dependency graph for filesys.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	fragmentEntry
	Fragment Table. More...
Defines
#define	IS_FAT_32   UDF
	Use PSW User Definable Flag to indicate FAT16/32.
#define	MAX_NUMBER_FRAGMENTS   10
	Maximum allowable number of fragments in file.
Functions
unsigned char	InitFileSystem ()
	Start the filing system and initialize all necessary subsystems.
unsigned char	OpenFile (unsigned int fileNumber)
	Open a file for reading.
unsigned char	FGetChar ()
	Read a character from current file.
unsigned char	BuildFragmentTable (void)
	Build a fragment table starting from current sector.
unsigned char	ScanForFreeSector ()
	Search for next free sector.
void	WriteClusterChain ()
	Write a cluster chain to FAT for a fragment.
Variables
Public xdata unsigned long	fileSize
	Size of current file to play.
xdata struct fragmentEntry	fragment [MAX_NUMBER_FRAGMENTS]
	Fragment Table.
xdata char	currentFileName [12]
	8 first characters of current file name
xdata unsigned long	freeSector
	Next free cluster number.
data unsigned char	fatSectorsPerCluster
	FAT Global sectors per cluster.

---

Detailed Description

File system interface, Implemented: FAT16, FAT32.

Definition in file filesys.h.

---

Define Documentation

#define IS_FAT_32   UDF

Use PSW User Definable Flag to indicate FAT16/32. Definition at line 15 of file filesys.h. Referenced by BuildFragmentTable(), FatInitGlobals(), GetFatEntry(), GetNextSector(), and WriteClusterChain().

#define MAX_NUMBER_FRAGMENTS   10

Maximum allowable number of fragments in file. Definition at line 22 of file filesys.h.

---

Function Documentation

unsigned char BuildFragmentTable (  void   )

Build a fragment table starting from current sector. Returns number of fragments in song. This function is used to get fast access to the filesystem when playing so cluster chain needs not be followed when the song is playing, that would be too slow with MMC cards without extra buffer memory for the file allocation tables. Note: filesys.c module does not use the fragment table internally. it is written to be a service to the player routine, which uses storage.c module directly for disk access after using the filesys.c module for finding a file to play. I am listening to Darude's Sandstorm while coding this. In terms of memory allocation, this function is devilish. At one stage temp.l is used just to make compiler use memory at temp.l instead of spilling to another unnecessary temp variable... Definition at line 397 of file filesys.c. References Address::b, Address::B::b0, Address::B::b1, Address::B::b3, dataStart, diskSect, DiskBlock::Fat16Table, DiskBlock::Fat32Table, fatSectorsPerCluster, fatStart, fragment, IS_FAT_32, Temp::l, Address::l, fragmentEntry::length, MAX_NUMBER_FRAGMENTS, Public, ReadDiskSector(), sectorAddress, fragmentEntry::start, and temp. Referenced by PlayCurrentFile(). { unsigned char c=0; addressType this,next; addressType fatSector; unsigned char entryNumber; //as long as the sectorAddress is "sane"... while (!(sectorAddress.b.b3 & 0x80)){ fragment[c].start = sectorAddress.l; fragment[c].length = fatSectorsPerCluster; /* Find cluster entry for the current sector */ /* in how manyth sector from start of data area are we? ->this */ this.l = sectorAddress.l - dataStart; /* convert from CurrentSectorN to currentClusterN */ this.l /= fatSectorsPerCluster; /* this.l is now the current cluster number */ /* now let's find the FAT entry for this.l cluster */ if (!IS_FAT_32){ //FAT16 entryNumber = this.b.b0; /* 256 entries / page in FAT16 table */ fatSector.l = this.l >> 8; /* Div by n of entries/page in FAT16 tbl*/ }else{ //FAT32 entryNumber = (this.b.b0 & 0x7f); /* 128 entries/page in FAT32 table */ fatSector.l = this.l >> 7; /* Div by n of entries/page in FAT32 tbl*/ } fatSector.l += fatStart; /* fatSector.l is now the DISK SECTOR NUMBER CONTAINING THE FAT table */ /* read this page into memory */ ReadDiskSector(fatSector.l); if (!IS_FAT_32){ //FAT16 next.l = diskSect.Fat16Table[entryNumber]; /* get next cluster n */ /* Check for FAT16 end-of-file condition */ if ((next.b.b1 == 0xff) && (next.b.b0 == 0xff)){ /* FAT16 End of file */ next.b.b3 = 0xff; /* return a large value (fat32 compatible) */ } }else{ //FAT32 next.l = diskSect.Fat32Table[entryNumber]&0x0fffffff; } /* next.l is the FAT entry (next cluster number) */ ConsoleWrite("\rFragment start: cluster "); ConsolePutUInt(this.l); ConsoleWrite("sector "); ConsolePutUInt(fragment[c].start); while (next.l==(this.l+1)){ //Not a fragment break -- continue to next entry //in this temp.l is used only to allow compiler memory spilling to temp temp.l = fragment[c].length; temp.l += fatSectorsPerCluster; fragment[c].length = temp.l; entryNumber++; // --- Check for a page break if (entryNumber==0){ //entryNumber has rolled over!!!! (8bit char) //FAT16 table page border is reached fatSector.l++; //Advance to next page; entryNumber=0; ReadDiskSector(fatSector.l); } if (IS_FAT_32 && (entryNumber==128)){ //FAT32 table page border is reached fatSector.l++; entryNumber=0; ReadDiskSector(fatSector.l); } // --- Advance to next cluster this.l = next.l; if (!IS_FAT_32){ //FAT16 get next cluster n next.l = diskSect.Fat16Table[entryNumber]; if ((next.b.b1==0xff)&&(next.b.b0==0xff)){ //FAT16 end-of-file next.b.b3 = 0xff; //mark end-of-file (FAT32 compatible) } }else{ //FAT32 get next cluster n next.l = diskSect.Fat32Table[entryNumber]; } }//This repeats until there is a discontinuity /* next.l now has the cluster entry for last cluster in fragment it has a high value if eof (see FAT spec) */ ConsoleWrite("Size: "); ConsolePutUInt(fragment[c].length); ConsoleWrite("sectors."); //EOF test if ((next.b.b3&0x08) //Quick test && ((next.l>0x0ffffff0) | !IS_FAT_32)){ //Complete test //EOF ConsoleWrite(" <EOF>\r"); sectorAddress.b.b3 = 0xff; }else{ //Determine next physical sector for next fragment sectorAddress.l = next.l; sectorAddress.l *= fatSectorsPerCluster; sectorAddress.l += dataStart; } c++; //Advance to next fragment number if (c==MAX_NUMBER_FRAGMENTS){ //End of RAM space allocated for fragment table //Force end-of-file sectorAddress.b.b3=0xff; } }//break or continue to next cluster return c; //Return number of fragments; } Here is the call graph for this function:

unsigned char FGetChar (   )

Read a character from current file. This can be called after calling OpenFile. It is a slow method for reading character based file data. fileSize holds the number of characters still left in file to be read, check for fileSize=0 to detect end-of-file. If FGetChar is called after the end of file is reached, it does nothing and returns 0. Definition at line 549 of file filesys.c. References DiskBlock::Raw::buf, dataBufPtr, diskSect, fileSize, Address::l, LoadNextSector(), Public, DiskBlock::raw, ReadDiskSector(), and sectorAddress. Referenced by GetAVIBlock(). { if (!fileSize) return 0; //return 0 for end-of-file if (dataBufPtr==0){ /* A file has been opened but not read from yet, so read the first sector. */ ReadDiskSector(sectorAddress.l); dataBufPtr = diskSect.raw.buf; } if (dataBufPtr>diskSect.raw.buf+511){ /* An end of sector has been reached, read the next sector */ if (LoadNextSector()){ /* Error, end-of-file according to FAT records */ return 0; /* must return something */ } dataBufPtr=diskSect.raw.buf; } /* Everything should now be ok for reading a byte. */ fileSize--; return (*dataBufPtr++); } Here is the call graph for this function:

unsigned char InitFileSystem (   )

Start the filing system and initialize all necessary subsystems. Init storage and file system. FAT16 and FAT32 are supported Definition at line 902 of file filesys.c. References Address::b, Address::B::b0, Address::B::b1, Address::B::b2, Address::B::b3, DiskBlock::Raw::buf, dataStart, diskSect, FatInitGlobals(), fatStart, freeSector, InitStorage(), Address::l, Public, DiskBlock::raw, ReadDiskSector(), rootStart, and sectorAddress. Referenced by main(). { unsigned char c; /* Initialize variables to sane values in case of error exit. */ fatStart = 0; rootStart = 0; dataStart = 0; freeSector = 0; ConsoleWrite("Init: Filesystem; supports: MBR, FAT16, FAT32\r"); ConsoleWrite("Trying to bring up storage...\r"); /* Initialize the storage system */ if ((c=InitStorage())){ ConsoleWrite("Storage init returns error "); ConsolePutUInt(c); ConsolePutChar(13); return c; /* Error in InitStorage */ } ConsoleWrite("Storage ok.\rSector 0 read..."); /* Load MBR */ sectorAddress.l = 0; /* the first sector on disk */ ReadDiskSector(0); ConsoleWrite("ok.\rSector signature..."); /* Ok, it should be a MBR sector. Let's verify */ if (diskSect.raw.buf[510] != 0x55) return 8; /* sector 0 is not MBR. */ if (diskSect.raw.buf[511] != 0xaa) return 8; /* sector 0 is not MBR. */ ConsoleWrite("ok.\rPartition 1..."); /* This checks that partition 1 is active. Alter code to allow * other partition configurations. */ if (diskSect.raw.buf[0x1be] == 0x80){ sectorAddress.b.b0 = diskSect.raw.buf[0x1c6]; sectorAddress.b.b1 = diskSect.raw.buf[0x1c7]; sectorAddress.b.b2 = diskSect.raw.buf[0x1c8]; sectorAddress.b.b3 = diskSect.raw.buf[0x1c9]; ConsoleWrite (" active"); }else{ //-------- DEBUG: Uncomment if you want to explore the sector //DumpDiskSector(); //while (!KEY_BUTTON); sectorAddress.b.b0 = diskSect.raw.buf[0x1c6]; sectorAddress.b.b1 = diskSect.raw.buf[0x1c7]; sectorAddress.b.b2 = diskSect.raw.buf[0x1c8]; sectorAddress.b.b3 = diskSect.raw.buf[0x1c9]; } // return 9; /* No active partition*/ ConsoleWrite(" at sector "); ConsolePutHex8(sectorAddress.b.b3); ConsolePutHex8(sectorAddress.b.b2); ConsolePutHex8(sectorAddress.b.b1); ConsolePutHex8(sectorAddress.b.b0); ConsolePutChar('\r'); /* Now leave MBR and load sector 0 of partition */ //SeekDiskSectorToRead(); //ReadDiskSector(); /* to global buffer */ ReadDiskSector(sectorAddress.l); if (FatInitGlobals()){ return 0x0a; /* FAT init failed */ } return 0; /* All ok return */ } Here is the call graph for this function:

unsigned char OpenFile (  unsigned int  fileNumber  )

Open a file for reading. Prepares the Filing System to read a data file from the storage. Files are referred to by their numbers, not file names. This makes the system generic, not necessarily needing a complex file system such as FAT. The way to assign numbers to files is implementation dependent. Returns 0 when ok, error code otherwise. Parameters: fileNumber  number of file, starting from beginning of storage, to open. What this function actually does, is: it starts reading the FAT records from start of the root directory, traversing through subdirectories as it encounters them. When the fileNumber'th valid record is encountered, it sets sectorAddress to point to its first data sector but doesn't load any sector. fileSize is loaded with the size in bytes indicated in the FAT record. Additionally, if it's called with 0 as the fileNumber and it happens to see an empty directory record, it registers a new file with name RECnnnnn.WAV starting from cluster fragment[0].start with file size from fragment[0].length Definition at line 598 of file filesys.c. References DirRecordUnion::Entry::Attr, Temp::c, currentFileName, dataBufPtr, dataStart, DiskBlock::dir, dirLevel, dirStack, diskSect, displayText, DirRecordUnion::entry, directoryStack::entry, fatSectorsPerCluster, fileSize, DirRecordUnion::Entry::FileSize, fragment, DirRecordUnion::Entry::FstClusHi, DirRecordUnion::Entry::FstClusLo, GetNextSector(), InitMMC(), Address::l, fragmentEntry::length, MAX_NUMBER_SUBDIRECTORIES, DirRecordUnion::Entry::Name, Public, ReadDiskSector(), rootStart, directoryStack::sector, sectorAddress, fragmentEntry::start, temp, and WriteDiskSector(). Referenced by main(), and WriteClusterChain(). { char tempc; ConsoleWrite("\rFilesystem: Looking for file "); ConsolePutUInt(fileNumber); ConsoleWrite("... "); /* Start at the start of root directory. */ dirLevel = 0; /* At root directory */ dirStack[dirLevel].sector=rootStart; dirStack[dirLevel].entry=0; if (fileNumber==0){ fileNumber = 32766; //use max-1 value for scanning for free entry } while (fileNumber){ if (dirStack[dirLevel].entry==0){ /* At the start of new dir, load first disk sector */ while (ReadDiskSector(dirStack[dirLevel].sector)){ InitMMC; } } temp.c = dirStack[dirLevel].entry; /* We are now looking at FAT directory structure. */ /* Is current entry empty? */ if ((diskSect.dir[temp.c].entry.Name[0]==0) ||(diskSect.dir[temp.c].entry.Name[0]==0xe5)){ /* Yes. Are we supposed to make an entry now? */ if (fileNumber>30000){ //yes, this is actually a request to write file directory entry!; fileNumber = 32767-fileNumber; diskSect.dir[temp.c].entry.Name[0] ='R'; diskSect.dir[temp.c].entry.Name[1] ='E'; diskSect.dir[temp.c].entry.Name[2] ='C'; diskSect.dir[temp.c].entry.Name[7] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[6] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[5] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[4] =(fileNumber%10)+'0'; fileNumber /= 10; diskSect.dir[temp.c].entry.Name[3] =(fileNumber%10)+'0'; diskSect.dir[temp.c].entry.Name[8] ='W'; diskSect.dir[temp.c].entry.Name[9] ='A'; diskSect.dir[temp.c].entry.Name[10]='V'; diskSect.dir[temp.c].entry.Attr = 0; diskSect.dir[temp.c].entry.FstClusHi = (fragment[0].start >> 16); diskSect.dir[temp.c].entry.FstClusLo = (fragment[0].start & 0xffff); diskSect.dir[temp.c].entry.FileSize = (fragment[0].length); ConsoleWrite(" Making Directory Entry "); WriteDiskSector(sectorAddress.l); return 99; //created a FAT entry } //register file } /* Does current entry point to a regular file? */ /* Attributes: NO directory, NO volume id, NO system, NO hidden */ if (((diskSect.dir[temp.c].entry.Attr & 222) == 0) && (diskSect.dir[temp.c].entry.Name[0] != 0xe5) && (diskSect.dir[temp.c].entry.Name[0] != 0) ){ /* It is a regular file. */ if (!(--fileNumber)){ /* ------------ FILE FOUND ------------- */ sectorAddress.l = ((unsigned long)diskSect.dir[temp.c].entry.FstClusHi<<16) + diskSect.dir[temp.c].entry.FstClusLo; sectorAddress.l *= fatSectorsPerCluster; sectorAddress.l += dataStart; fileSize = diskSect.dir[temp.c].entry.FileSize; dataBufPtr = 0; /* Reset data buffer ptr for FGetChar */ ConsoleWrite("found, FAT name is \""); for (tempc=0; tempc<11; tempc++){ ConsolePutChar(diskSect.dir[temp.c].entry.Name[tempc]); } //Store file name nicely for displaying on screen :) for (tempc=0; tempc<8; tempc++){ currentFileName[tempc]=diskSect.dir[temp.c].entry.Name[tempc]; } currentFileName[8]='.'; currentFileName[9]=diskSect.dir[temp.c].entry.Name[8]; currentFileName[10]=diskSect.dir[temp.c].entry.Name[9]; currentFileName[11]=diskSect.dir[temp.c].entry.Name[10]; displayText[0]=' '; for (tempc=0; tempc<12; tempc++){ displayText[tempc+1]=currentFileName[tempc]; } ConsoleWrite("\"\rFile size: "); ConsolePutUInt(fileSize); ConsoleWrite("bytes. "); ConsoleWrite("Start cluster: "); ConsolePutHex8(diskSect.dir[temp.c].entry.FstClusHi); ConsolePutHex8(diskSect.dir[temp.c].entry.FstClusLo); ConsoleWrite("h, sector "); ConsolePutUInt(sectorAddress.l); ConsoleWrite("decimal.\r"); return 0; /* File found, All OK return */ } } /* it was a regular file */ /* Is it a subdirectory? */ if (((diskSect.dir[temp.c].entry.Attr & 16) != 0) && (diskSect.dir[temp.c].entry.Name[0] != '.') /* skip . and .. */ && (diskSect.dir[temp.c].entry.Name[0] != 0xe5) && (diskSect.dir[temp.c].entry.Name[0] != 0) ){ /* It is a subdirectory. */ if (dirLevel<MAX_NUMBER_SUBDIRECTORIES-1){ /* Yes, we have room in dirStack to traverse deeper. */ dirLevel++; /* Advance to next directory level */ sectorAddress.l = ((unsigned long)diskSect.dir[temp.c].entry.FstClusHi<<16) + diskSect.dir[temp.c].entry.FstClusLo; sectorAddress.l *= fatSectorsPerCluster; sectorAddress.l += dataStart; /* Prepare for loading. */ dirStack[dirLevel].sector = sectorAddress.l; dirStack[dirLevel].entry = 255; /* Magic number */ } /* we had room in dirStack */ } /* it was a subdirectory */ /* Have we reached the end of the directory? */ if (diskSect.dir[temp.c].entry.Name[0] == 0){ /* It's the end of directory. */ /* Is it the end of root directory? */ if (dirLevel == 0){ /* End of root directory, end of all files in volume */ ConsoleWrite("File not found.\r"); sectorAddress.l = dataStart; /* when in error point to start of data */ return 0x0c; /* File Not Found return */ } /* End of subdirectory, return from subdirectory */ dirLevel--; ReadDiskSector(dirStack[dirLevel].sector); /* restore temp entry pointer */ temp.c = dirStack[dirLevel].entry; } /* it was end of directory */ /* Advance to next entry */ temp.c++; /* If we just went to a subdir, set temp entry pointer to 0 */ if (dirStack[dirLevel].entry == 255){ /* Magic Number 255: we have gone to a subdirectory */ temp.c=0; } if (temp.c==16){ /* End of sector */ /* Prepare to load next sector */ dirStack[dirLevel].sector = GetNextSector (dirStack[dirLevel].sector); temp.c=0; } dirStack[dirLevel].entry = temp.c; } /* Control should never reach this far, end of root directory should occur first. */ sectorAddress.l = dataStart; /* when in error point to start of data */ return 0x0c; /* File Not Found return */ } Here is the call graph for this function:

unsigned char ScanForFreeSector (   )

Search for next free sector. If freeSector is zero, a new file should be allocated. Definition at line 244 of file filesys.c. References dataStart, fatSectorsPerCluster, freeSector, GetFatEntry(), PConvertClusterToSector(), and PConvertSectorToCluster(). Referenced by Record(). { //ConsoleWrite("\rLooking for free space starting from "); if ((freeSector) && (freeSector-dataStart+1)%fatSectorsPerCluster){ //Still room in current cluster... freeSector++; //ConsoleWrite("free at sector "); //ConsolePutUInt(freeSector); return 1; } if (freeSector){ //Advance to next sector freeSector++; //switch from using sectors to using clusters PConvertSectorToCluster(&freeSector); }else{ freeSector=3; //starting cluster entry (should be 2?) } //scan until free entry is found //freeSector actually counts clusters here. while(GetFatEntry(freeSector)){ freeSector++; } ConsoleWrite("F"); ConsolePutUInt(freeSector); //while (!KEY_BUTTON); //ConsoleWrite("free at cluster "); //ConsolePutUInt(freeSector); //switch back from using clusters to using sectors. PConvertClusterToSector(&freeSector); //ConsoleWrite("sector "); //ConsolePutUInt(freeSector); return 1; } Here is the call graph for this function:

void WriteClusterChain (   )

Write a cluster chain to FAT for a fragment. This takes its input from the fragment[] table. It currently has the ability to register only single fragment from fragment[0]. fragment[1].start should contain the next cluster number after this fragment or 0x0fffffff if this is the last fragment. This function currently also registers a FAT directory entry for the file to first free entry slot in the directory structure. If no free directory entries are available, it will behave unpredictably. This could happen in FAT32. OpenFile(0) is a special call to register a directory entry for fragment[0]. Todo: update second FAT too update second FAT too Definition at line 125 of file filesys.c. References Temp::c, diskSect, DiskBlock::Fat16Table, DiskBlock::Fat32Table, fatSectorsPerCluster, fatStart, fragment, IS_FAT_32, Address::l, fragmentEntry::length, OpenFile(), PConvertSectorToCluster(), ReadDiskSector(), sectorAddress, fragmentEntry::start, temp, and WriteDiskSector(). Referenced by Record(). { xdata unsigned long currentCluster; //is now fragment[0].start xdata unsigned long fragSize; //is now fragment[0].length xdata unsigned long fatPageSector; xdata unsigned char entryNumber; // PREPARE // Calculate starting cluster number... currentCluster = fragment[0].start; PConvertSectorToCluster(&currentCluster); fragSize = fragment[0].length; //size in sectors // Write cluster number and size in bytes to fragment[0] // for the function that registers directory entries fragment[0].start = currentCluster; fragment[0].length *= 512; // Locate the relevant page in FAT clusterchain records fatPageSector = currentCluster; if (!IS_FAT_32){ //FAT16 entryNumber = fatPageSector & 0xff; fatPageSector >>= 8; }else{ //FAT32 entryNumber = fatPageSector & 0x7f; fatPageSector >>= 7; } fatPageSector += fatStart; ConsoleWrite("Writing clusterchain from: "); ConsolePutUInt(currentCluster); ConsoleWrite("Fragment size (sectors): "); ConsolePutUInt(fragSize); ConsoleWrite("FatPageSector: "); ConsolePutUInt(fatPageSector); ConsoleWrite("EntryNumber: "); ConsolePutUInt(entryNumber); // WRITE CLUSTER CHAIN TO FIRST FAT while (fragSize>fatSectorsPerCluster){ // while more than 1 cluster left... // is the FAT clusterchain page changed? if (sectorAddress.l != fatPageSector){ // Yes, have we advanced by 1 sector? if (sectorAddress.l == (fatPageSector - 1)){ //Yes, we must save the edited sector WriteDiskSector (sectorAddress.l); } // at least we need to load the new clusterchain page sectorAddress.l = fatPageSector; ReadDiskSector(sectorAddress.l); }//Load/Save FAT sector // Register Middle Entry currentCluster++; //advancce to next cluster //fragSize-=fatSectorsPerCluster; //we will register one cluster //to avoid memory spill in C compiler, the preceding line is written as: for (temp.c = fatSectorsPerCluster;temp.c;temp.c--){ fragSize--; } if (IS_FAT_32){ diskSect.Fat32Table[entryNumber]=currentCluster; }else{ diskSect.Fat16Table[entryNumber]=(currentCluster&0xffff); } // Calculate next entry position in FAT records fatPageSector = currentCluster; if (!IS_FAT_32){ //FAT16 entryNumber = fatPageSector & 0xff; fatPageSector >>= 8; }else{ //FAT32 entryNumber = fatPageSector & 0x7f; fatPageSector >>= 7; } fatPageSector += fatStart; }//while // WRITE THE FINAL ENTRY TO FAT CLUSTERCHAIN // is the FAT clusterchain page changed? if (sectorAddress.l != fatPageSector){ // Yes, have we advanced by 1 sector? if (sectorAddress.l == (fatPageSector - 1)){ //Yes, we must save the edited sector WriteDiskSector (sectorAddress.l); } // at least we need to load the new clusterchain page sectorAddress.l = fatPageSector; ReadDiskSector(sectorAddress.l); }//Load/Save FAT sector //Write the Last entry if (IS_FAT_32){ diskSect.Fat32Table[entryNumber]=fragment[1].start; }else{ diskSect.Fat16Table[entryNumber]=(fragment[1].start & 0xffff); } WriteDiskSector(sectorAddress.l); //Write last sector OpenFile(0); //Register FAT entry } Here is the call graph for this function:

---

Variable Documentation

xdata char currentFileName[12]

8 first characters of current file name Definition at line 31 of file filesys.h. Referenced by main(), and OpenFile().

data unsigned char fatSectorsPerCluster

FAT Global sectors per cluster. Definition at line 84 of file filesys.h. Referenced by BuildFragmentTable(), FatInitGlobals(), GetNextSector(), OpenFile(), PConvertClusterToSector(), PConvertSectorToCluster(), Record(), ScanForFreeSector(), and WriteClusterChain().

Public xdata unsigned long fileSize

Size of current file to play. Definition at line 17 of file filesys.h. Referenced by FGetChar(), GetAVIBlock(), OpenFile(), and PlayAvi().

xdata struct fragmentEntry fragment[MAX_NUMBER_FRAGMENTS]

Fragment Table.

xdata unsigned long freeSector

Next free cluster number. Definition at line 82 of file filesys.h. Referenced by InitFileSystem(), Record(), and ScanForFreeSector().

---

All software copyright 2000-2004 VLSI Solution OY. Redistribution of these software modules are limited to promotional use only and only with the VS1011 / VS1002 / VS1003 MP3-Evakit evaluation boards. Free or commercial use of these software modules in MP3 players is ok if the product includes MP3 decoder chip(s) from VLSI. You can request the complete (compilable) package from mp3@vlsi.fi