Added Daybreak, a system updater homebrew (#1073)

* Implemented a system updater homebrew (titled Daybreak)

* git subrepo pull ./troposphere/daybreak/nanovg

subrepo:
  subdir:   "troposphere/daybreak/nanovg"
  merged:   "c197ba2f"
upstream:
  origin:   "https://github.com/Adubbz/nanovg-deko.git"
  branch:   "master"
  commit:   "c197ba2f"
git-subrepo:
  version:  "0.4.1"
  origin:   "???"
  commit:   "???" (+1 squashed commits)

Squashed commits:

[232dc943] git subrepo clone https://github.com/Adubbz/nanovg-deko.git troposphere/daybreak/nanovg

subrepo:
  subdir:   "troposphere/daybreak/nanovg"
  merged:   "52bb784b"
upstream:
  origin:   "https://github.com/Adubbz/nanovg-deko.git"
  branch:   "master"
  commit:   "52bb784b"
git-subrepo:
  version:  "0.4.1"
  origin:   "???"
  commit:   "???"

* daybreak: switch to using hiddbg for home blocking (+1 squashed commits)

Squashed commits:

[4bfc7b0d] daybreak: block the home button during installation

troposphere/daybreak/nanovg/source/framework/CApplication.cpp

@@ -0,0 +1,69 @@
+/*
+** Sample Framework for deko3d Applications
+**   CApplication.cpp: Wrapper class containing common application boilerplate
+*/
+#include "CApplication.h"
+
+CApplication::CApplication()
+{
+    appletLockExit();
+    appletSetFocusHandlingMode(AppletFocusHandlingMode_NoSuspend);
+}
+
+CApplication::~CApplication()
+{
+    appletSetFocusHandlingMode(AppletFocusHandlingMode_SuspendHomeSleep);
+    appletUnlockExit();
+}
+
+void CApplication::run()
+{
+    u64 tick_ref = armGetSystemTick();
+    u64 tick_saved = tick_ref;
+    bool focused = appletGetFocusState() == AppletFocusState_Focused;
+
+    onOperationMode(appletGetOperationMode());
+
+    for (;;)
+    {
+        u32 msg = 0;
+        Result rc = appletGetMessage(&msg);
+        if (R_SUCCEEDED(rc))
+        {
+            bool should_close = !appletProcessMessage(msg);
+            if (should_close)
+                return;
+
+            switch (msg)
+            {
+                case AppletMessage_FocusStateChanged:
+                {
+                    bool old_focused = focused;
+                    AppletFocusState state = appletGetFocusState();
+                    focused = state == AppletFocusState_Focused;
+
+                    onFocusState(state);
+                    if (focused == old_focused)
+                        break;
+                    if (focused)
+                    {
+                        appletSetFocusHandlingMode(AppletFocusHandlingMode_NoSuspend);
+                        tick_ref += armGetSystemTick() - tick_saved;
+                    }
+                    else
+                    {
+                        tick_saved = armGetSystemTick();
+                        appletSetFocusHandlingMode(AppletFocusHandlingMode_SuspendHomeSleepNotify);
+                    }
+                    break;
+                }
+                case AppletMessage_OperationModeChanged:
+                    onOperationMode(appletGetOperationMode());
+                    break;
+            }
+        }
+
+        if (focused && !onFrame(armTicksToNs(armGetSystemTick() - tick_ref)))
+            break;
+    }
+}

troposphere/daybreak/nanovg/source/framework/CExternalImage.cpp

@@ -0,0 +1,37 @@
+/*
+** Sample Framework for deko3d Applications
+**   CExternalImage.cpp: Utility class for loading images from the filesystem
+*/
+#include "CExternalImage.h"
+#include "FileLoader.h"
+
+bool CExternalImage::load(CMemPool& imagePool, CMemPool& scratchPool, dk::Device device, dk::Queue transferQueue, const char* path, uint32_t width, uint32_t height, DkImageFormat format, uint32_t flags)
+{
+    CMemPool::Handle tempimgmem = LoadFile(scratchPool, path, DK_IMAGE_LINEAR_STRIDE_ALIGNMENT);
+    if (!tempimgmem)
+        return false;
+
+    dk::UniqueCmdBuf tempcmdbuf = dk::CmdBufMaker{device}.create();
+    CMemPool::Handle tempcmdmem = scratchPool.allocate(DK_MEMBLOCK_ALIGNMENT);
+    tempcmdbuf.addMemory(tempcmdmem.getMemBlock(), tempcmdmem.getOffset(), tempcmdmem.getSize());
+
+    dk::ImageLayout layout;
+    dk::ImageLayoutMaker{device}
+        .setFlags(flags)
+        .setFormat(format)
+        .setDimensions(width, height)
+        .initialize(layout);
+
+    m_mem = imagePool.allocate(layout.getSize(), layout.getAlignment());
+    m_image.initialize(layout, m_mem.getMemBlock(), m_mem.getOffset());
+    m_descriptor.initialize(m_image);
+
+    dk::ImageView imageView{m_image};
+    tempcmdbuf.copyBufferToImage({ tempimgmem.getGpuAddr() }, imageView, { 0, 0, 0, width, height, 1 });
+    transferQueue.submitCommands(tempcmdbuf.finishList());
+    transferQueue.waitIdle();
+
+    tempcmdmem.destroy();
+    tempimgmem.destroy();
+    return true;
+}

troposphere/daybreak/nanovg/source/framework/CIntrusiveTree.cpp

@@ -0,0 +1,214 @@
+/*
+** Sample Framework for deko3d Applications
+**   CIntrusiveTree.cpp: Intrusive red-black tree helper class
+*/
+#include "CIntrusiveTree.h"
+
+// This red-black tree implementation is mostly based on mtheall's work,
+// which can be found here:
+//   https://github.com/smealum/ctrulib/tree/master/libctru/source/util/rbtree
+
+void CIntrusiveTreeBase::rotate(N* node, N::Leaf leaf)
+{
+    N *tmp    = node->child(leaf);
+    N *parent = node->getParent();
+
+    node->child(leaf) = tmp->child(!leaf);
+    if (tmp->child(!leaf))
+        tmp->child(!leaf)->setParent(node);
+
+    tmp->child(!leaf) = node;
+    tmp->setParent(parent);
+
+    if (parent)
+    {
+        if (node == parent->child(!leaf))
+            parent->child(!leaf) = tmp;
+        else
+            parent->child(leaf) = tmp;
+    }
+    else
+        m_root = tmp;
+
+    node->setParent(tmp);
+}
+
+void CIntrusiveTreeBase::recolor(N* parent, N* node)
+{
+    N *sibling;
+
+    while ((!node || node->isBlack()) && node != m_root)
+    {
+        N::Leaf leaf = node == parent->left() ? N::Right : N::Left;
+        sibling = parent->child(leaf);
+
+        if (sibling->isRed())
+        {
+            sibling->setBlack();
+            parent->setRed();
+            rotate(parent, leaf);
+            sibling = parent->child(leaf);
+        }
+
+        N::Color clr[2];
+        clr[N::Left]  = sibling->left()  ? sibling->left()->getColor()  : N::Black;
+        clr[N::Right] = sibling->right() ? sibling->right()->getColor() : N::Black;
+
+        if (clr[N::Left] == N::Black && clr[N::Right] == N::Black)
+        {
+            sibling->setRed();
+            node = parent;
+            parent = node->getParent();
+        }
+        else
+        {
+            if (clr[leaf] == N::Black)
+            {
+                sibling->child(!leaf)->setBlack();
+                sibling->setRed();
+                rotate(sibling, !leaf);
+                sibling = parent->child(leaf);
+            }
+
+            sibling->setColor(parent->getColor());
+            parent->setBlack();
+            sibling->child(leaf)->setBlack();
+            rotate(parent, leaf);
+
+            node = m_root;
+        }
+    }
+
+    if (node)
+        node->setBlack();
+}
+
+auto CIntrusiveTreeBase::walk(N* node, N::Leaf leaf) const -> N*
+{
+    if (node->child(leaf))
+    {
+        node = node->child(leaf);
+        while (node->child(!leaf))
+            node = node->child(!leaf);
+    }
+    else
+    {
+        N *parent = node->getParent();
+        while (parent && node == parent->child(leaf))
+        {
+            node = parent;
+            parent = node->getParent();
+        }
+        node = parent;
+    }
+
+    return node;
+}
+
+void CIntrusiveTreeBase::insert(N* node, N* parent)
+{
+    node->left() = node->right() = nullptr;
+    node->setParent(parent);
+    node->setRed();
+
+    while ((parent = node->getParent()) && parent->isRed())
+    {
+        N *grandparent = parent->getParent();
+        N::Leaf leaf = parent == grandparent->left() ? N::Right : N::Left;
+        N *uncle = grandparent->child(leaf);
+
+        if (uncle && uncle->isRed())
+        {
+            uncle->setBlack();
+            parent->setBlack();
+            grandparent->setRed();
+
+            node = grandparent;
+        }
+        else
+        {
+            if (parent->child(leaf) == node)
+            {
+                rotate(parent, leaf);
+
+                N* tmp = parent;
+                parent = node;
+                node = tmp;
+            }
+
+            parent->setBlack();
+            grandparent->setRed();
+            rotate(grandparent, !leaf);
+        }
+    }
+
+    m_root->setBlack();
+}
+
+void CIntrusiveTreeBase::remove(N* node)
+{
+    N::Color color;
+    N *child, *parent;
+
+    if (node->left() && node->right())
+    {
+        N *old = node;
+
+        node = node->right();
+        while (node->left())
+            node = node->left();
+
+        parent = old->getParent();
+        if (parent)
+        {
+            if (parent->left() == old)
+                parent->left() = node;
+            else
+                parent->right() = node;
+        }
+        else
+            m_root = node;
+
+        child  = node->right();
+        parent = node->getParent();
+        color  = node->getColor();
+
+        if (parent == old)
+            parent = node;
+        else
+        {
+            if (child)
+                child->setParent(parent);
+            parent->left() = child;
+
+            node->right() = old->right();
+            old->right()->setParent(node);
+        }
+
+        node->setParent(old->getParent());
+        node->setColor(old->getColor());
+        node->left() = old->left();
+        old->left()->setParent(node);
+    }
+    else
+    {
+        child  = node->left() ? node->right() : node->left();
+        parent = node->getParent();
+        color  = node->getColor();
+
+        if (child)
+            child->setParent(parent);
+        if (parent)
+        {
+            if (parent->left() == node)
+                parent->left() = child;
+            else
+                parent->right() = child;
+        }
+        else
+            m_root = child;
+    }
+
+    if (color == N::Black)
+        recolor(parent, child);
+}

troposphere/daybreak/nanovg/source/framework/CMemPool.cpp

@@ -0,0 +1,175 @@
+/*
+** Sample Framework for deko3d Applications
+**   CMemPool.cpp: Pooled dynamic memory allocation manager class
+*/
+#include "CMemPool.h"
+
+inline auto CMemPool::_newSlice() -> Slice*
+{
+    Slice* ret = m_sliceHeap.pop();
+    if (!ret) ret = (Slice*)::malloc(sizeof(Slice));
+    return ret;
+}
+
+inline void CMemPool::_deleteSlice(Slice* s)
+{
+    if (!s) return;
+    m_sliceHeap.add(s);
+}
+
+CMemPool::~CMemPool()
+{
+    m_memMap.iterate([](Slice* s) { ::free(s); });
+    m_sliceHeap.iterate([](Slice* s) { ::free(s); });
+    m_blocks.iterate([](Block* blk) {
+        blk->m_obj.destroy();
+        ::free(blk);
+    });
+}
+
+auto CMemPool::allocate(uint32_t size, uint32_t alignment) -> Handle
+{
+    if (!size) return nullptr;
+    if (alignment & (alignment - 1)) return nullptr;
+    size = (size + alignment - 1) &~ (alignment - 1);
+#ifdef DEBUG_CMEMPOOL
+    printf("Allocating size=%u alignment=0x%x\n", size, alignment);
+    {
+        Slice* temp = /*m_freeList*/m_memMap.first();
+        while (temp)
+        {
+            printf("-- blk %p | 0x%08x-0x%08x | %s used\n", temp->m_block, temp->m_start, temp->m_end, temp->m_pool ? "   " : "not");
+            temp = /*m_freeList*/m_memMap.next(temp);
+        }
+    }
+#endif
+
+    uint32_t start_offset = 0;
+    uint32_t end_offset = 0;
+    Slice* slice = m_freeList.find(size, decltype(m_freeList)::LowerBound);
+    while (slice)
+    {
+#ifdef DEBUG_CMEMPOOL
+        printf(" * Checking slice 0x%x - 0x%x\n", slice->m_start, slice->m_end);
+#endif
+        start_offset = (slice->m_start + alignment - 1) &~ (alignment - 1);
+        end_offset = start_offset + size;
+        if (end_offset <= slice->m_end)
+            break;
+        slice = m_freeList.next(slice);
+    }
+
+    if (!slice)
+    {
+        Block* blk = (Block*)::malloc(sizeof(Block));
+        if (!blk)
+            return nullptr;
+
+        uint32_t unusableSize = (m_flags & DkMemBlockFlags_Code) ? DK_SHADER_CODE_UNUSABLE_SIZE : 0;
+        uint32_t blkSize = m_blockSize - unusableSize;
+        blkSize = size > blkSize ? size : blkSize;
+        blkSize = (blkSize + unusableSize + DK_MEMBLOCK_ALIGNMENT - 1) &~ (DK_MEMBLOCK_ALIGNMENT - 1);
+#ifdef DEBUG_CMEMPOOL
+        printf(" ! Allocating block of size 0x%x\n", blkSize);
+#endif
+        blk->m_obj = dk::MemBlockMaker{m_dev, blkSize}.setFlags(m_flags).create();
+        if (!blk->m_obj)
+        {
+            ::free(blk);
+            return nullptr;
+        }
+
+        slice = _newSlice();
+        if (!slice)
+        {
+            blk->m_obj.destroy();
+            ::free(blk);
+            return nullptr;
+        }
+
+        slice->m_pool = nullptr;
+        slice->m_block = blk;
+        slice->m_start = 0;
+        slice->m_end = blkSize - unusableSize;
+        m_memMap.add(slice);
+
+        blk->m_cpuAddr = blk->m_obj.getCpuAddr();
+        blk->m_gpuAddr = blk->m_obj.getGpuAddr();
+        m_blocks.add(blk);
+
+        start_offset = 0;
+        end_offset = size;
+    }
+    else
+    {
+#ifdef DEBUG_CMEMPOOL
+        printf(" * found it\n");
+#endif
+        m_freeList.remove(slice);
+    }
+
+    if (start_offset != slice->m_start)
+    {
+        Slice* t = _newSlice();
+        if (!t) goto _bad;
+        t->m_pool = nullptr;
+        t->m_block = slice->m_block;
+        t->m_start = slice->m_start;
+        t->m_end = start_offset;
+#ifdef DEBUG_CMEMPOOL
+        printf("-> subdivide left:  %08x-%08x\n", t->m_start, t->m_end);
+#endif
+        m_memMap.addBefore(slice, t);
+        m_freeList.insert(t, true);
+        slice->m_start = start_offset;
+    }
+
+    if (end_offset != slice->m_end)
+    {
+        Slice* t = _newSlice();
+        if (!t) goto _bad;
+        t->m_pool = nullptr;
+        t->m_block = slice->m_block;
+        t->m_start = end_offset;
+        t->m_end = slice->m_end;
+#ifdef DEBUG_CMEMPOOL
+        printf("-> subdivide right: %08x-%08x\n", t->m_start, t->m_end);
+#endif
+        m_memMap.addAfter(slice, t);
+        m_freeList.insert(t, true);
+        slice->m_end = end_offset;
+    }
+
+    slice->m_pool = this;
+    return slice;
+
+_bad:
+    m_freeList.insert(slice, true);
+    return nullptr;
+}
+
+void CMemPool::_destroy(Slice* slice)
+{
+    slice->m_pool = nullptr;
+
+    Slice* left  = m_memMap.prev(slice);
+    Slice* right = m_memMap.next(slice);
+
+    if (left && left->canCoalesce(*slice))
+    {
+        slice->m_start = left->m_start;
+        m_freeList.remove(left);
+        m_memMap.remove(left);
+        _deleteSlice(left);
+    }
+
+    if (right && slice->canCoalesce(*right))
+    {
+        slice->m_end = right->m_end;
+        m_freeList.remove(right);
+        m_memMap.remove(right);
+        _deleteSlice(right);
+    }
+
+    m_freeList.insert(slice, true);
+}

troposphere/daybreak/nanovg/source/framework/CShader.cpp

@@ -0,0 +1,62 @@
+/*
+** Sample Framework for deko3d Applications
+**   CShader.cpp: Utility class for loading shaders from the filesystem
+*/
+#include "CShader.h"
+
+struct DkshHeader
+{
+    uint32_t magic; // DKSH_MAGIC
+    uint32_t header_sz; // sizeof(DkshHeader)
+    uint32_t control_sz;
+    uint32_t code_sz;
+    uint32_t programs_off;
+    uint32_t num_programs;
+};
+
+bool CShader::load(CMemPool& pool, const char* path)
+{
+    FILE* f;
+    DkshHeader hdr;
+    void* ctrlmem;
+
+    m_codemem.destroy();
+
+    f = fopen(path, "rb");
+    if (!f) return false;
+
+    if (!fread(&hdr, sizeof(hdr), 1, f))
+        goto _fail0;
+
+    ctrlmem = malloc(hdr.control_sz);
+    if (!ctrlmem)
+        goto _fail0;
+
+    rewind(f);
+    if (!fread(ctrlmem, hdr.control_sz, 1, f))
+        goto _fail1;
+
+    m_codemem = pool.allocate(hdr.code_sz, DK_SHADER_CODE_ALIGNMENT);
+    if (!m_codemem)
+        goto _fail1;
+
+    if (!fread(m_codemem.getCpuAddr(), hdr.code_sz, 1, f))
+        goto _fail2;
+
+    dk::ShaderMaker{m_codemem.getMemBlock(), m_codemem.getOffset()}
+        .setControl(ctrlmem)
+        .setProgramId(0)
+        .initialize(m_shader);
+
+    free(ctrlmem);
+    fclose(f);
+    return true;
+
+_fail2:
+    m_codemem.destroy();
+_fail1:
+    free(ctrlmem);
+_fail0:
+    fclose(f);
+    return false;
+}

troposphere/daybreak/nanovg/source/framework/FileLoader.cpp

@@ -0,0 +1,27 @@
+/*
+** Sample Framework for deko3d Applications
+**   FileLoader.cpp: Helpers for loading data from the filesystem directly into GPU memory
+*/
+#include "FileLoader.h"
+
+CMemPool::Handle LoadFile(CMemPool& pool, const char* path, uint32_t alignment)
+{
+    FILE *f = fopen(path, "rb");
+    if (!f) return nullptr;
+
+    fseek(f, 0, SEEK_END);
+    uint32_t fsize = ftell(f);
+    rewind(f);
+
+    CMemPool::Handle mem = pool.allocate(fsize, alignment);
+    if (!mem)
+    {
+        fclose(f);
+        return nullptr;
+    }
+
+    fread(mem.getCpuAddr(), fsize, 1, f);
+    fclose(f);
+
+    return mem;
+}

troposphere/daybreak/nanovg/source/framework/LICENSE

@@ -0,0 +1,18 @@
+Copyright (C) 2020 fincs
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you
+   must not claim that you wrote the original software. If you use
+   this software in a product, an acknowledgment in the product
+   documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and
+   must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source
+   distribution.