kis_memory_window.cpp

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2010 Dmitry Kazakov <dimula73@gmail.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_debug.h"
#include "kis_memory_window.h"
 
#include <QDir>
 
#define SWP_PREFIX "KRITA_SWAP_FILE_XXXXXX"
 
KisMemoryWindow::KisMemoryWindow(const QString &swapDir, quint64 writeWindowSize)
    : m_readWindowEx(writeWindowSize / 4),
      m_writeWindowEx(writeWindowSize)
{
    m_valid = true;
 
    // swapDir will never be empty, as KisImageConfig::swapDir() always provides
    // us with a (platform specific) default directory, even if none is explicitly
    // configured by the user; also we do not want any logic that determines the
    // default swap dir here.
    KIS_SAFE_ASSERT_RECOVER_NOOP(!swapDir.isEmpty());
 
    QDir d(swapDir);
    if (!d.exists()) {
        m_valid = d.mkpath(swapDir);
    }
 
    const QString swapFileTemplate = swapDir + '/' + SWP_PREFIX;
 
    if (m_valid) {
        m_file.setFileTemplate(swapFileTemplate);
        bool res = m_file.open();
        if (!res || m_file.fileName().isEmpty()) {
            m_valid = false;
        }
    }
 
    if (!m_valid) {
        qWarning() << "Could not create or open swapfile; disabling swapfile" << swapFileTemplate;
    }
}
 
KisMemoryWindow::~KisMemoryWindow()
{
}
 
quint8* KisMemoryWindow::getReadChunkPtr(const KisChunkData &readChunk)
{
    if (!adjustWindow(readChunk, &m_readWindowEx, &m_writeWindowEx)) {
        return nullptr;
    }
 
    return m_readWindowEx.calculatePointer(readChunk);
}
 
quint8* KisMemoryWindow::getWriteChunkPtr(const KisChunkData &writeChunk)
{
    if (!adjustWindow(writeChunk, &m_writeWindowEx, &m_readWindowEx)) {
        return nullptr;
    }
 
    return m_writeWindowEx.calculatePointer(writeChunk);
}
 
bool KisMemoryWindow::adjustWindow(const KisChunkData &requestedChunk,
                                   MappingWindow *adjustingWindow,
                                   MappingWindow *otherWindow)
{
    if(!(adjustingWindow->window) ||
       !(requestedChunk.m_begin >= adjustingWindow->chunk.m_begin &&
         requestedChunk.m_end <= adjustingWindow->chunk.m_end))
    {
        m_file.unmap(adjustingWindow->window);
 
        quint64 windowSize = adjustingWindow->defaultSize;
        if(requestedChunk.size() > windowSize) {
            warnKrita <<
                "KisMemoryWindow: the requested chunk is too "
                "big to fit into the mapping! "
                "Adjusting mapping to avoid SIGSEGV...";
 
            windowSize = requestedChunk.size();
        }
 
        adjustingWindow->chunk.setChunk(requestedChunk.m_begin, windowSize);
 
        if(adjustingWindow->chunk.m_end >= (quint64)m_file.size()) {
            // Align by 32 bytes
            quint64 newSize = (adjustingWindow->chunk.m_end + 1 + 32) & (~31ULL);
 
#ifdef Q_OS_WIN32
            if (otherWindow->chunk.size()) {
                m_file.unmap(otherWindow->window);
            }
#else
            Q_UNUSED(otherWindow);
#endif
 
            if (!m_file.resize(newSize)) {
                return false;
            }
 
#ifdef Q_OS_WIN32
            if (otherWindow->chunk.size()) {
                otherWindow->window = m_file.map(otherWindow->chunk.m_begin,
                                                 otherWindow->chunk.size());
            }
#endif
        }
 
#ifdef Q_OS_UNIX
        // A workaround for https://bugreports.qt-project.org/browse/QTBUG-6330
        m_file.exists();
#endif
 
        adjustingWindow->window = m_file.map(adjustingWindow->chunk.m_begin,
                                             adjustingWindow->chunk.size());
 
        if (!adjustingWindow->window) {
            return false;
        }
    }
 
    return true;
}