1 /*
2 delaboratory - color correction utility
3 Copyright (C) 2011 Jacek Poplawski
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include "layer_processor.h"
20 #include "main_window.h"
21 #include "main_frame_events.h"
22 #include "layer_frame_manager.h"
23 #include "layer_stack.h"
24 #include "view_manager.h"
25 #include <string>
26 #include "base_layer.h"
27 #include "channel_manager.h"
28 #include "str.h"
29 #include "progress_dialog.h"
30 #include <iostream>
31 #include "logger.h"
32 #include "renderer.h"
33 #include "image_io.h"
34 #include "layer_processor_threads.h"
35 #include "flatten_layers.h"
36 #include "gui.h"
37
deLayerProcessor(deChannelManager & _previewChannelManager,deLayerStack & _layerStack,deLayerFrameManager & _layerFrameManager,deMainWindow & _mainWindow)38 deLayerProcessor::deLayerProcessor(deChannelManager& _previewChannelManager, deLayerStack& _layerStack, deLayerFrameManager& _layerFrameManager, deMainWindow& _mainWindow)
39 :
40 layerStack(_layerStack),
41 layerFrameManager(_layerFrameManager),
42 renderer(_previewChannelManager),
43 previewChannelManager(_previewChannelManager),
44 mainWindow(_mainWindow)
45 {
46 #ifdef DEBUG_LOG
47 logInfo("layer processor constructor");
48 #endif
49 viewManager = NULL;
50
51 firstLayerToUpdate = 0;
52 lastValidLayer = -1;
53
54 layerProcessType = deLayerProcessInvalid;
55 layerProcessChannel = -1;
56
57 closing = false;
58
59 threads = new deLayerProcessorThreads(*this);
60
61 }
62
onDestroyAll()63 void deLayerProcessor::onDestroyAll()
64 {
65 lockLayerProcessor();
66
67 lastValidLayer = -1;
68
69 unlockLayerProcessor();
70 }
71
~deLayerProcessor()72 deLayerProcessor::~deLayerProcessor()
73 {
74 #ifdef DEBUG_LOG
75 logInfo("layer processor destructor");
76 #endif
77 delete threads;
78 }
79
stopWorkerThread()80 void deLayerProcessor::stopWorkerThread()
81 {
82 closing = true;
83 threads->stopWorkerThread();
84 }
85
startWorkerThread()86 void deLayerProcessor::startWorkerThread()
87 {
88 threads->startWorkerThread();
89 }
90
setViewManager(deViewManager * _viewManager)91 void deLayerProcessor::setViewManager(deViewManager* _viewManager)
92 {
93 viewManager = _viewManager;
94 }
95
repaintImageInLayerProcessor()96 void deLayerProcessor::repaintImageInLayerProcessor()
97 {
98 if (closing)
99 {
100 logInfo("skip repaintImage because closing");
101 return;
102 }
103 #ifdef DEBUG_LOG
104 logInfo("repaintImage");
105 #endif
106
107 threads->renderPost();
108 generateHistogram();
109
110 }
111
generateHistogram()112 void deLayerProcessor::generateHistogram()
113 {
114 if (closing)
115 {
116 logInfo("skip generateHistogram because closing");
117 return;
118 }
119
120 threads->histogramPost();
121 }
122
sendRepaintEvent()123 void deLayerProcessor::sendRepaintEvent()
124 {
125 if (closing)
126 {
127 return;
128 }
129
130 mainWindow.postEvent(DE_REPAINT_EVENT, 0 );
131 }
132
sendInfoEvent(int i)133 void deLayerProcessor::sendInfoEvent(int i)
134 {
135 if (closing)
136 {
137 return;
138 }
139
140 mainWindow.postEvent(DE_INFO_EVENT, i );
141 }
142
sendHistogramEvent()143 void deLayerProcessor::sendHistogramEvent()
144 {
145 if (closing)
146 {
147 return;
148 }
149
150 mainWindow.postEvent(DE_HISTOGRAM_EVENT, 0 );
151 }
152
updateAllImages(bool calcHistogram)153 void deLayerProcessor::updateAllImages(bool calcHistogram)
154 {
155 updateImages(0, -1, true);
156 }
157
lockLayers() const158 void deLayerProcessor::lockLayers() const
159 {
160 #ifdef DEBUG_LOG
161 logInfo("locking layer process mutex...");
162 #endif
163 layerProcessMutex.lock();
164 #ifdef DEBUG_LOG
165 logInfo("layer process mutex locked");
166 #endif
167 }
168
unlockLayers() const169 void deLayerProcessor::unlockLayers() const
170 {
171 #ifdef DEBUG_LOG
172 logInfo("unlocking layer process mutex");
173 #endif
174 layerProcessMutex.unlock();
175 }
176
lockHistogram()177 void deLayerProcessor::lockHistogram()
178 {
179 #ifdef DEBUG_LOG
180 logInfo("locking histogram mutex...");
181 #endif
182 histogramMutex.lock();
183 #ifdef DEBUG_LOG
184 logInfo("histogram mutex locked");
185 #endif
186 }
187
unlockHistogram()188 void deLayerProcessor::unlockHistogram()
189 {
190 #ifdef DEBUG_LOG
191 logInfo("unlocking histogram mutex");
192 #endif
193 histogramMutex.unlock();
194 }
195
lockUpdateImage()196 void deLayerProcessor::lockUpdateImage()
197 {
198 #ifdef DEBUG_LOG
199 logInfo("locking update image mutex...");
200 #endif
201 updateImageMutex.lock();
202 #ifdef DEBUG_LOG
203 logInfo("update image mutex locked");
204 #endif
205 }
206
unlockUpdateImage()207 void deLayerProcessor::unlockUpdateImage()
208 {
209 #ifdef DEBUG_LOG
210 logInfo("unlocking update image mutex");
211 #endif
212 updateImageMutex.unlock();
213 }
214
lockPrepareImage()215 void deLayerProcessor::lockPrepareImage()
216 {
217 #ifdef DEBUG_LOG
218 logInfo("locking prepare image mutex...");
219 #endif
220 prepareImageMutex.lock();
221 #ifdef DEBUG_LOG
222 logInfo("prepare image mutex locked");
223 #endif
224 }
225
unlockPrepareImage()226 void deLayerProcessor::unlockPrepareImage()
227 {
228 #ifdef DEBUG_LOG
229 logInfo("unlocking prepare image mutex");
230 #endif
231 prepareImageMutex.unlock();
232 }
233
updateImages(int a,int channel,bool action)234 void deLayerProcessor::updateImages(int a, int channel, bool action)
235 {
236 if (closing)
237 {
238 return;
239 }
240
241 lockLayers();
242
243 if (a == firstLayerToUpdate)
244 {
245 if (layerProcessChannel != channel)
246 {
247 channel = -1;
248 }
249 }
250
251 if (a < firstLayerToUpdate)
252 {
253 firstLayerToUpdate = a;
254 }
255
256 if (channel >= 0)
257 {
258 layerProcessType = deLayerProcessSingleChannel;
259 layerProcessChannel = channel;
260 }
261 else
262 {
263 if (action)
264 {
265 layerProcessType = deLayerProcessFull;
266 }
267 else
268 {
269 layerProcessType = deLayerProcessBlend;
270 }
271 }
272
273 unlockLayers();
274
275 checkUpdateImagesRequest();
276
277 }
278
updateLayerImage()279 bool deLayerProcessor::updateLayerImage()
280 {
281 #ifdef DEBUG_LOG
282 logInfo("updateLayerImage");
283 #endif
284 lockUpdateImage();
285
286 lockLayers();
287
288 bool ok = true;
289 bool result = false;
290
291 if (firstLayerToUpdate > getLastLayerToUpdate())
292 {
293 ok = false;
294 }
295
296 int i = firstLayerToUpdate;
297
298 deLayerProcessType type = deLayerProcessInvalid;
299 int channel = -1;
300
301 deBaseLayer* layer = layerStack.getLayer(i);
302
303 if ((layer) && (ok))
304 {
305 layer->lockLayer();
306
307 type = layerProcessType;
308 channel = layerProcessChannel;
309
310 layerProcessType = deLayerProcessFull;
311
312 lastValidLayer = i;
313 firstLayerToUpdate = i + 1;
314 }
315
316 unlockLayers();
317
318 if ((layer) && (ok))
319 {
320 layer->processLayer(type, channel);
321
322 layer->unlockLayer();
323
324 result = true;
325 }
326
327 unlockUpdateImage();
328
329 updateWarning();
330
331 return result;
332
333 }
334
updateWarning()335 void deLayerProcessor::updateWarning()
336 {
337 if (closing)
338 {
339 return;
340 }
341
342 mainWindow.postEvent(DE_WARNING_EVENT, 0 );
343 }
344
updateImagesSmart(deProgressDialog & progressDialog,const std::string & fileName,const std::string & type,bool saveAll,const deSize & size,deGUI & gui)345 bool deLayerProcessor::updateImagesSmart(deProgressDialog& progressDialog, const std::string& fileName, const std::string& type, bool saveAll, const deSize& size, deGUI& gui)
346 {
347 gui.lockSize();
348
349 lockLayerProcessor();
350 lockHistogram();
351 lockPrepareImage();
352 lockUpdateImage();
353
354 // remember original size of preview
355 deSize originalSize = previewChannelManager.getChannelSizeFromChannelManager();
356
357 // calculate final image in full size
358 int view = viewManager->getView();
359
360 previewChannelManager.setChannelSize(size, false);
361
362 bool result = flattenLayers(view, progressDialog, fileName, type, saveAll, layerStack, previewChannelManager);
363
364 // bring back original size of preview
365 previewChannelManager.setChannelSize(originalSize, true);
366
367 unlockUpdateImage();
368 unlockPrepareImage();
369 unlockHistogram();
370 unlockLayerProcessor();
371
372 gui.unlockSize();
373
374 return result;
375 }
376
markUpdateSingleChannel(int index,int channel)377 void deLayerProcessor::markUpdateSingleChannel(int index, int channel)
378 {
379 #ifdef DEBUG_LOG
380 logInfo("markUpdateSingleChannel " +str(index) + " " + str(channel));
381 #endif
382 updateImages(index, channel, true);
383 }
384
markUpdateAllChannels(int index)385 void deLayerProcessor::markUpdateAllChannels(int index)
386 {
387 updateImages(index, -1, true);
388 }
389
markUpdateBlendAllChannels(int index)390 void deLayerProcessor::markUpdateBlendAllChannels(int index)
391 {
392 updateImages(index, -1, false);
393 }
394
onChangeView(int a)395 void deLayerProcessor::onChangeView(int a)
396 {
397 updateImages(a + 1, -1, true);
398 updateWarning();
399 }
400
lockLayerProcessor()401 void deLayerProcessor::lockLayerProcessor()
402 {
403 #ifdef DEBUG_LOG
404 logInfo("layer processor lock...");
405 #endif
406 updateImagesMutex.lock();
407 #ifdef DEBUG_LOG
408 logInfo("layer processor locked");
409 #endif
410 }
411
unlockLayerProcessor()412 void deLayerProcessor::unlockLayerProcessor()
413 {
414 #ifdef DEBUG_LOG
415 logInfo("layer processor unlock");
416 #endif
417 updateImagesMutex.unlock();
418 }
419
tickWork()420 void deLayerProcessor::tickWork()
421 {
422 sendInfoEvent(DE_PROCESSING_START);
423
424 bool result = updateLayerImage();
425
426 if (result)
427 {
428 checkUpdateImagesRequest();
429
430 repaintImageInLayerProcessor();
431 }
432
433 sendInfoEvent(DE_PROCESSING_END);
434 }
435
onChangeViewMode()436 void deLayerProcessor::onChangeViewMode()
437 {
438 repaintImageInLayerProcessor();
439 }
440
onGUIUpdate()441 void deLayerProcessor::onGUIUpdate()
442 {
443 sendRepaintEvent();
444 }
445
removeTopLayerInLayerProcessor()446 void deLayerProcessor::removeTopLayerInLayerProcessor()
447 {
448 logInfo("removeTopLayer");
449 lockHistogram();
450 lockPrepareImage();
451 lockUpdateImage();
452
453 int index = layerStack.getSize() - 1;
454 logInfo("requested remove top layer " + str(index));
455 if (index > 0)
456 {
457 layerStack.removeTopLayer();
458 int view = viewManager->getView();
459 if (view >= layerStack.getSize())
460 {
461 viewManager->setView( layerStack.getSize() - 1 );
462 }
463 repaintImageInLayerProcessor();
464 }
465
466 unlockUpdateImage();
467 unlockPrepareImage();
468 unlockHistogram();
469 logInfo("removeTopLayer DONE");
470 }
471
removeAllLayers()472 void deLayerProcessor::removeAllLayers()
473 {
474 logInfo("removeAllLayers");
475 lockHistogram();
476 lockPrepareImage();
477 lockUpdateImage();
478
479 while (layerStack.getSize() > 0)
480 {
481 layerStack.removeTopLayer();
482 }
483
484 repaintImageInLayerProcessor();
485
486 unlockUpdateImage();
487 unlockPrepareImage();
488 unlockHistogram();
489 logInfo("removeAllLayers DONE");
490 }
491
addLayerInLayerProcessor(deBaseLayer * layer)492 void deLayerProcessor::addLayerInLayerProcessor(deBaseLayer* layer)
493 {
494 layerStack.addLayer(layer);
495
496 int n = layerStack.getSize();
497
498 markUpdateAllChannels(n-1);
499
500 }
501
checkUpdateImagesRequest()502 void deLayerProcessor::checkUpdateImagesRequest()
503 {
504 lockLayers();
505
506 bool ok = true;
507
508 if (firstLayerToUpdate > getLastLayerToUpdate())
509 {
510 ok = false;
511 }
512
513 if (ok)
514 {
515 threads->workerPost();
516 }
517
518 unlockLayers();
519 }
520
getLastLayerToUpdate()521 int deLayerProcessor::getLastLayerToUpdate()
522 {
523 if (!viewManager)
524 {
525 return 0;
526 }
527 else
528 {
529 int n = viewManager->getView();
530 return n;
531 }
532 }
533
prepareImage()534 bool deLayerProcessor::prepareImage()
535 {
536 if (previewChannelManager.isImageEmpty())
537 {
538 return false;
539 }
540
541 #ifdef DEBUG_LOG
542 logInfo("prepare image start");
543 #endif
544
545 sendInfoEvent(DE_RENDERING_START);
546
547 bool result = false;
548 lockPrepareImage();
549 lockLayerProcessor();
550
551 if (!closing)
552 {
553 if (viewManager)
554 {
555 result = renderer.prepareImage(*viewManager, *this, layerStack);
556 }
557 }
558
559 unlockLayerProcessor();
560 unlockPrepareImage();
561
562 sendInfoEvent(DE_RENDERING_END);
563 #ifdef DEBUG_LOG
564 logInfo("prepare image DONE");
565 #endif
566
567 return result;
568 }
569
onGenerateHistogram()570 void deLayerProcessor::onGenerateHistogram()
571 {
572 sendInfoEvent(DE_HISTOGRAM_START);
573
574 lockHistogram();
575
576 if (!closing)
577 {
578 mainWindow.generateHistogram();
579 }
580
581 unlockHistogram();
582
583 sendInfoEvent(DE_HISTOGRAM_END);
584 }
585
forceUpdateSize()586 void deLayerProcessor::forceUpdateSize()
587 {
588 mainWindow.forceUpdateSize();
589 }
590
setPreviewSize(const deSize & size,bool canSkip)591 void deLayerProcessor::setPreviewSize(const deSize& size, bool canSkip)
592 {
593 deSize oldSize = previewChannelManager.getChannelSizeFromChannelManager();
594 if ((oldSize == size) && (canSkip))
595 {
596 logInfo("skip set preview size");
597 return;
598 }
599
600 if (size.getW() < 0)
601 {
602 logError("broken size passed to setPreviewSize, w: " + str(size.getW()));
603 }
604
605 if (size.getH() < 0)
606 {
607 logError("broken size passed to setPreviewSize, h: " + str(size.getH()));
608 }
609
610 logInfo("setPreviewSize start");
611
612 lockHistogram();
613 lockPrepareImage();
614 lockUpdateImage();
615
616 previewChannelManager.setChannelSize(size, true);
617
618 updateAllImages(false);
619
620 unlockUpdateImage();
621 unlockPrepareImage();
622 unlockHistogram();
623 logInfo("setPreviewSize DONE");
624 }
625
onImageLoad()626 void deLayerProcessor::onImageLoad()
627 {
628 logInfo("onImageLoad");
629 lockHistogram();
630 lockPrepareImage();
631 lockUpdateImage();
632
633 updateAllImages(false);
634
635 unlockUpdateImage();
636 unlockPrepareImage();
637 unlockHistogram();
638 logInfo("onImageLoad DONE");
639 }
640
render(deCanvas & canvas)641 void deLayerProcessor::render(deCanvas& canvas)
642 {
643 renderer.render(canvas);
644 }
645
setHistogramChannel(int channel)646 void deLayerProcessor::setHistogramChannel(int channel)
647 {
648 if (viewManager)
649 {
650 viewManager->setHistogramChannel(channel);
651 }
652 }
653
getLastValidLayer() const654 int deLayerProcessor::getLastValidLayer() const
655 {
656 lockLayers();
657 int l = lastValidLayer;
658 unlockLayers();
659 return l;
660 }
661