usbloadergx/source/GUI/gui_image_async.cpp

/****************************************************************************
 * USB Loader GX
 *
 * gui_imagea_sync.cpp
 ***************************************************************************/
#include <unistd.h>
#include "gui_image_async.h"

std::vector<GuiImageAsync *> GuiImageAsync::List;
lwp_t GuiImageAsync::Thread = LWP_THREAD_NULL;
mutex_t GuiImageAsync::ListLock = LWP_THREAD_NULL;
GuiImageAsync * GuiImageAsync::InUse = NULL;
u32 GuiImageAsync::ThreadCount = 0;
bool GuiImageAsync::ThreadSleep = true;
bool GuiImageAsync::CloseThread = false;

static inline void * memdup(const void* src, size_t len)
{
    if(!src) return NULL;

    void *dst = malloc(len);
    if (dst) memcpy(dst, src, len);
    return dst;
}

static GuiImageData * StdImageLoaderCallback(void *arg)
{
    return new GuiImageData((char *) arg);
}

GuiImageAsync::GuiImageAsync(const char *Filename, GuiImageData * PreloadImg) :
    GuiImage(PreloadImg), imgData(NULL), callback(StdImageLoaderCallback), arg(strdup(Filename))
{
    ThreadInit();
    ThreadAddImage(this);
}

GuiImageAsync::GuiImageAsync(ImageLoaderCallback Callback, const void * Arg, int ArgLen, GuiImageData * PreloadImg) :
    GuiImage(PreloadImg), imgData(NULL), callback(Callback), arg(memdup(Arg, ArgLen))
{
    ThreadInit();
    ThreadAddImage(this);
}

GuiImageAsync::~GuiImageAsync()
{
    ThreadRemoveImage(this);
    ThreadExit();
    while(InUse == this) usleep(100);
    if (imgData) delete imgData;
    if (arg) free(arg);
}

void GuiImageAsync::ThreadAddImage(GuiImageAsync *Image)
{
    LWP_MutexLock(ListLock);
    List.push_back(Image);
    LWP_MutexUnlock(ListLock);
    ThreadSleep = false;
    LWP_ResumeThread(Thread);
}

void GuiImageAsync::ThreadRemoveImage(GuiImageAsync *Image)
{
    for(u32 i = 0; i < List.size(); ++i)
    {
        if(List[i] == Image)
        {
            LWP_MutexLock(ListLock);
            List.erase(List.begin()+i);
            LWP_MutexUnlock(ListLock);
            break;
        }
    }
}

void GuiImageAsync::ClearQueue()
{
    LWP_MutexLock(ListLock);
    List.clear();
    LWP_MutexUnlock(ListLock);
}

void * GuiImageAsync::GuiImageAsyncThread(void *arg)
{
    while(!CloseThread)
    {
        if(ThreadSleep)
            LWP_SuspendThread(Thread);

        while(!List.empty() && !CloseThread)
        {
            LWP_MutexLock(ListLock);
            InUse = List.front();
            List.erase(List.begin());
            LWP_MutexUnlock(ListLock);

            if (!InUse)
                continue;

            InUse->imgData = InUse->callback(InUse->arg);

            if (InUse->imgData && InUse->imgData->GetImage())
            {
                InUse->width = InUse->imgData->GetWidth();
                InUse->height = InUse->imgData->GetHeight();
                InUse->image = InUse->imgData->GetImage();
            }

            InUse = NULL;
        }

        ThreadSleep = true;
    }

    return NULL;
}

u32 GuiImageAsync::ThreadInit()
{
    if (Thread == LWP_THREAD_NULL)
    {
        LWP_MutexInit(&ListLock, false);
        LWP_CreateThread(&Thread, GuiImageAsyncThread, NULL, NULL, 32768, 80);
    }
    return ++ThreadCount;
}

u32 GuiImageAsync::ThreadExit()
{
    //! We don't need to always shutdown and startup the thread, especially
    //! since this is a nested startup/shutdown from the gui thread.
    //! It's fine with being put to suspended only.
    /*
    if (--ThreadCount == 0)
    {
        CloseThread = true;
        LWP_ResumeThread(Thread);
        LWP_JoinThread(Thread, NULL);
        LWP_MutexUnlock(ListLock);
        LWP_MutexDestroy(ListLock);
        Thread = LWP_THREAD_NULL;
        ListLock = LWP_MUTEX_NULL;
        ListLock = LWP_MUTEX_NULL;
    }
    */
    return --ThreadCount;
}