FatReader.h

/* Arduino FatReader Library
 * Copyright (C) 2009 by William Greiman
 *
 * This file is part of the Arduino FatReader Library
 *
 * This Library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This Library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with the Arduino FatReader Library.  If not, see
 * <http://www.gnu.org/licenses/>.
 */
#ifndef FatReader_h
#define FatReader_h
#include <FatStructs.h>
#include <SdReader.h>

// flags for ls()
#define LS_FLAG_FRAGMENTED 1

#define LS_SIZE 2

#define LS_R 4

// offsets for structures used in volume init
#define BPB_OFFSET 11

#define BPB_COUNT 37

#define PART_OFFSET (512 - 64 - 2)

// format dir.name into name[13] as standard 8.3 string
void dirName(dir_t &dir, char name[]);
// Print name field of dir_t struct in 8.3 format
void printEntryName(dir_t &dir);
//------------------------------------------------------------------------------
class FatVolume {
  friend class FatReader;
  uint8_t blocksPerCluster_;
  uint32_t blocksPerFat_;
  uint32_t clusterCount_;
  uint32_t dataStartBlock_;
  uint8_t fatCount_;
  uint32_t fatStartBlock_;
  uint8_t fatType_;
  SdReader *rawDevice_;
  uint16_t rootDirEntryCount_;
  uint32_t rootDirStart_;
  uint32_t totalBlocks_;
  uint8_t chainIsContiguous(uint32_t cluster);
  uint32_t chainSize(uint32_t cluster);
  uint8_t isEOC(uint32_t cluster) {
    return cluster >= (fatType_ == 16 ? FAT16EOC_MIN : FAT32EOC_MIN);
  }
  uint32_t nextCluster(uint32_t cluster);
  uint8_t rawRead(uint32_t block, uint16_t offset, uint8_t *dst,
                  uint16_t count) {
    return rawDevice_->readData(block, offset, dst, count);
  }
  uint8_t validCluster(uint32_t cluster) {
    return (1 < cluster && cluster < (clusterCount_ + 2));
  }

public:
  FatVolume(void) : fatType_(0) {}
  uint8_t init(SdReader &dev) { return init(dev, 1) ? 1 : init(dev, 0); }
  uint8_t init(SdReader &dev, uint8_t part);

  // inline functions that return volume info
  uint8_t blocksPerCluster(void) { return blocksPerCluster_; }
  uint32_t blocksPerFat(void) { return blocksPerFat_; }
  uint32_t clusterCount(void) { return clusterCount_; }
  uint32_t dataStartBlock(void) { return dataStartBlock_; }
  uint8_t fatCount(void) { return fatCount_; }
  uint32_t fatStartBlock(void) { return fatStartBlock_; }
  uint8_t fatType(void) { return fatType_; }

  SdReader *rawDevice(void) { return rawDevice_; }
  uint32_t rootDirEntryCount(void) { return rootDirEntryCount_; }
  uint32_t rootDirStart(void) { return rootDirStart_; }
  uint32_t totalBlocks(void) { return totalBlocks_; }
};
//------------------------------------------------------------------------------
class FatReader {
// values for type_
#define FILE_IS_CONTIGUOUS 0X08

#define FILE_TYPE_MASK 0X07

#define FILE_TYPE_CLOSED 0X00

#define FILE_TYPE_NORMAL 0X01

#define FILE_TYPE_ROOT16 0X02

#define FILE_TYPE_ROOT32 0X03

#define FILE_TYPE_SUBDIR 0X04

#define FILE_TYPE_MIN_DIR FILE_TYPE_ROOT16
  uint8_t type_;
  uint32_t fileSize_;
  uint32_t readCluster_;
  uint32_t readPosition_;
  uint32_t firstCluster_;
  FatVolume *vol_;
  int16_t readBlockData(uint8_t *dst, uint16_t count);
  void lsR(dir_t &d, uint8_t flags, uint8_t indent);

public:
  FatReader(void) : type_(FILE_TYPE_CLOSED) {}
  void ls(uint8_t flags = 0);
  uint8_t openRoot(FatVolume &vol);
  uint8_t open(FatVolume &vol, dir_t &dir);
  uint8_t open(FatReader &dir, char *name);
  uint8_t open(FatReader &dir, uint16_t index);
  void optimizeContiguous(void);
  int16_t read(void *buf, uint16_t count);
  int8_t readDir(dir_t &dir);
  void rewind(void);
  uint8_t seekCur(uint32_t pos);
  // inline functions
  void close(void) { type_ = FILE_TYPE_CLOSED; }
  uint32_t fileSize(void) { return fileSize_; }
  uint8_t fileType(void) { return type_ & FILE_TYPE_MASK; }
  uint32_t firstCluster(void) { return firstCluster_; }
  uint8_t isContiguous(void) { return type_ & FILE_IS_CONTIGUOUS; }
  uint8_t isDir(void) { return fileType() >= FILE_TYPE_MIN_DIR; }
  uint8_t isFile(void) { return fileType() == FILE_TYPE_NORMAL; }
  uint8_t isOpen(void) { return fileType() != FILE_TYPE_CLOSED; }
  uint32_t readCluster(void) { return readCluster_; }
  uint32_t readPosition(void) { return readPosition_; }
  uint8_t seekSet(uint32_t pos) {
    if (pos >= readPosition_)
      return seekCur(pos - readPosition_);
    rewind();
    return seekCur(pos);
  }

  FatVolume *volume(void) { return vol_; }
};
#endif // FatReader_h