← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to intern/cycles/util/util_progress.h

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/cycles/util/util_progress.h
36
36
public:
37
37
        Progress()
38
38
        {
 
39
                tile = 0;
39
40
                sample = 0;
40
41
                start_time = time_dt();
41
42
                total_time = 0.0f;
42
 
                sample_time = 0.0f;
 
43
                tile_time = 0.0f;
43
44
                status = "Initializing";
44
45
                substatus = "";
 
46
                sync_status = "";
 
47
                sync_substatus = "";
45
48
                update_cb = NULL;
46
49
                cancel = false;
47
50
                cancel_message = "";
57
60
        {
58
61
                thread_scoped_lock lock(progress.progress_mutex);
59
62
 
60
 
                progress.get_sample(sample, total_time, sample_time);
61
63
                progress.get_status(status, substatus);
 
64
                progress.get_tile(tile, total_time, tile_time);
 
65
 
 
66
                sample = progress.get_sample();
62
67
 
63
68
                return *this;
64
69
        }
65
70
 
 
71
        void reset()
 
72
        {
 
73
                tile = 0;
 
74
                sample = 0;
 
75
                start_time = time_dt();
 
76
                total_time = 0.0f;
 
77
                tile_time = 0.0f;
 
78
                status = "Initializing";
 
79
                substatus = "";
 
80
                sync_status = "";
 
81
                sync_substatus = "";
 
82
                cancel = false;
 
83
                cancel_message = "";
 
84
        }
 
85
 
66
86
        /* cancel */
67
87
        void set_cancel(const string& cancel_message_)
68
88
        {
90
110
                cancel_cb = function;
91
111
        }
92
112
 
93
 
        /* sample and timing information */
 
113
        /* tile and timing information */
94
114
 
95
115
        void set_start_time(double start_time_)
96
116
        {
99
119
                start_time = start_time_;
100
120
        }
101
121
 
102
 
        void set_sample(int sample_, double sample_time_)
 
122
        void set_tile(int tile_, double tile_time_)
103
123
        {
104
124
                thread_scoped_lock lock(progress_mutex);
105
125
 
106
 
                sample = sample_;
 
126
                tile = tile_;
107
127
                total_time = time_dt() - start_time;
108
 
                sample_time = sample_time_;
 
128
                tile_time = tile_time_;
109
129
        }
110
130
 
111
 
        void get_sample(int& sample_, double& total_time_, double& sample_time_)
 
131
        void get_tile(int& tile_, double& total_time_, double& tile_time_)
112
132
        {
113
133
                thread_scoped_lock lock(progress_mutex);
114
134
 
115
 
                sample_ = sample;
 
135
                tile_ = tile;
116
136
                total_time_ = (total_time > 0.0)? total_time: 0.0;
117
 
                sample_time_ = sample_time;
 
137
                tile_time_ = tile_time;
 
138
        }
 
139
 
 
140
        void reset_sample()
 
141
        {
 
142
                thread_scoped_lock lock(progress_mutex);
 
143
 
 
144
                sample = 0;
 
145
        }
 
146
 
 
147
        void increment_sample()
 
148
        {
 
149
                thread_scoped_lock lock(progress_mutex);
 
150
 
 
151
                sample++;
 
152
        }
 
153
 
 
154
        int get_sample()
 
155
        {
 
156
                return sample;
118
157
        }
119
158
 
120
159
        /* status messages */
142
181
                set_update();
143
182
        }
144
183
 
 
184
        void set_sync_status(const string& status_, const string& substatus_ = "")
 
185
        {
 
186
                {
 
187
                        thread_scoped_lock lock(progress_mutex);
 
188
                        sync_status = status_;
 
189
                        sync_substatus = substatus_;
 
190
                        total_time = time_dt() - start_time;
 
191
                }
 
192
 
 
193
                set_update();
 
194
 
 
195
        }
 
196
 
 
197
        void set_sync_substatus(const string& substatus_)
 
198
        {
 
199
                {
 
200
                        thread_scoped_lock lock(progress_mutex);
 
201
                        sync_substatus = substatus_;
 
202
                        total_time = time_dt() - start_time;
 
203
                }
 
204
 
 
205
                set_update();
 
206
        }
 
207
 
145
208
        void get_status(string& status_, string& substatus_)
146
209
        {
147
210
                thread_scoped_lock lock(progress_mutex);
148
 
                status_ = status;
149
 
                substatus_ = substatus;
 
211
 
 
212
                if(sync_status != "") {
 
213
                        status_ = sync_status;
 
214
                        substatus_ = sync_substatus;
 
215
                }
 
216
                else {
 
217
                        status_ = status;
 
218
                        substatus_ = substatus;
 
219
                }
150
220
        }
151
221
 
152
222
        /* callback */
153
223
 
154
224
        void set_update()
155
225
        {
156
 
                if(update_cb)
 
226
                if(update_cb) {
 
227
                        thread_scoped_lock lock(update_mutex);
157
228
                        update_cb();
 
229
                }
158
230
        }
159
231
 
160
232
        void set_update_callback(boost::function<void(void)> function)
164
236
 
165
237
protected:
166
238
        thread_mutex progress_mutex;
 
239
        thread_mutex update_mutex;
167
240
        boost::function<void(void)> update_cb;
168
241
        boost::function<void(void)> cancel_cb;
169
242
 
170
 
        int sample;
 
243
        int tile;    /* counter for rendered tiles */
 
244
        int sample;  /* counter of rendered samples, global for all tiles */
171
245
 
172
246
        double start_time;
173
247
        double total_time;
174
 
        double sample_time;
 
248
        double tile_time;
175
249
 
176
250
        string status;
177
251
        string substatus;
178
252
 
 
253
        string sync_status;
 
254
        string sync_substatus;
 
255
 
179
256
        volatile bool cancel;
180
257
        string cancel_message;
181
258
};