Changeset 130

Timestamp:

04/29/06 06:04:59 (2 years ago)

Author:

jordi

Message:

I added a new IJob child class called JobRender? which just renders pages. This class also needs a mutex because when it's rendering it could be that the document disapears (actually I think this happens only when testing), so I added a boolean variable to know when stop processing jobs, and also a way to "clear" the async queue.

Location:

trunk

Files:

• src/IDocument.cxx (modified) (15 diffs)
• src/IDocument.h (modified) (5 diffs)
• src/IJob.cxx (modified) (1 diff)
• src/IJob.h (modified) (1 diff)
• src/JobRender.cxx (added)
• src/JobRender.h (added)
• src/Makefile.am (modified) (1 diff)
• src/epdfview.h (modified) (1 diff)
• tests/PDFDocumentTest.cxx (modified) (6 diffs)
• tests/PDFDocumentTest.h (modified) (1 diff)

trunk/src/IDocument.cxx

@@ -22 +22 @@
 using namespace ePDFView;
 
-G_LOCK_DEFINE_STATIC (rendering);
-#define WAIT_REQUEST(req) while (!req->done) { }
-
 // Constants.
 static const gdouble ZOOM_IN_FACTOR = 1.2;
@@ -32 +29 @@
 static const guint CACHE_SIZE = 3;
 
-typedef struct
-{
-    guint32 age;
-    gint pageNum;
-    IDocument *document;
-    DocumentPage *page;
-    volatile gboolean done;
-} PageRequest;
-
 /// This is the error domain that will be used to report Document's errors.
 GQuark IDocument::errorQuark = 0;
+
+G_LOCK_EXTERN (JobRender);
 
 ///
@@ -128 +118 @@
 
 ///
-/// @brief Renders the requested pages.
-///
-/// This is a working thread that waits until a request to render
-/// a page is make. Then it renders the requested page and waits
-/// for another.
-/// The IDocument class is responsable to make the requests.
-///
-gpointer
-IDocument::renderPageWorker (gpointer data)
-{
-    GAsyncQueue *renderQueue = (GAsyncQueue *)data;
-    gboolean exit = FALSE;
-    do
-    {
-        PageRequest *request = (PageRequest *)g_async_queue_pop (renderQueue);
-        G_LOCK (rendering);
-        if ( -1 == request->pageNum )
-        {
-            delete request;
-            exit = TRUE;
-        }
-        else
-        {
-            if ( 0 < request->pageNum )
-            {
-                request->page = new DocumentPage ();
-          //          request->document->renderPage (request->pageNum);
-            }
-            request->done = TRUE;
-        }
-        G_UNLOCK (rendering);
-    }
-    while (!exit);
-
-    g_async_queue_unref (renderQueue);
-    renderQueue = NULL;
-    
-    return NULL;
-}
-
-///
 /// @brief Constructs a new IDocument object.
 ///
@@ -195 +144 @@
     m_Subject = NULL;
     m_Title = NULL;
-
-    if ( !g_thread_supported () )
-    {
-        g_thread_init (NULL);
-    }
-    m_RenderQueue = g_async_queue_new ();
-    g_async_queue_ref (m_RenderQueue);
-//    g_thread_create (IDocument::renderPageWorker, (gpointer)m_RenderQueue, 
-//                     FALSE, NULL);
 }
 
@@ -211 +151 @@
 IDocument::~IDocument ()
 {
-    // Create a page request with an invalid page number to let know the
-    // thread that we are done.
-    PageRequest *request = new PageRequest;
-    memset (request, 0, sizeof (PageRequest));
-    request->pageNum = -1;
-    g_async_queue_unref (m_RenderQueue);
-    g_async_queue_push (m_RenderQueue, (gpointer)request);
-
     g_list_free (m_Observers);
     delete m_Outline;
@@ -254 +186 @@
 IDocument::notifyLoad ()
 {
+    // Add the two first pages to the cache.
+    addPageToCache (1);
+    addPageToCache (2);
+
     for ( GList *item = g_list_first (m_Observers) ; NULL != item ;
           item = g_list_next (item) )
@@ -293 +229 @@
         IDocumentObserver *observer = (IDocumentObserver *)item->data;
         observer->notifyPageChanged (pageNum);
+    }
+}
+#include <stdio.h>
+void
+IDocument::notifyPageRendered (gint pageNumber, DocumentPage *pageImage)
+{
+    PageCache *cachedPage = getCachedPage (pageNumber);
+    if ( NULL != cachedPage )
+    {
+        delete cachedPage->pageImage;
+        cachedPage->pageImage = pageImage;
     }
 }
@@ -331 +278 @@
     job->setFileName (fileName);
     job->setPassword (password);
-
     IJob::queue (job);
 }
@@ -781 +727 @@
 IDocument::getCurrentPage ()
 {
-    PageRequest *request = NULL;
-    for ( GList *cache = g_list_first (m_PageCache) ;
-          NULL != cache && NULL == request ;
-          cache = g_list_next (cache) )
-    {
-        PageRequest *tmpRequest = (PageRequest *)cache->data;
-        if ( m_CurrentPage == tmpRequest->pageNum )
-        {
-            request = tmpRequest;
-        }
-    }
-
-    if ( NULL == request )
+    volatile PageCache *cachedPage = getCachedPage (m_CurrentPage);
+    if ( NULL == cachedPage )
     {
         return NULL;
     }
-    WAIT_REQUEST (request);
-    return request->page;
+
+    while ( NULL == cachedPage->pageImage )
+    {
+        ;
+    }
+
+    return cachedPage->pageImage;
 }
 
@@ -894 +834 @@
         m_CurrentPage = pageNum;
         
-        scheduleToRender (m_CurrentPage);
+        addPageToCache (m_CurrentPage);
         if ( 1 < m_CurrentPage )
         {
-            scheduleToRender (m_CurrentPage - 1);
+            addPageToCache (m_CurrentPage - 1);
         }
         if ( m_CurrentPage < getNumPages () )
         {
-            scheduleToRender (m_CurrentPage + 1);
+            addPageToCache (m_CurrentPage + 1);
         }
 
@@ -943 +883 @@
     if ( rotation != m_Rotation )
     {
+        G_LOCK (JobRender);
         m_Rotation = (rotation % 360);
         refreshCache ();
         notifyPageRotated ();
+        G_UNLOCK (JobRender);
     }
 }
@@ -1017 +959 @@
 IDocument::setZoom (gdouble zoom)
 {
-    if ( ABS (zoom - m_Scale) > 0.00001 )
-    {
+    if ( ABS (zoom - m_Scale) > 0.00001 )    
+    {
+        G_LOCK (JobRender);
         m_Scale = zoom;
         refreshCache ();
         notifyPageZoomed ();
+        G_UNLOCK (JobRender);
     }
 }
@@ -1101 +1045 @@
 
 ///
-/// @brief Adds a new page to be rendered.
+/// @brief Adds a new page to the cache and starts to render it.
 ///
 /// This function checks if a page is already on the cache. If it is, then
 /// only updates the age and returns. Otherwise adds the page to the cache and
-/// tells to the working thread to render it.
+/// creates a new job for rendering it.
 ///
 /// After adding the new page, if the cache size is larger that it should be,
 /// then this deletes the oldest request from the cache.
 ///
-/// @param pageNum The page number to render.
-///
-void
-IDocument::scheduleToRender (gint pageNum)
+/// @param pageNum The page number to add to the cache.
+///
+void
+IDocument::addPageToCache (gint pageNum)
 {
     // Check if the page is already on cache.
-    PageRequest *request = NULL;
-    for ( GList *cache = g_list_first (m_PageCache) ; 
-          NULL != cache && NULL == request ;
-          cache = g_list_next (cache) )
-    {
-        PageRequest *tmpRequest = (PageRequest *)cache->data;
-        if ( pageNum == tmpRequest->pageNum )
-        {
-            request = tmpRequest;
-        }
-    }
-
+    PageCache *cached = getCachedPage (pageNum);
     // If it's not.
-    if ( NULL == request )
+    if ( NULL == cached )
     {
         //Create it.
-        request = new PageRequest;
-        request->pageNum = pageNum;
-        request->page = new DocumentPage ();
-        request->document = this;
-        request->done = TRUE;
-        request->age = m_PageCacheAge++;
+        cached = new PageCache;
+        cached->age = m_PageCacheAge++;
+        cached->pageNumber = pageNum;
+        cached->pageImage = NULL;
+
+        JobRender *job = new JobRender ();
+        job->setDocument (this);
+        job->setPageNumber (pageNum);
+        IJob::queue (job);
         
         // Check which cached page to drop.
         if ( g_list_length (m_PageCache) >= CACHE_SIZE )
         {
-            PageRequest *oldestRequest = NULL;
+            PageCache *oldestCachedPage = NULL;
             guint32 oldestAge = G_MAXUINT32;
-            for ( GList *cache = g_list_first (m_PageCache) ; NULL != cache ;
-                  cache = g_list_next (cache) )
+            for ( GList *page = g_list_first (m_PageCache) ; NULL != page ;
+                  page = g_list_next (page) )
             {
-                PageRequest *tmpRequest = (PageRequest *)cache->data;
-                if ( tmpRequest->age < oldestAge )
+                PageCache *tmpCachedPage = (PageCache *)page->data;
+                if ( tmpCachedPage->age < oldestAge )
                 {
-                    oldestAge = tmpRequest->age;
-                    oldestRequest = tmpRequest;
+                    oldestAge = tmpCachedPage->age;
+                    oldestCachedPage = tmpCachedPage;
                 }
             }
-            m_PageCache = g_list_remove_all (m_PageCache, oldestRequest);
-            WAIT_REQUEST (oldestRequest);
-            delete oldestRequest->page;
-            oldestRequest->page = NULL;
-            delete oldestRequest;
+            G_LOCK (JobRender);
+            m_PageCache = g_list_remove_all (m_PageCache, oldestCachedPage);
+            delete oldestCachedPage->pageImage;
+            delete oldestCachedPage;
+            G_UNLOCK (JobRender);
         }
-        // Add the page to the cache and render it.
-        m_PageCache = g_list_append (m_PageCache, request);
-        g_async_queue_push (m_RenderQueue, (gpointer)request);
+        // Add the page to the cache.
+        m_PageCache = g_list_append (m_PageCache, cached);
     }
     else
     {
         // If the page is already on cache, just update the age.
-        request->age = m_PageCacheAge++;
-    }
+        cached->age = m_PageCacheAge++;
+    }
+}
+
+PageCache *
+IDocument::getCachedPage (gint pageNum)
+{
+    PageCache *cached = NULL;
+    for ( GList *page = g_list_first (m_PageCache) ; 
+          NULL != page && NULL == cached ;
+          page = g_list_next (page) )
+    {
+        PageCache *tmpCached = (PageCache *)page->data;
+        if ( pageNum == tmpCached->pageNumber )
+        {
+            cached = tmpCached;
+        }
+    }
+
+    return cached;
 }
 
@@ -1180 +1133 @@
 IDocument::refreshCache ()
 {
-    G_LOCK (rendering);
-    for ( GList *cache = g_list_first (m_PageCache) ; NULL != cache ;
-          cache = g_list_next (cache) )
-    {
-        PageRequest *request = (PageRequest *)cache->data;
-        if ( request->done )
-        {
-            delete request->page;
-            request->page = NULL;
-            request->done = FALSE;
-            g_async_queue_push (m_RenderQueue, (gpointer)request);
-        }
-    }
-    G_UNLOCK (rendering);
+    for ( GList *page = g_list_first (m_PageCache) ; 
+          NULL != page ;
+          page = g_list_next (page) )
+    {
+        PageCache *cachedPage = (PageCache *)page->data;
+        delete cachedPage->pageImage;
+        cachedPage->pageImage = NULL;
+        JobRender *job = new JobRender;
+        job->setDocument (this);
+        job->setPageNumber (cachedPage->pageNumber);
+        IJob::queue (job);
+    }
 }
 
@@ -1205 +1156 @@
 IDocument::clearCache ()
 {
-    // This will tell the working thread not to render them.
-    G_UNLOCK (rendering);
-    for ( GList *cache = g_list_first (m_PageCache) ; NULL != cache ;
-          cache = g_list_next (cache) )
-    {
-        PageRequest *request = (PageRequest *)cache->data;
-        request->pageNum = 0;
-    }
-    G_UNLOCK (rendering);
-
     // Delete all cached pages.
-    for ( GList *cache = g_list_first (m_PageCache) ; NULL != cache ;
-          cache = g_list_next (cache) )
-    {
-        PageRequest *request = (PageRequest *)cache->data;
-        WAIT_REQUEST (request);
-        delete request->page;
-        request->page = NULL;
-        delete request;
+    for ( GList *page = g_list_first (m_PageCache) ; 
+          NULL != page ;
+          page = g_list_next (page) )
+    {
+        PageCache *cachedPage = (PageCache *)page->data;
+        delete cachedPage->pageImage;
+        delete cachedPage;
     }
     g_list_free (m_PageCache);

trunk/src/IDocument.h

@@ -106 +106 @@
     } PageLayout;
 
+
+    typedef struct
+    {
+        guint32 age;
+        gint pageNumber;
+        DocumentPage *pageImage;
+    } PageCache;
+
     ///
     /// @class IDocument
@@ -181 +189 @@
             void notifyLoadPassword (const GError *error);
             void notifyPageChanged (void);
+            void notifyPageRendered (gint pageNumber, DocumentPage *pageImage);
             void notifyPageRotated (void);
             void notifyPageZoomed (void);
@@ -245 +254 @@
             static GQuark getErrorQuark (void);
             static gchar *getErrorMessage (DocumentError errorCode);
-            static gpointer renderPageWorker (gpointer data); 
 
         protected:
@@ -251 +259 @@
             
             IDocument (void);
-            void scheduleToRender (gint pageNum);
+            void addPageToCache (gint pageNum);
+            PageCache *getCachedPage (gint pageNum);
             void refreshCache (void);
 
@@ -276 +285 @@
             gchar *m_Subject;
             gchar *m_Title;
-            GAsyncQueue *m_RenderQueue;
     };
 }

trunk/src/IJob.cxx

@@ -21 +21 @@
 
 GAsyncQueue *IJob::m_JobsQueue = NULL;
+
+void
+IJob::clearQueue (void)
+{
+    IJob *job = NULL;
+    do
+    {
+        job = (IJob *)g_async_queue_try_pop (m_JobsQueue);
+    }
+    while ( NULL != job );
+}
 
 gpointer

trunk/src/IJob.h

@@ -36 +36 @@
             virtual ~IJob (void) { }
 
+            static void clearQueue (void);
             static gpointer dispatcher (gpointer data); 
             static void init (void);

trunk/src/Makefile.am

@@ -20 +20 @@
     JobLoad.cxx         \
     JobLoad.h           \
+    JobRender.cxx   \
+    JobRender.h \
     MainPter.cxx        \
     MainPter.h          \

trunk/src/epdfview.h

@@ -35 +35 @@
 #include <IJob.h>
 #include <JobLoad.h>
+#include <JobRender.h>
 
 #endif //!__E_PDF_VIEW_H__

trunk/tests/PDFDocumentTest.cxx

@@ -24 +24 @@
 static const double DELTA = 0.0001;
 
+// Lock for rendering pages.
+G_LOCK_EXTERN (JobRender);
+
 // Register the test suite into the `registry'.
 CPPUNIT_TEST_SUITE_REGISTRATION (PDFDocumentTest);
@@ -36 +39 @@
     m_Observer = new DumbDocumentObserver ();
     m_Document->attach (m_Observer);
+    G_LOCK (JobRender);
+    JobRender::m_CanProcessJobs = TRUE;
+    G_UNLOCK (JobRender);
 }
 
@@ -44 +50 @@
 PDFDocumentTest::tearDown ()
 {
+    G_LOCK (JobRender);
+    JobRender::m_CanProcessJobs = FALSE;
+    IJob::clearQueue ();
+    G_UNLOCK (JobRender);
     m_Document->deattach (m_Observer);
     delete m_Observer;
@@ -541 +551 @@
     g_free (testFile);
 }
-/*
+
 ///
 /// @brief Test rendering a page.
@@ -573 +583 @@
     CPPUNIT_ASSERT_DOUBLES_EQUAL (0.3562f, m_Document->getZoom (), DELTA);
     DocumentPage *page = m_Document->getCurrentPage ();
+    CPPUNIT_ASSERT (NULL != page);
     CPPUNIT_ASSERT_EQUAL (300, page->getWidth ());
     CPPUNIT_ASSERT_EQUAL (212, page->getHeight ());
@@ -587 +598 @@
     g_free (testFile);
 }
-*/

trunk/tests/PDFDocumentTest.h

@@ -35 +35 @@
         CPPUNIT_TEST (pageRotate);
         CPPUNIT_TEST (pageZoom);
-//        CPPUNIT_TEST (pageRender);
+        CPPUNIT_TEST (pageRender);
         CPPUNIT_TEST_SUITE_END ();