Coverage Report

Created: 2025-01-23 06:31

/src/dng_sdk/source/dng_area_task.cpp
Line
Count
Source
1
/*****************************************************************************/
2
// Copyright 2006-2012 Adobe Systems Incorporated
3
// All Rights Reserved.
4
//
5
// NOTICE:  Adobe permits you to use, modify, and distribute this file in
6
// accordance with the terms of the Adobe license agreement accompanying it.
7
/*****************************************************************************/
8
9
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_area_task.cpp#1 $ */ 
10
/* $DateTime: 2012/05/30 13:28:51 $ */
11
/* $Change: 832332 $ */
12
/* $Author: tknoll $ */
13
14
/*****************************************************************************/
15
16
#include "dng_area_task.h"
17
18
#include "dng_abort_sniffer.h"
19
#include "dng_flags.h"
20
#include "dng_sdk_limits.h"
21
#include "dng_tile_iterator.h"
22
#include "dng_utils.h"
23
24
#if qImagecore
25
extern bool gPrintTimings;
26
#endif
27
28
/*****************************************************************************/
29
30
dng_area_task::dng_area_task ()
31
32
61.5k
  : fMaxThreads   (kMaxMPThreads)
33
  
34
61.5k
  , fMinTaskArea  (256 * 256)
35
  
36
61.5k
  , fUnitCell   (1, 1)
37
  
38
61.5k
  , fMaxTileSize  (256, 256)
39
  
40
61.5k
  {
41
  
42
61.5k
  }
43
44
/*****************************************************************************/
45
46
dng_area_task::~dng_area_task ()
47
61.5k
  {
48
  
49
61.5k
  }
50
51
/*****************************************************************************/
52
53
dng_rect dng_area_task::RepeatingTile1 () const
54
68.2k
  {
55
  
56
68.2k
  return dng_rect ();
57
  
58
68.2k
  }
59
    
60
/*****************************************************************************/
61
62
dng_rect dng_area_task::RepeatingTile2 () const
63
68.2k
  {
64
  
65
68.2k
  return dng_rect ();
66
  
67
68.2k
  }
68
    
69
/*****************************************************************************/
70
71
dng_rect dng_area_task::RepeatingTile3 () const
72
122k
  {
73
  
74
122k
  return dng_rect ();
75
  
76
122k
  }
77
    
78
/*****************************************************************************/
79
80
void dng_area_task::Start (uint32 /* threadCount */,
81
               const dng_point & /* tileSize */,
82
               dng_memory_allocator * /* allocator */,
83
               dng_abort_sniffer * /* sniffer */)
84
35.5k
  {
85
  
86
35.5k
  }
87
88
/*****************************************************************************/
89
90
void dng_area_task::Finish (uint32 /* threadCount */)
91
60.9k
  {
92
  
93
60.9k
  }
94
  
95
/*****************************************************************************/
96
97
dng_point dng_area_task::FindTileSize (const dng_rect &area) const
98
61.1k
  {
99
  
100
61.1k
  dng_rect repeatingTile1 = RepeatingTile1 ();
101
61.1k
  dng_rect repeatingTile2 = RepeatingTile2 ();
102
61.1k
  dng_rect repeatingTile3 = RepeatingTile3 ();
103
  
104
61.1k
  if (repeatingTile1.IsEmpty ())
105
34.1k
    {
106
34.1k
    repeatingTile1 = area;
107
34.1k
    }
108
  
109
61.1k
  if (repeatingTile2.IsEmpty ())
110
34.1k
    {
111
34.1k
    repeatingTile2 = area;
112
34.1k
    }
113
  
114
61.1k
  if (repeatingTile3.IsEmpty ())
115
61.1k
    {
116
61.1k
    repeatingTile3 = area;
117
61.1k
    }
118
    
119
61.1k
  uint32 repeatV = Min_uint32 (Min_uint32 (repeatingTile1.H (),
120
61.1k
                       repeatingTile2.H ()),
121
61.1k
                       repeatingTile3.H ());
122
  
123
61.1k
  uint32 repeatH = Min_uint32 (Min_uint32 (repeatingTile1.W (),
124
61.1k
                       repeatingTile2.W ()),
125
61.1k
                       repeatingTile3.W ());
126
  
127
61.1k
  dng_point maxTileSize = MaxTileSize ();
128
129
61.1k
  dng_point tileSize;
130
    
131
61.1k
  tileSize.v = Min_int32 (repeatV, maxTileSize.v);
132
61.1k
  tileSize.h = Min_int32 (repeatH, maxTileSize.h);
133
  
134
  // What this is doing is, if the smallest repeating image tile is larger than the 
135
  // maximum tile size, adjusting the tile size down so that the tiles are as small
136
  // as possible while still having the same number of tiles covering the
137
  // repeat area.  This makes the areas more equal in size, making MP
138
  // algorithms work better.
139
            
140
  // The image core team did not understand this code, and disabled it.
141
  // Really stupid idea to turn off code you don't understand!
142
  // I'm undoing this removal, because I think the code is correct and useful.
143
144
61.1k
  uint32 countV = (repeatV + tileSize.v - 1) / tileSize.v;
145
61.1k
  uint32 countH = (repeatH + tileSize.h - 1) / tileSize.h;
146
  
147
61.1k
  tileSize.v = (repeatV + countV - 1) / countV;
148
61.1k
  tileSize.h = (repeatH + countH - 1) / countH;
149
  
150
  // Round up to unit cell size.
151
  
152
61.1k
  dng_point unitCell = UnitCell ();
153
  
154
61.1k
  if (unitCell.h != 1 || unitCell.v != 1)
155
25.6k
    {
156
25.6k
    tileSize.v = ((tileSize.v + unitCell.v - 1) / unitCell.v) * unitCell.v;
157
25.6k
    tileSize.h = ((tileSize.h + unitCell.h - 1) / unitCell.h) * unitCell.h;
158
25.6k
    }
159
    
160
  // But if that is larger than maximum tile size, round down to unit cell size.
161
  
162
61.1k
  if (tileSize.v > maxTileSize.v)
163
201
    {
164
201
    tileSize.v = (maxTileSize.v / unitCell.v) * unitCell.v;
165
201
    }
166
167
61.1k
  if (tileSize.h > maxTileSize.h)
168
183
    {
169
183
    tileSize.h = (maxTileSize.h / unitCell.h) * unitCell.h;
170
183
    }
171
    
172
  #if qImagecore  
173
    if (gPrintTimings)
174
    {
175
        fprintf (stdout, "\nRender tile for below: %d x %d\n", (int32) tileSize.h, (int32) tileSize.v);
176
    } 
177
  #endif
178
179
61.1k
  return tileSize;
180
  
181
61.1k
  }
182
    
183
/*****************************************************************************/
184
185
void dng_area_task::ProcessOnThread (uint32 threadIndex,
186
                   const dng_rect &area,
187
                   const dng_point &tileSize,
188
                   dng_abort_sniffer *sniffer)
189
61.1k
  {
190
  
191
61.1k
  dng_rect repeatingTile1 = RepeatingTile1 ();
192
61.1k
  dng_rect repeatingTile2 = RepeatingTile2 ();
193
61.1k
  dng_rect repeatingTile3 = RepeatingTile3 ();
194
  
195
61.1k
  if (repeatingTile1.IsEmpty ())
196
34.1k
    {
197
34.1k
    repeatingTile1 = area;
198
34.1k
    }
199
  
200
61.1k
  if (repeatingTile2.IsEmpty ())
201
34.1k
    {
202
34.1k
    repeatingTile2 = area;
203
34.1k
    }
204
  
205
61.1k
  if (repeatingTile3.IsEmpty ())
206
61.1k
    {
207
61.1k
    repeatingTile3 = area;
208
61.1k
    }
209
    
210
61.1k
  dng_rect tile1;
211
  
212
61.1k
  dng_tile_iterator iter1 (repeatingTile3, area);
213
  
214
122k
  while (iter1.GetOneTile (tile1))
215
61.1k
    {
216
    
217
61.1k
    dng_rect tile2;
218
    
219
61.1k
    dng_tile_iterator iter2 (repeatingTile2, tile1);
220
    
221
122k
    while (iter2.GetOneTile (tile2))
222
61.1k
      {
223
      
224
61.1k
      dng_rect tile3;
225
      
226
61.1k
      dng_tile_iterator iter3 (repeatingTile1, tile2);
227
      
228
122k
      while (iter3.GetOneTile (tile3))
229
61.1k
        {
230
        
231
61.1k
        dng_rect tile4;
232
        
233
61.1k
        dng_tile_iterator iter4 (tileSize, tile3);
234
        
235
2.04M
        while (iter4.GetOneTile (tile4))
236
1.98M
          {
237
          
238
1.98M
          dng_abort_sniffer::SniffForAbort (sniffer);
239
          
240
1.98M
          Process (threadIndex, tile4, sniffer);
241
          
242
1.98M
          }
243
          
244
61.1k
        }
245
        
246
61.1k
      }
247
    
248
61.1k
    }
249
  
250
61.1k
  }
251
    
252
/*****************************************************************************/
253
254
void dng_area_task::Perform (dng_area_task &task,
255
                 const dng_rect &area,
256
                 dng_memory_allocator *allocator,
257
                 dng_abort_sniffer *sniffer)
258
61.1k
  {
259
  
260
61.1k
  dng_point tileSize (task.FindTileSize (area));
261
    
262
61.1k
  task.Start (1, tileSize, allocator, sniffer);
263
  
264
61.1k
  task.ProcessOnThread (0, area, tileSize, sniffer);
265
      
266
61.1k
  task.Finish (1);
267
  
268
61.1k
  }
269
270
/*****************************************************************************/