filesystem.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2012 Sifteo, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/array.h>
#include <sifteo/asset/loader.h>
#include <sifteo/abi.h>

namespace Sifteo {

class StoredObject {
public:
    _SYSObjectKey sys;

    static const unsigned LIMIT = _SYS_FS_MAX_OBJECT_KEYS - 1;

    static const unsigned MAX_SIZE = _SYS_FS_MAX_OBJECT_SIZE;

    StoredObject(_SYSObjectKey k) : sys(k) {}

    StoredObject(int k) : sys(k) {
        ASSERT(k >= 0 && k <= LIMIT);
    }

    StoredObject(unsigned k) : sys(k) {
        ASSERT(k <= LIMIT);
    }

    operator const _SYSObjectKey () const { return sys; }

    static StoredObject allocate() {
        return StoredObject(LIMIT - _SYS_lti_counter("Sifteo.StoredObject", 0));
    }

    int read(void *buffer, unsigned bufferSize, _SYSVolumeHandle volume = 0) const {
        return _SYS_fs_objectRead(sys, (uint8_t*)buffer, bufferSize, volume);
    }

    int write(const void *data, unsigned dataSize) const {
        return _SYS_fs_objectWrite(sys, (const uint8_t*)data, dataSize);
    }

    int erase() const {
        return write(0, 0);
    }

    template <typename T>
    int read(T &buffer, _SYSVolumeHandle volume = 0) const {
        return read((void*) &buffer, sizeof buffer, volume);
    }

    template <typename T>
    int readObject(T &buffer, _SYSVolumeHandle volume = 0) const {
        return read((void*) &buffer, sizeof buffer, volume);
    }

    template <typename T>
    int write(const T &buffer) const {
        return write((const void*) &buffer, sizeof buffer);
    }

    template <typename T>
    int writeObject(const T &buffer) const {
        return write((const void*) &buffer, sizeof buffer);
    }

    bool operator== (_SYSObjectKey other) const {
        return sys == other;
    }

    bool operator!= (_SYSObjectKey other) const {
        return sys != other;
    }
};


class Volume {
public:
    _SYSVolumeHandle sys;

    enum Type {
        T_GAME      = _SYS_FS_VOL_GAME,         
        T_LAUNCHER  = _SYS_FS_VOL_LAUNCHER,     
    };

    Volume() : sys(0) {}

    Volume(_SYSVolumeHandle vh) : sys(vh) {}

    operator const _SYSVolumeHandle () const { return sys; }

    template <unsigned T>
    static void list(unsigned volType, Array<Volume, T> &volumes)
    {
        volumes.setCount(_SYS_fs_listVolumes(volType, &volumes.begin()->sys,
            volumes.capacity()));
    }

    void exec() const {
        _SYS_elf_exec(sys);
    }

    static Volume running() {
        return (_SYSVolumeHandle) _SYS_fs_runningVolume();
    }

    static Volume previous() {
        return (_SYSVolumeHandle) _SYS_fs_previousVolume();
    }

    bool operator== (_SYSVolumeHandle other) const {
        return sys == other;
    }

    bool operator!= (_SYSVolumeHandle other) const {
        return sys != other;
    }
};


class MappedVolume {
    Volume vol;
    uint32_t offset;

    /*
     * On debug builds, this ensures that only one MappedVolume exists
     * at a time. On release builds, this has no effect and the static
     * variable optimizes out.
     */
    void debugInstanceCounter(int delta) {
        DEBUG_ONLY({
            static int counter = 0;
            counter += delta;
            ASSERT(counter >= 0);
            ASSERT(counter <= 1);
        });
    }

public:
    typedef _SYSUUID UUID;
    typedef _SYSMetadataCubeRange CubeRange;

    static const unsigned MAX_BOOTSTRAP_GROUPS = _SYS_MAX_METADATA_ITEM_BYTES / sizeof(_SYSMetadataBootAsset);

    typedef AssetConfiguration<MAX_BOOTSTRAP_GROUPS> BootstrapAssetConfiguration;

    typedef Array<AssetGroup, MAX_BOOTSTRAP_GROUPS> BootstrapAssetGroups;

    MappedVolume()
        : vol(0), offset(0) {
        debugInstanceCounter(1);
    }

    explicit MappedVolume(Volume vol) {
        debugInstanceCounter(1);
        attach(vol);
    }

    ~MappedVolume()
    {
        debugInstanceCounter(-1);

        // Reclaim a little bit of memory by unmapping
        _SYS_elf_map(0);
    }

    void attach(Volume vol)
    {
        if (this->vol != vol) {
            this->vol = vol;
            offset = _SYS_elf_map(vol);
        }
    }

    Volume volume() const {
        return vol;
    }

    void *metadata(unsigned key, unsigned minSize, unsigned *actualSize) const {
        return _SYS_elf_metadata(vol, key, minSize, actualSize);
    }

    template <typename T>
    const T* metadata(unsigned key, unsigned *actualSize = NULL) const {
        return reinterpret_cast<const T*>(metadata(key, sizeof(T), actualSize));
    }

    template <typename T>
    T* translate(T* va) const {
        return reinterpret_cast<T*>(translate(reinterpret_cast<uint32_t>(va)));
    }

    uint32_t translate(uint32_t va) const {
        return va + offset;
    }

    const char *title(const char *placeholder = "(untitled)") const {
        const char *p = metadata<char>(_SYS_METADATA_TITLE_STR);
        return p ? p : placeholder;
    }

    const char *package(const char *placeholder = "(none)") const {
        const char *p = metadata<char>(_SYS_METADATA_PACKAGE_STR);
        return p ? p : placeholder;
    }

    const char *version(const char *placeholder = "(none)") const {
        const char *p = metadata<char>(_SYS_METADATA_VERSION_STR);
        return p ? p : placeholder;
    }

    const UUID *uuid() const {
        const UUID *p = metadata<UUID>(_SYS_METADATA_UUID);
        static UUID zero;
        return p ? p : &zero;
    }

    void translate(const _SYSMetadataBootAsset &meta, AssetGroup &group)
    {
        bzero(group);
        group.sys.pHdr = translate(meta.pHdr);
    }

    void translate(const _SYSMetadataImage *meta, AssetImage &image, AssetGroup &group)
    {
        bzero(group);
        group.sys.pHdr = translate(meta->groupHdr);

        bzero(image);
        image.sys.pAssetGroup = reinterpret_cast<uint32_t>(&group);
        image.sys.width = meta->width;
        image.sys.height = meta->height;
        image.sys.frames = meta->frames;
        image.sys.format = meta->format;
        image.sys.pData = translate(meta->pData);
    }

    void getBootstrap(BootstrapAssetGroups &groups, BootstrapAssetConfiguration &config)
    {
        uint32_t actual;
        auto vec = metadata<_SYSMetadataBootAsset>(_SYS_METADATA_BOOT_ASSET, &actual);
        if (!vec)
            return;

        unsigned count = actual / sizeof *vec;
        for (unsigned i = 0; i != count; ++i) {

            AssetGroup &group = groups.append();
            translate(vec[i], group);

            config.append(vec[i].slot, group, volume());
        }
    }
};


class FilesystemInfo
{
public:
    _SYSFilesystemInfo sys;

    void gather() {
        _SYS_fs_info(&sys, sizeof sys);
    }

    uint32_t allocationUnitSize() {
        return sys.unitSize;
    }

    uint32_t freeUnits() {
        return sys.freeUnits;
    }

    uint32_t freeBytes() {
        return sys.freeUnits * sys.unitSize;
    }

    uint32_t totalUnits() {
        return sys.totalUnits;
    }

    uint32_t totalBytes() {
        return sys.totalUnits * sys.unitSize;
    }

    uint32_t systemUnits() {
        return sys.systemUnits;
    }

    uint32_t systemBytes() {
        return sys.systemUnits * sys.unitSize;
    }

    uint32_t launcherElfUnits() {
        return sys.launcherElfUnits;
    }

    uint32_t launcherElfBytes() {
        return sys.launcherElfUnits * sys.unitSize;
    }

    uint32_t launcherObjUnits() {
        return sys.launcherObjUnits;
    }

    uint32_t launcherObjBytes() {
        return sys.launcherObjUnits * sys.unitSize;
    }

    uint32_t gameElfUnits() {
        return sys.gameElfUnits;
    }

    uint32_t gameElfBytes() {
        return sys.gameElfUnits * sys.unitSize;
    }

    uint32_t gameObjUnits() {
        return sys.gameObjUnits;
    }

    uint32_t gameObjBytes() {
        return sys.gameObjUnits * sys.unitSize;
    }

    uint32_t selfElfUnits() {
        return sys.selfElfUnits;
    }

    uint32_t selfElfBytes() {
        return sys.selfElfUnits * sys.unitSize;
    }

    uint32_t selfObjUnits() {
        return sys.selfObjUnits;
    }

    uint32_t selfObjBytes() {
        return sys.selfObjUnits * sys.unitSize;
    }
};


} // namespace Sifteo