← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/compositor/intern/COM_ExecutionGroup.cpp

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-02-19 11:24:23 UTC
  • mfrom: (14.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20140219112423-rkmaz2m7ha06d4tk
Tags: 2.69-3ubuntu1
* Merge with Debian; remaining changes:
  - Configure without OpenImageIO on armhf, as it is not available on
    Ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/compositor/intern/COM_ExecutionGroup.cpp
37
37
#include "COM_ViewerOperation.h"
38
38
#include "COM_ChunkOrder.h"
39
39
#include "COM_ExecutionSystemHelper.h"
 
40
#include "COM_Debug.h"
40
41
 
41
42
#include "MEM_guardedalloc.h"
42
43
#include "BLI_math.h"
248
249
        OrderOfChunks chunkorder = COM_ORDER_OF_CHUNKS_DEFAULT;
249
250
 
250
251
        if (operation->isViewerOperation()) {
251
 
                ViewerBaseOperation *viewer = (ViewerBaseOperation *)operation;
 
252
                ViewerOperation *viewer = (ViewerOperation *)operation;
252
253
                centerX = viewer->getCenterX();
253
254
                centerY = viewer->getCenterY();
254
255
                chunkorder = viewer->getChunkOrder();
288
289
 
289
290
                        delete hotspots[0];
290
291
                        MEM_freeN(chunkOrders);
 
292
                        break;
291
293
                }
292
 
                break;
293
294
                case COM_TO_RULE_OF_THIRDS:
294
295
                {
295
296
                        ChunkOrderHotspot *hotspots[9];
336
337
                        delete hotspots[7];
337
338
                        delete hotspots[8];
338
339
                        MEM_freeN(chunkOrders);
 
340
                        break;
339
341
                }
340
 
                break;
341
342
                case COM_TO_TOP_DOWN:
342
343
                default:
343
344
                        break;
344
345
        }
345
346
 
 
347
        DebugInfo::execution_group_started(this);
 
348
        DebugInfo::graphviz(graph);
 
349
 
346
350
        bool breaked = false;
347
351
        bool finished = false;
348
352
        unsigned int startIndex = 0;
383
387
                        breaked = true;
384
388
                }
385
389
        }
 
390
        DebugInfo::execution_group_finished(this);
 
391
        DebugInfo::graphviz(graph);
386
392
 
387
393
        MEM_freeN(chunkOrder);
388
394
}
518
524
        // find all chunks inside the rect
519
525
        // determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers
520
526
 
521
 
        float chunkSizef = this->m_chunkSize;
522
 
 
523
527
        int indexx, indexy;
524
 
        int minxchunk = floor((area->xmin - this->m_viewerBorder.xmin) / chunkSizef);
525
 
        int maxxchunk = ceil((area->xmax - 1) / chunkSizef);
526
 
        int minychunk = floor((area->ymin - this->m_viewerBorder.ymin) / chunkSizef);
527
 
        int maxychunk = ceil((area->ymax - 1) / chunkSizef);
528
 
        minxchunk = max(minxchunk, 0);
529
 
        minychunk = max(minychunk, 0);
530
 
        maxxchunk = min(maxxchunk, (int)this->m_numberOfXChunks);
531
 
        maxychunk = min(maxychunk, (int)this->m_numberOfYChunks);
 
528
        int minx = max_ii(area->xmin - m_viewerBorder.xmin, 0);
 
529
        int maxx = min_ii(area->xmax - m_viewerBorder.xmin, m_viewerBorder.xmax - m_viewerBorder.xmin);
 
530
        int miny = max_ii(area->ymin - m_viewerBorder.ymin, 0);
 
531
        int maxy = min_ii(area->ymax - m_viewerBorder.ymin, m_viewerBorder.ymax - m_viewerBorder.ymin);
 
532
        int minxchunk = minx / (int)m_chunkSize;
 
533
        int maxxchunk = (maxx + (int)m_chunkSize - 1) / (int)m_chunkSize;
 
534
        int minychunk = miny / (int)m_chunkSize;
 
535
        int maxychunk = (maxy + (int)m_chunkSize - 1) / (int)m_chunkSize;
 
536
        minxchunk = max_ii(minxchunk, 0);
 
537
        minychunk = max_ii(minychunk, 0);
 
538
        maxxchunk = min_ii(maxxchunk, (int)m_numberOfXChunks);
 
539
        maxychunk = min_ii(maxychunk, (int)m_numberOfYChunks);
532
540
 
533
541
        bool result = true;
534
542
        for (indexx = minxchunk; indexx < maxxchunk; indexx++) {