// --- Simple file header ---
char fileType[8] = "MEMFRAG!";
uint32_t version;
 
// --- Assets section starts here ---
char assetsSection[4] = "ASTS";
uint32_t assetCount;
struct {
    char assetName[128]; // Name of asset in UTF-8
    uint32_t offset; // File offset to asset
} assetTOC[assetCount];
 
// --- Assets will follow this pattern. ---
char assetSection[4] = "ASET";
char assetType[4] = "<asset type goes here>";
uint32_t version;
uint8_t assetData[dataSize];
uint8_t paddingTo32BitBoundary[x];
 
// --- Arbitrary binary data asset ---
char assetSection = "ASET";
char assetType = "DATA";
uint32_t version;
uint32_t size;
uint8_t data[size];
uint8_t paddingTo32BitBoundary[x];
 
// --- Texture asset ---
char assetSection[4] = "ASET";
char assetType[4] = "TXTR";
uint32_t version;
uint32_t format; // PVR (iPhone), PNG or DDS (Mac)
uint32_t size;
uint8_t data[size];
uint8_t paddingTo32BitBoundary[x];
 
// --- Effect asset ---
char assetSection[4] = "ASET";
char fileType[4] = "EFCT";
uint32_t version;
uint32_t lengthOfVertexShader;
char vertexShader[lengthOfVertexShader];
uint32_t lengthOfFragmentShader;
char fragmentShader[lengthOfFragmentShader];
uint32_t attributeCount;
struct {
   uint32_t index;
   uint32_t standardAttributeIndex; // -1 if not standard
} attributes[attributeCount];
 
// --- Sprite asset ---
char assetSection[4] = "ASET";
char fileType[4] = "SPRT";
uint32_t version;
char texture[64]; // Asset name
uint32_t frameCount;
struct {
   uint32_t originX;
   uint32_t originY;
   uint32_t sizeX;
   uint32_t sizeY;
   uint32_t hotspotX;
   uint32_t hotspotY;
} frames[frameCount];
uint32_t animationCount;
struct {
   char key[64];
   uint32_t loopCount;
   float frameDuration;
   uint32_t frameCount;
   uint32_t frames[frameCount];
} animations[animationCount];
 
// --- Sound asset ---
char assetSection[4] = "ASET";
char assetType[4] = "SOND";
uint32_t version;
uint32_t format; // AL_FORMAT_STEREO16 or AL_FORMAT_MONO16
uint32_t sampleRate;
uint32_t size;
uint8_t data[size];
uint8_t paddingTo32BitBoundary[x];
 
// --- Music asset ---
char assetSection[4] = "ASET";
char assetType[4] = "MUSC";
uint32_t version;
char filePath[128]; // Music files stored separately.

#import <Foundation/Foundation.h>
 
 
@interface MemoryMappedFile : NSObject
{
@private
    NSString *path;
    void *baseAddress;
    NSUInteger size;
}
 
// The path of the file to map into memory.
@property (nonatomic, readonly) NSString *path;
 
// The memory address where the file is mapped.
// NULL when the file is not mapped into memory.
@property (nonatomic, readonly) void *baseAddress;
 
// Total size of the file.
@property (nonatomic, readonly) NSUInteger size;
 
// Returns YES when the file is mapped into memory.
@property (nonatomic, readonly) BOOL isMapped;
 
// Prepares to map the specified file, but does not
// actually map the file into memory.
- (id)initWithPath:(NSString *)pathToFile;
 
// Maps the file into memory.
// Returns pointer to start of file or NULL if unsuccessful.
- (void *)map;
 
// Unmaps the file from memory.
// The pointer returned by map is no longer valid.
- (void)unmap;
 
@end

#import "MemoryMappedFile.h"
#import <fcntl.h>
#import <unistd.h>
#import <sys/stat.h>
#import <sys/mman.h>
 
@implementation MemoryMappedFile
 
@synthesize path;
@synthesize baseAddress;
@synthesize size;
 
- (id)initWithPath:(NSString *)pathToFile
{
    if (self = [super init])
    {
        path = [pathToFile copyWithZone:nil];
    }
 
    return self;
}
 
- (void)dealloc
{
    if ([self isMapped])
    {
        [self unmap];
    }
 
    [path release];
    [super dealloc];
}
 
- (void *)map
{
    if ([self isMapped])
    {
        return baseAddress;
    }
 
    // This will be released when "path" is released.
    const char *cPath = [path
            cStringUsingEncoding:NSISOLatin1StringEncoding];
 
    // The file must be opened so we can pass 
    // the file descriptor to mmap().
    int file = open(cPath, O_RDONLY);
    if (file == -1)
    {
        perror("open");
        return NULL;
    }
 
    // Get info about file, we need the file size.
    struct stat buffer;
    if (fstat(file, &buffer) == -1)
    {
        perror("fstat");
        close(file);
        return NULL;
    }
 
    // Map the file as read only pages.
    baseAddress = mmap(NULL, buffer.st_size, PROT_READ,
                        MAP_SHARED, file, 0);
    if (baseAddress == MAP_FAILED)
    {
        perror("mmap");
        close(file);
        return NULL;
    }
 
    // Store the size, we need it when we unmap the file.
    size = (NSUInteger)buffer.st_size;
 
    // It's ok to close() after mmap().
    if (close(file) == -1)
    {
        perror("close");
        [self unmap];
        return NULL;
    }
 
    return baseAddress;
}
 
- (void)unmap
{
    // Only unmap the file if it is actually mapped.
    if ([self isMapped])
    {
        if (munmap(baseAddress, size) == -1)
        {
            perror("munmap");
            // There's not much we can do if munmap() fails.
        }
 
        baseAddress = NULL;
        size = 0;
    }
}
 
- (BOOL)isMapped
{
    return baseAddress != NULL;
}
 
@end