CRenderThread Class Reference

#include <RenderThread.h>

Collaboration diagram for CRenderThread:

[legend]

List of all members.

Public Member Functions
	CRenderThread (void)
	~CRenderThread (void)
void	start (ThreadParam *param)
void	stop ()
void	clearTodoList ()
void	addTodoItem (TodoItem *item, GBool bHead=gTrue)
void	signal ()
void	renderPageNow (TodoItem *item)
GBool	isInRendering (TodoItem *item)
Private Types
enum	threadState { Initialized = 0, Rendering = 1, RenderFinished = 2, ToAbort = 3 }
Private Member Functions
void	initialize ()
void	destroy ()
void	adjustPageList (const int center)
Static Private Member Functions
static void *	threadProc (void *)
static GBool	abortCheckFunc (void *data)
Private Attributes
pthread_t	thread
pthread_cond_t	cond
pthread_mutex_t	mutex
pthread_mutex_t	abort
GBool	bRunning
CPageInfo *	renderingPage
ThreadParam *	param
Static Private Attributes
static threadState	abortState = Initialized

---

Detailed Description

Definition at line 40 of file RenderThread.h.

---

Member Enumeration Documentation

enum CRenderThread::threadState [private]

Enumerator:

Initialized
Rendering
RenderFinished
ToAbort

Definition at line 43 of file RenderThread.h.

    {
        Initialized     = 0, 
        Rendering       = 1, 
        RenderFinished  = 2,
        ToAbort         = 3,
    };

---

Constructor & Destructor Documentation

CRenderThread::CRenderThread

(

void

)

Definition at line 28 of file RenderThread.cpp.

: bRunning(gFalse)
{
    initialize();
}

Here is the call graph for this function:

CRenderThread::~CRenderThread

(

void

)

Definition at line 34 of file RenderThread.cpp.

{
    destroy();
}

Here is the call graph for this function:

---

Member Function Documentation

void CRenderThread::initialize

(

)

[private]

Definition at line 41 of file RenderThread.cpp.

{
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&abort, NULL);
    renderingPage = NULL;
}

void CRenderThread::destroy

(

)

[private]

Definition at line 49 of file RenderThread.cpp.

{
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&abort);
}

void CRenderThread::adjustPageList

(

const int

center

)

[private]

Definition at line 129 of file RenderThread.cpp.

{
    // memory       allocate         pages
    // 50MB  ------- 20 MB   ------   35 
    // 30MB  ------- 30 MB   ------    8 ( 250%)
    static const int MEM = 1024 * 1024 * 15;    // 49.1 MB used from experiment, ~ 35 pages cached

    {
        char * p = (char *)malloc(MEM);
        if (p)
        {
            // PV_MEM("Memory is enough %d bytes!", MEM);
            free(p);
            return;
        }
        else 
        {
            // PV_MEM("Not enough memory, try to release some pages!");
            for(int i = 0; i < RemovePages; ++i)
            {
                param->pageList->removeOldestOne(current);
            }                
        }
    }
}

Here is the call graph for this function:

void * CRenderThread::threadProc

(

void *

pvoid

)

[static, private]

Definition at line 225 of file RenderThread.cpp.

{
    // install 
    installThreadTermHandler();


    // param
    ThreadParam * param = (ThreadParam *)pvoid;

    // loop
    for(;;)
    {
        if (param->bQuit)
        {
            PV_LOGPRINTF("Quit from thread!");
            return NULL;
        }
        
        // check todo list
        TodoItem *pItem = param->todoList->popItem();
        if (NULL == pItem) 
        {
            pthread_mutex_lock(&param->thread->mutex);
            PV_LOGPRINTF("Waiting...");
            pthread_cond_wait(&param->thread->cond, &param->thread->mutex); 
            pthread_mutex_unlock(&param->thread->mutex);
            continue;   // quit or do something 
        }
    
        // check page list 
        CPageInfo * page = param->pageList->checkPage(pItem);
        if (page) 
        {
            delete pItem;
            continue;
        }
        
        // memory control
        param->thread->adjustPageList(param->ctrl->settings.getCurrentPage());
                    
        // construct a new page item
        page = new CPageInfo;
        page->pageNumber = pItem->pageNumber;
        page->pageZoom   = pItem->zoom;
        page->rotate     = pItem->rotate;   // global settings
        page->timestamp  = pItem->timeStamp;
        delete pItem;
        
        // protect, renderingPage could be accessed by main thread and helper thread in same time
        pthread_mutex_lock(&param->thread->abort);
        param->thread->renderingPage = page;
        param->thread->abortState = Rendering;
        pthread_mutex_unlock(&param->thread->abort);
        
        // go
        RenderRet ret = param->ctrl->core->renderPage(*page, 
                gFalse, gTrue, gTrue, abortCheckFunc, NULL);
    
        // reset                
        pthread_mutex_lock(&param->thread->abort);
        param->thread->renderingPage = NULL;
        param->thread->abortState = RenderFinished;
        pthread_mutex_unlock(&param->thread->abort);                                        

        // check result
        if (ret != Render_Done)
        {
            if (ret == Render_Abort)
            {
                PV_LOGPRINTF("Page %d is aborted!", page->pageNumber);
            }
            delete page;
            continue;
        }
        // to protect page, use request time stamp
        // page->timestamp = param->ctrl->getTimeStamp();
        param->pageList->addPage(page);

        // send a message to the main window
        postEvent(param, page);
    }
    return NULL;
}

Here is the call graph for this function:

GBool CRenderThread::abortCheckFunc

(

void *

data

)

[static, private]

Definition at line 56 of file RenderThread.cpp.

{
    if (abortState == ToAbort)
    {
        // PV_LOGPRINTF("Abort page!");
        return gTrue;
    }
    return gFalse;
    
}

void CRenderThread::start

(

ThreadParam *

param

)

Definition at line 77 of file RenderThread.cpp.

{
    if (bRunning) 
    {
        PV_ERRORPRINTF("Thread already running!");
        return;
    }
    param = p;
    param->bQuit = gFalse;
    param->thread = this;
    renderingPage = NULL;
    abortState = Initialized;
    if (pthread_create(&thread, NULL, threadProc, p) != 0)
    {
        PV_ERRORPRINTF("Could not create thread!");
        return;
    }
    PV_LOGPRINTF("Create render thread done!");
    bRunning = gTrue;
}

Here is the call graph for this function:

void CRenderThread::stop

(

)

Definition at line 98 of file RenderThread.cpp.

{
    if (!bRunning) return;

    abortState = Initialized;
    param->bQuit = gTrue;
    pthread_mutex_lock(&mutex);
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
    pthread_join(thread, NULL);
    bRunning = gFalse;
    renderingPage = NULL;
}

void CRenderThread::clearTodoList

(

)

Definition at line 112 of file RenderThread.cpp.

{
    param->todoList->clear();
}

Here is the call graph for this function:

void CRenderThread::addTodoItem	(	TodoItem *	item,
		GBool	bHead = gTrue
	)

Definition at line 117 of file RenderThread.cpp.

{
    param->todoList->pushItem(item, bHead);
}

Here is the call graph for this function:

void CRenderThread::signal

(

)

Definition at line 122 of file RenderThread.cpp.

{
    pthread_mutex_lock(&mutex);
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
}

void CRenderThread::renderPageNow

(

TodoItem *

item

)

Definition at line 155 of file RenderThread.cpp.

{
    // if it's already rendering ignore the request
    pthread_mutex_lock(&abort);
    if (abortState == Rendering && 
        renderingPage &&
        renderingPage->isSame(item->pageNumber, item->zoom, item->rotate))
    {
        PV_LOGPRINTF("Page %d is in rendering!", item->pageNumber);
        delete item;
        pthread_mutex_unlock(&abort);
        return;
    }        

    if (abortState == Rendering)
    {
        abortState = ToAbort;
    }
    param->todoList->pushItem(item, gTrue);
    signal();
    pthread_mutex_unlock(&abort);
}

Here is the call graph for this function:

GBool CRenderThread::isInRendering

(

TodoItem *

item

)

Definition at line 178 of file RenderThread.cpp.

{
    pthread_mutex_lock(&abort);
    if (abortState == Rendering && 
        renderingPage &&
        renderingPage->isSame(item->pageNumber, item->zoom, item->rotate))
    {
        pthread_mutex_unlock(&abort);
        return gTrue;
    }        
    pthread_mutex_unlock(&abort);
    return gFalse;
}

Here is the call graph for this function:

---

Member Data Documentation

pthread_t CRenderThread::thread [private]

Definition at line 51 of file RenderThread.h.

pthread_cond_t CRenderThread::cond [private]

Definition at line 52 of file RenderThread.h.

pthread_mutex_t CRenderThread::mutex [private]

Definition at line 53 of file RenderThread.h.

pthread_mutex_t CRenderThread::abort [private]

Definition at line 54 of file RenderThread.h.

GBool CRenderThread::bRunning [private]

Definition at line 55 of file RenderThread.h.

CPageInfo* CRenderThread::renderingPage [private]

Definition at line 56 of file RenderThread.h.

ThreadParam* CRenderThread::param [private]

Definition at line 57 of file RenderThread.h.

CRenderThread::threadState CRenderThread::abortState = Initialized [static, private]

Definition at line 64 of file RenderThread.h.

---

The documentation for this class was generated from the following files:

• ipdf-svn/inc/RenderThread.h
• ipdf-svn/src/RenderThread.cpp