SramManager.h

Go to the documentation of this file.

/**************************************************************************/
#ifndef AVIATE_SRAMMANAGER_H_
#define AVIATE_SRAMMANAGER_H_
 
#include <memory>
#include "Aviate/Aviate.h"
#include "Aviate/ForwardDeclares.h"
 
namespace Aviate {
 
class SramManager;
 
class AVIATE_API SramMemSlot {
public:
    SramMemSlot();  
    virtual ~SramMemSlot();
 
    bool clear();
 
    bool isUseDma() const;
 
    bool isWriteBusy() const;
 
    bool isReadBusy() const;
 
    size_t size();
 
    bool setWritePosition(size_t offsetBytes);
 
    size_t getWritePosition() const;
 
    bool setReadPosition(size_t offsetBytes);
 
    size_t getReadPosition() const;
 
    /* Byte-based transfers */
 
    bool zero(size_t offsetBytes, size_t numBytes);
 
    bool write(size_t offsetBytes, uint8_t *src, size_t numBytes);
 
    bool read(size_t offsetBytes, uint8_t *dest, size_t numBytes);
 
    bool zeroAdvance(size_t numBytes);
 
    bool writeAdvance(uint8_t data); // write just one data
 
    bool writeAdvance(uint8_t *src, size_t numBytes);
 
    uint8_t readAdvance();
 
    bool readAdvance(uint8_t *dest, size_t numBytes);
 
 
    /* 16-bit data transfers */
 
    bool zero16(size_t offsetWords, size_t numWords);
 
    bool write16(size_t offsetWords, int16_t *src, size_t numWords);
 
    bool read16(size_t offsetWords, int16_t *dest, size_t numWords);
 
    bool zeroAdvance16(size_t numWords);
 
    bool writeAdvance16(int16_t *src, size_t numWords);
 
    bool writeAdvance16(int16_t data); // write just one data
 
    uint16_t readAdvance16();
 
    bool readAdvance16(int16_t *dest, size_t numWords);
 
    bool enable() const;
 
    bool isEnabled() const;
 
    friend SramManager;   
    friend AudioDelay;    
 
private:
    class Impl;
    std::unique_ptr<Impl> _pimpl;
};
 
/**************************************************************************/
class AVIATE_API SramManager final {
public:
    SramManager(bool useDma);
    virtual ~SramManager();  
 
    void begin();
 
    size_t availableMemory();
 
    SramMemSlot* requestMemory(float delayMilliseconds, bool clearMemory = false);
 
    SramMemSlot* requestMemory(size_t sizeBytes, bool clearMemory = false);
 
    SysPlatform::SysSpi* getSpiMemoryPtr();
 
    SysPlatform::SysSpi* getSpiDmaMemoryPtr();
 
    bool isUsingDma();
 
    void stop(bool waitForStop = false);
 
    void start(bool waitForStart = false);
 
    bool isStopped();
 
    bool isStarted();
 
    bool runSramTest();
 
 
private:
    struct Impl;
    std::unique_ptr<Impl> _pimpl;
};
 
extern volatile SramManager* sramManagerPtr;  
 
}
 
#endif // LIBAVALON_FLASHMANAGER_H_