1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
|
/* ============================================================
*
* This file is a part of digiKam project
* http://www.digikam.org
*
* Date : 2005-12-17
* Description : image file IO threaded interface.
*
* Copyright (C) 2005-2007 by Marcel Wiesweg <marcel.wiesweg@gmx.de>
* Copyright (C) 2005-2007 by Gilles Caulier <caulier dot gilles at gmail dot com>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#include "loadsavetask.h"
// Qt includes.
#include <qapplication.h>
// Local includes.
#include "ddebug.h"
#include "loadsavethread.h"
#include "managedloadsavethread.h"
#include "sharedloadsavethread.h"
#include "loadingcache.h"
namespace Digikam
{
void LoadingProgressEvent::notify(LoadSaveThread *thread)
{
thread->loadingProgress(m_loadingDescription, m_progress);
}
void SavingProgressEvent::notify(LoadSaveThread *thread)
{
thread->savingProgress(m_filePath, m_progress);
}
void StartedLoadingEvent::notify(LoadSaveThread *thread)
{
thread->imageStartedLoading(m_loadingDescription);
}
void StartedSavingEvent::notify(LoadSaveThread *thread)
{
thread->imageStartedSaving(m_filePath);
}
void LoadedEvent::notify(LoadSaveThread *thread)
{
thread->imageLoaded(m_loadingDescription, m_img);
}
void MoreCompleteLoadingAvailableEvent::notify(LoadSaveThread *thread)
{
thread->moreCompleteLoadingAvailable(m_oldDescription, m_newDescription);
}
void SavedEvent::notify(LoadSaveThread *thread)
{
thread->imageSaved(m_filePath, m_success);
}
//---------------------------------------------------------------------------------------------------
void LoadingTask::execute()
{
if (m_loadingTaskStatus == LoadingTaskStatusStopping)
return;
DImg img(m_loadingDescription.filePath, this, m_loadingDescription.rawDecodingSettings);
m_thread->taskHasFinished();
QApplication::postEvent(m_thread, new LoadedEvent(m_loadingDescription.filePath, img));
}
LoadingTask::TaskType LoadingTask::type()
{
return TaskTypeLoading;
}
void LoadingTask::progressInfo(const DImg *, float progress)
{
if (m_loadingTaskStatus == LoadingTaskStatusLoading)
{
if (m_thread->querySendNotifyEvent())
QApplication::postEvent(m_thread, new LoadingProgressEvent(m_loadingDescription.filePath, progress));
}
}
bool LoadingTask::continueQuery(const DImg *)
{
return m_loadingTaskStatus != LoadingTaskStatusStopping;
}
void LoadingTask::setStatus(LoadingTaskStatus status)
{
m_loadingTaskStatus = status;
}
// This is a hack needed to prevent hanging when a KProcess-based loader (raw loader)
// is waiting for the process to finish, but the main thread is waiting
// for the thread to finish and no KProcess events are delivered.
// Remove when porting to Qt4.
bool LoadingTask::isShuttingDown()
{
return m_thread->isShuttingDown();
}
//---------------------------------------------------------------------------------------------------
void SharedLoadingTask::execute()
{
if (m_loadingTaskStatus == LoadingTaskStatusStopping)
return;
// send StartedLoadingEvent from each single Task, not via LoadingProcess list
QApplication::postEvent(m_thread, new StartedLoadingEvent(m_loadingDescription.filePath));
LoadingCache *cache = LoadingCache::cache();
{
LoadingCache::CacheLock lock(cache);
// find possible cached images
DImg *cachedImg = 0;
QStringList lookupKeys = m_loadingDescription.lookupCacheKeys();
for ( QStringList::Iterator it = lookupKeys.begin(); it != lookupKeys.end(); ++it ) {
if ( (cachedImg = cache->retrieveImage(*it)) )
break;
}
if (cachedImg)
{
// image is found in image cache, loading is successful
DImg img(*cachedImg);
if (accessMode() == LoadSaveThread::AccessModeReadWrite)
img = img.copy();
QApplication::postEvent(m_thread, new LoadedEvent(m_loadingDescription.filePath, img));
return;
}
else
{
// find possible running loading process
m_usedProcess = 0;
for ( QStringList::Iterator it = lookupKeys.begin(); it != lookupKeys.end(); ++it ) {
if ( (m_usedProcess = cache->retrieveLoadingProcess(*it)) )
{
break;
}
}
if (m_usedProcess)
{
// Other process is right now loading this image.
// Add this task to the list of listeners and
// attach this thread to the other thread, wait until loading
// has finished.
m_usedProcess->addListener(this);
// break loop when either the loading has completed, or this task is being stopped
while ( !m_usedProcess->completed() && m_loadingTaskStatus != LoadingTaskStatusStopping )
lock.timedWait();
// remove listener from process
m_usedProcess->removeListener(this);
// wake up the process which is waiting until all listeners have removed themselves
lock.wakeAll();
// set to 0, as checked in setStatus
m_usedProcess = 0;
//DDebug() << "SharedLoadingTask " << this << ": waited" << endl;
return;
}
else
{
// Neither in cache, nor currently loading in different thread.
// Load it here and now, add this LoadingProcess to cache list.
cache->addLoadingProcess(this);
// Add this to the list of listeners
addListener(this);
// for use in setStatus
m_usedProcess = this;
// Notify other processes that we are now loading this image.
// They might be interested - see notifyNewLoadingProcess below
cache->notifyNewLoadingProcess(this, m_loadingDescription);
}
}
}
// load image
DImg img(m_loadingDescription.filePath, this, m_loadingDescription.rawDecodingSettings);
bool isCached = false;
{
LoadingCache::CacheLock lock(cache);
// put (valid) image into cache of loaded images
if (!img.isNull())
isCached = cache->putImage(m_loadingDescription.cacheKey(), new DImg(img), m_loadingDescription.filePath);
// remove this from the list of loading processes in cache
cache->removeLoadingProcess(this);
}
// following the golden rule to avoid deadlocks, do this when CacheLock is not held
m_thread->taskHasFinished();
{
LoadingCache::CacheLock lock(cache);
//DDebug() << "SharedLoadingTask " << this << ": image loaded, " << img.isNull() << endl;
// indicate that loading has finished so that listeners can stop waiting
m_completed = true;
// Optimize so that no unnecessary copying is done.
// If image has been put in cache, the initial copy has been consumed for this.
// If image is too large for cache, the initial copy is still available.
bool usedInitialCopy = isCached;
// dispatch image to all listeners, including this
for (LoadingProcessListener *l = m_listeners.first(); l; l = m_listeners.next())
{
// This code sends a copy only when ReadWrite access is requested.
// Otherwise, the image from the cache is sent.
// As the image in the cache will be deleted from any thread, the explicit sharing
// needs to be thread-safe to avoid the risk of memory leaks.
// This is the case only for Qt4, so uncomment this code when porting.
/*
if (l->accessMode() == LoadSaveThread::AccessModeReadWrite)
{
// If a listener requested ReadWrite access, it gets a deep copy.
// DImg is explicitly shared.
DImg copy = img.copy();
QApplication::postEvent(l->eventReceiver(), new LoadedEvent(m_loadingDescription.filePath, copy));
}
else
QApplication::postEvent(l->eventReceiver(), new LoadedEvent(m_loadingDescription.filePath, img));
*/
// Qt3: The same copy for all Read listeners (it is assumed that they will delete it only in the main thread),
// an extra copy for each ReadWrite listener
DImg readerCopy;
if (l->accessMode() == LoadSaveThread::AccessModeReadWrite)
{
// If a listener requested ReadWrite access, it gets a deep copy.
// DImg is explicitly shared.
DImg copy;
if (usedInitialCopy)
{
copy = img.copy();
}
else
{
copy = img;
usedInitialCopy = true;
}
QApplication::postEvent(l->eventReceiver(), new LoadedEvent(m_loadingDescription, copy));
}
else
{
if (readerCopy.isNull())
{
if (usedInitialCopy)
{
readerCopy = img.copy();
}
else
{
readerCopy = img;
usedInitialCopy = true;
}
}
QApplication::postEvent(l->eventReceiver(), new LoadedEvent(m_loadingDescription, readerCopy));
}
}
// remove myself from list of listeners
removeListener(this);
// wake all listeners waiting on cache condVar, so that they remove themselves
lock.wakeAll();
// wait until all listeners have removed themselves
while (m_listeners.count() != 0)
lock.timedWait();
// set to 0, as checked in setStatus
m_usedProcess = 0;
}
}
void SharedLoadingTask::progressInfo(const DImg *, float progress)
{
if (m_loadingTaskStatus == LoadingTaskStatusLoading)
{
LoadingCache *cache = LoadingCache::cache();
LoadingCache::CacheLock lock(cache);
for (LoadingProcessListener *l = m_listeners.first(); l; l = m_listeners.next())
{
if (l->querySendNotifyEvent())
QApplication::postEvent(l->eventReceiver(), new LoadingProgressEvent(m_loadingDescription, progress));
}
}
}
bool SharedLoadingTask::continueQuery(const DImg *)
{
// If this is called, the thread is currently loading an image.
// In shared loading, we cannot stop until all listeners have been removed as well
return (m_loadingTaskStatus != LoadingTaskStatusStopping) || (m_listeners.count() != 0);
}
void SharedLoadingTask::setStatus(LoadingTaskStatus status)
{
m_loadingTaskStatus = status;
if (m_loadingTaskStatus == LoadingTaskStatusStopping)
{
LoadingCache *cache = LoadingCache::cache();
LoadingCache::CacheLock lock(cache);
// check for m_usedProcess, to avoid race condition that it has finished before
if (m_usedProcess)
{
// remove this from list of listeners - check in continueQuery() of active thread
m_usedProcess->removeListener(this);
// wake all listeners - particularly this - from waiting on cache condvar
lock.wakeAll();
}
}
}
bool SharedLoadingTask::completed()
{
return m_completed;
}
QString SharedLoadingTask::filePath()
{
return m_loadingDescription.filePath;
}
QString SharedLoadingTask::cacheKey()
{
return m_loadingDescription.cacheKey();
}
void SharedLoadingTask::addListener(LoadingProcessListener *listener)
{
m_listeners.append(listener);
}
void SharedLoadingTask::removeListener(LoadingProcessListener *listener)
{
m_listeners.remove(listener);
}
void SharedLoadingTask::notifyNewLoadingProcess(LoadingProcess *process, LoadingDescription description)
{
// Ok, we are notified that another task has been started in another thread.
// We are of course only interested if the task loads the same file,
// and we are right now loading a reduced version, and the other task is loading the full version.
// In this case, we notify our own thread (a signal to the API user is emitted) of this.
// The fact that we are receiving the method call shows that this task is registered with the LoadingCache,
// somewhere in between the calls to addLoadingProcess(this) and removeLoadingProcess(this) above.
if (process != this &&
m_loadingDescription.isReducedVersion() &&
m_loadingDescription.equalsIgnoreReducedVersion(description) &&
!description.isReducedVersion()
)
{
for (LoadingProcessListener *l = m_listeners.first(); l; l = m_listeners.next())
{
QApplication::postEvent(l->eventReceiver(), new MoreCompleteLoadingAvailableEvent(m_loadingDescription, description));
}
}
}
bool SharedLoadingTask::querySendNotifyEvent()
{
return m_thread->querySendNotifyEvent();
}
QObject *SharedLoadingTask::eventReceiver()
{
return m_thread;
}
LoadSaveThread::AccessMode SharedLoadingTask::accessMode()
{
return m_accessMode;
}
//---------------------------------------------------------------------------------------------------
void SavingTask::execute()
{
bool success = m_img.save(m_filePath, m_format, this);
m_thread->taskHasFinished();
QApplication::postEvent(m_thread, new SavedEvent(m_filePath, success));
};
LoadingTask::TaskType SavingTask::type()
{
return TaskTypeSaving;
}
void SavingTask::progressInfo(const DImg *, float progress)
{
if (m_thread->querySendNotifyEvent())
QApplication::postEvent(m_thread, new SavingProgressEvent(m_filePath, progress));
}
bool SavingTask::continueQuery(const DImg *)
{
return m_savingTaskStatus != SavingTaskStatusStopping;
}
void SavingTask::setStatus(SavingTaskStatus status)
{
m_savingTaskStatus = status;
}
} //namespace Digikam
|