Snapshot.h

// -----------------------------------------------------------------------------
// This file is part of VirtualC64
//
// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
// This FILE is dual-licensed. You are free to choose between:
//
//     - The GNU General Public License v3 (or any later version)
//     - The Mozilla Public License v2
//
// SPDX-License-Identifier: GPL-3.0-or-later OR MPL-2.0
// -----------------------------------------------------------------------------
 
#pragma once
 
#include "AnyFile.h"
#include "Constants.h"
 
namespace vc64 {
 
class C64;
 
struct Thumbnail {
    
    // Image size
    isize width, height;
    
    // Raw texture data
    u32 screen[Texture::height * Texture::width];
    
    // Creation date and time
    time_t timestamp;
    
    // Factory methods
    static Thumbnail *makeWithC64(const C64 &c64, isize dx = 1, isize dy = 1);
    
    // Takes a screenshot from the current texture
    void take(const C64 &c64, isize dx = 1, isize dy = 1);
};
 
struct SnapshotHeader {
    
    // Magic bytes ('V','C','6','4')
    char magic[4];
    
    // Version number (V major.minor.subminor)
    u8 major;
    u8 minor;
    u8 subminor;
    u8 beta;
 
    // Preview image
    Thumbnail screenshot;
};
 
class Snapshot : public AnyFile {
 
public:
 
    //
    // Class methods
    //
 
    static bool isCompatible(const fs::path &path);
    static bool isCompatible(std::istream &stream);
 
    
    //
    // Initializing
    //
 
    Snapshot(const fs::path &path) throws { init(path); }
    Snapshot(const u8 *buf, isize len) throws { init(buf, len); }
    Snapshot(isize capacity);
    Snapshot(C64 &c64);
 
    
    //
    // Methods from CoreObject
    //
 
    const char *objectName() const override { return "Snapshot"; }
 
    
    //
    // Methods from AnyFile
    //
 
    FileType type() const override { return FILETYPE_SNAPSHOT; }
    bool isCompatiblePath(const fs::path &path) override { return isCompatible(path); }
    bool isCompatibleStream(std::istream &stream) override { return isCompatible(stream); }
    void finalizeRead() throws override;
 
    
    //
    // Accessing
    //
 
    std::pair <isize,isize> previewImageSize() const override;
    const u32 *previewImageData() const override;
    time_t timestamp() const override;
 
    // Checks the snapshot version number
    bool isTooOld() const;
    bool isTooNew() const;
    bool isBeta() const;
    bool matches() { return !isTooOld() && !isTooNew(); }
 
    // Returns a pointer to the snapshot header
    SnapshotHeader *getHeader() const { return (SnapshotHeader *)data; }
 
    // Returns a pointer to the thumbnail image
    const Thumbnail &getThumbnail() const { return getHeader()->screenshot; }
 
    // Returns pointer to the core data
    u8 *getSnapshotData() const { return data + sizeof(SnapshotHeader); }
 
    // Records a screenshot
    void takeScreenshot(C64 &c64);
};
 
}