random_utils/src/ThreadSafeCanvas.cpp

Go to the documentation of this file.

    
#include "random_utils/ThreadSafeCanvas.h"

namespace random_utils
{

ThreadSafeCanvas* ThreadSafeCanvas::m_instance = 0;

ThreadSafeCanvas::ThreadSafeCanvas(const std::string& p_windowName,
                                   unsigned int p_height, 
                                   unsigned int p_width,
                                   int  p_properties)
    : VRS::GlutCanvas(p_windowName, p_height, p_width, p_properties),
      ThreadSafeObject()
{
    m_instance              = this;
    m_sleepRequested        = false;
    m_breakOut              = false;

    m_finishedRenderingCondition = SDL_CreateCond();
    m_finishedRenderingMutex = SDL_CreateMutex();
    m_wakeUpCondition = SDL_CreateCond();
    m_requestMutex = SDL_CreateMutex();
}

ThreadSafeCanvas::~ThreadSafeCanvas()
{
    SDL_DestroyCond(m_finishedRenderingCondition);
    SDL_DestroyMutex(m_finishedRenderingMutex);
    SDL_DestroyCond(m_wakeUpCondition);
    SDL_DestroyMutex(m_requestMutex);
}

void
ThreadSafeCanvas::sleep()
{
    if(SDL_LockMutex(m_requestMutex) == -1)
        std::cerr << "ERROR: cannot lock request mutex" << std::endl;

    m_sleepRequested = true;

    if(SDL_CondWait(m_finishedRenderingCondition, m_requestMutex) == -1)
        std::cerr << "ERROR: cannot wait for render condition" << std::endl;

    if(!m_breakOut)
    {
        if(SDL_UnlockMutex(m_requestMutex) == -1)
            std::cerr << "ERROR: cannot unlock request mutex" << std::endl;

        if(SDL_LockMutex(m_finishedRenderingMutex) == -1)
            std::cerr << "ERROR: cannot lock render mutex" << std::endl;
        if(SDL_UnlockMutex(m_finishedRenderingMutex) == -1)
            std::cerr << "ERROR: cannot unlock render mutex" << std::endl;
    }
}

void
ThreadSafeCanvas::finishRedisplay()
{
    VRS::GlutCanvas::finishRedisplay();

    if(SDL_LockMutex(m_requestMutex) == -1)
        std::cerr << "ERROR: cannot lock request mutex" << std::endl;

    if(m_sleepRequested)
    {
        m_sleepRequested = false;

        if(SDL_LockMutex(m_finishedRenderingMutex) == -1)
            std::cerr << "ERROR: cannot lock render mutex" << std::endl;;
        
        if(SDL_CondSignal(m_finishedRenderingCondition) == -1)
            std::cerr << "ERROR: cannot signal render condition" << std::endl;

        if(SDL_UnlockMutex(m_requestMutex) == -1)
            std::cerr << "ERROR: cannot unlock request mutex" << std::endl;;

        if(SDL_CondWait(m_wakeUpCondition, m_finishedRenderingMutex) == -1)
            std::cerr << "ERROR: cannot wait for wakeup" << std::endl;;

        if(SDL_UnlockMutex(m_finishedRenderingMutex) == -1)
            std::cerr << "ERROR: cannot unlock render mutex" << std::endl;;
    }
    else
        if(SDL_UnlockMutex(m_requestMutex) == -1)
            std::cerr << "ERROR: cannot unlock request mutex" << std::endl;
}

void
ThreadSafeCanvas::wakeUp()
{
    if(SDL_CondSignal(m_wakeUpCondition) == -1)
        std::cerr << "ERROR: cannot signal wake up" << std::endl;
}

void
ThreadSafeCanvas::breakOut()
{
    m_breakOut = true;

    if(SDL_CondSignal(m_wakeUpCondition) == -1)
        std::cerr << "ERROR: cannot signal wake up" << std::endl;
    if(SDL_CondSignal(m_finishedRenderingCondition) == -1)
        std::cerr << "ERROR: cannot signal render condition" << std::endl;    
}

}

---