usbloadergx/source/libwiigui/gui_image_async.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_imagea_sync.cpp
 *
 * GUI class definitions
 ***************************************************************************/

#include "gui.h"
//#include <string.h>
#include <unistd.h>
#include "gui_image_async.h"
static mutex_t debugLock = LWP_MUTEX_NULL;

void debug( int Line, const char* Format, ... )
{
    if ( debugLock == 0 ) LWP_MutexInit( &debugLock, false );

    LWP_MutexLock( debugLock );

    FILE *fp = fopen( "SD:/debug.txt", "a" );
    if ( fp )
    {
        char theTime[10];
        time_t rawtime = time( 0 );                                                             //this fixes code dump caused by the clock
        struct tm * timeinfo = localtime ( &rawtime );
        strftime( theTime, sizeof( theTime ), "%H:%M:%S", timeinfo );
        char format[10+strlen( Format )+strlen( theTime )];
        sprintf( format, "%s %i - %s\n", theTime, Line, Format );
        va_list va;
        va_start( va, Format );
        vfprintf( fp, format, va );
        va_end( va );
        fclose( fp );
    }
    LWP_MutexUnlock( debugLock );
}
//#define DEBUG(format, ...) debug(__LINE__, format, ##__VA_ARGS__)
#define DEBUG(format, ...)

static void *memdup( const void* src, size_t len )
{
    void *dst = malloc( len );
    if ( dst ) memcpy( dst, src, len );
    return dst;
}
static std::vector<GuiImageAsync *> List;
static u32 ThreadCount = 0;
static lwp_t Thread = LWP_THREAD_NULL;
static mutex_t ListLock = LWP_MUTEX_NULL;
static mutex_t InUseLock = LWP_MUTEX_NULL;
static GuiImageAsync *InUse = NULL;
static bool Quit = false;
static bool CanSleep = true;
void *GuiImageAsyncThread( void *arg )
{
    while ( !Quit )
    {
        LWP_MutexLock( ListLock );
        if ( List.size() )
        {
            LWP_MutexLock( InUseLock );

            InUse = List.front();
            List.erase( List.begin() );

            LWP_MutexUnlock( ListLock );

            if ( InUse )
            {
                GuiImageData *data = InUse->callback( InUse->arg );
                InUse->loadet_imgdata = data;
                if ( InUse->loadet_imgdata && InUse->loadet_imgdata->GetImage() )
                {
                    //  InUse->SetImage(InUse->loadet_imgdata); can<61>t use here. There can occur a deadlock
                    // Sets the image directly without lock. This is not fine, but it prevents a deadlock
                    InUse->image = InUse->loadet_imgdata->GetImage();
                    InUse->width = InUse->loadet_imgdata->GetWidth();
                    InUse->height = InUse->loadet_imgdata->GetHeight();
                }
            }
            InUse = NULL;
            LWP_MutexUnlock( InUseLock );
        }
        else
        {
            LWP_MutexUnlock( ListLock );
            if ( !Quit && CanSleep )
                LWP_SuspendThread( Thread );
        }
        CanSleep = true;
    }
    Quit = false;
    return NULL;
}

static u32 GuiImageAsyncThreadInit()
{
    if ( 0 == ThreadCount++ )
    {
        CanSleep = false;
        LWP_MutexInit( &ListLock, false );
        LWP_MutexInit( &InUseLock, false );
        LWP_CreateThread( &Thread, GuiImageAsyncThread, NULL, NULL, 16384, 75 );
//      while(!CanSleep)
//          usleep(20);
    }
    return ThreadCount;
}
static u32 GuiImageAsyncThreadExit()
{
    if ( --ThreadCount == 0 )
    {
        Quit = true;
        LWP_ResumeThread( Thread );
//      while(Quit)
//          usleep(20);
        LWP_JoinThread( Thread, NULL );
        LWP_MutexDestroy( ListLock );
        LWP_MutexDestroy( InUseLock );
        Thread = LWP_THREAD_NULL;
        ListLock = LWP_MUTEX_NULL;
        InUseLock = LWP_MUTEX_NULL;
    }
    return ThreadCount;
}


static void GuiImageAsyncThread_AddImage( GuiImageAsync* Image )
{
    LWP_MutexLock( ListLock );
    List.push_back( Image );
    LWP_MutexUnlock( ListLock );
    CanSleep = false;
//  if(LWP_ThreadIsSuspended(Thread))
    LWP_ResumeThread( Thread );
}
static void GuiImageAsyncThread_RemoveImage( GuiImageAsync* Image )
{
    LWP_MutexLock( ListLock );
    for ( std::vector<GuiImageAsync *>::iterator iter = List.begin(); iter != List.end(); iter++ )
    {
        if ( *iter == Image )
        {
            List.erase( iter );
            LWP_MutexUnlock( ListLock );
            return;
        }
    }
    if ( InUse == Image )
    {
        LWP_MutexLock( InUseLock );
        LWP_MutexUnlock( InUseLock );
    }
    LWP_MutexUnlock( ListLock );
}


/**
 * Constructor for the GuiImageAsync class.
 */
GuiImageData *StdImageLoaderCallback( void *arg )
{
    return new GuiImageData( ( char* )arg, NULL );
}

GuiImageAsync::GuiImageAsync( const char *Filename, GuiImageData * PreloadImg ) :
        GuiImage( PreloadImg ),
        loadet_imgdata( NULL ),
        callback( StdImageLoaderCallback ),
        arg( strdup( Filename ) )
{
    GuiImageAsyncThreadInit();
    GuiImageAsyncThread_AddImage( this );
}
GuiImageAsync::GuiImageAsync( ImageLoaderCallback Callback, void *Arg, int ArgLen, GuiImageData * PreloadImg ) :
        GuiImage( PreloadImg ),
        loadet_imgdata( NULL ),
        callback( Callback ),
        arg( memdup( Arg, ArgLen ) )
{
    DEBUG( "Constructor %p", this );
    GuiImageAsyncThreadInit();
    GuiImageAsyncThread_AddImage( this );
}
GuiImageAsync::~GuiImageAsync()
{
    GuiImageAsyncThread_RemoveImage( this );
    GuiImageAsyncThreadExit();
    DEBUG( "Deconstructor %p (loadet_imgdata=%p)", this, loadet_imgdata );
    if ( loadet_imgdata ) delete loadet_imgdata;
    if ( arg ) free( arg );
}