Fix msvc 2013 compiler errors after the ingenious cleanup in 4ca67869cc7a.
[blender.git] / source / blender / imbuf / intern / imageprocess.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/imbuf/intern/imageprocess.c
29  *  \ingroup imbuf
30  *
31  * This file was moved here from the src/ directory. It is meant to
32  * deal with endianness. It resided in a general blending lib. The
33  * other functions were only used during rendering. This single
34  * function remained. It should probably move to imbuf/intern/util.c,
35  * but we'll keep it here for the time being. (nzc)
36  *
37  */
38
39 #include <stdlib.h>
40
41 #include "MEM_guardedalloc.h"
42
43 #include "BLI_utildefines.h"
44 #include "BLI_task.h"
45 #include "BLI_math.h"
46
47 #include "IMB_imbuf_types.h"
48 #include "IMB_imbuf.h"
49 #include <math.h>
50
51 /* Only this one is used liberally here, and in imbuf */
52 void IMB_convert_rgba_to_abgr(struct ImBuf *ibuf)
53 {
54         int size;
55         unsigned char rt, *cp = (unsigned char *)ibuf->rect;
56         float rtf, *cpf = ibuf->rect_float;
57
58         if (ibuf->rect) {
59                 size = ibuf->x * ibuf->y;
60
61                 while (size-- > 0) {
62                         rt = cp[0];
63                         cp[0] = cp[3];
64                         cp[3] = rt;
65                         rt = cp[1];
66                         cp[1] = cp[2];
67                         cp[2] = rt;
68                         cp += 4;
69                 }
70         }
71
72         if (ibuf->rect_float) {
73                 size = ibuf->x * ibuf->y;
74
75                 while (size-- > 0) {
76                         rtf = cpf[0];
77                         cpf[0] = cpf[3];
78                         cpf[3] = rtf;
79                         rtf = cpf[1];
80                         cpf[1] = cpf[2];
81                         cpf[2] = rtf;
82                         cpf += 4;
83                 }
84         }
85 }
86 static void pixel_from_buffer(struct ImBuf *ibuf, unsigned char **outI, float **outF, int x, int y)
87
88 {
89         int offset = ibuf->x * y * 4 + 4 * x;
90         
91         if (ibuf->rect)
92                 *outI = (unsigned char *)ibuf->rect + offset;
93         
94         if (ibuf->rect_float)
95                 *outF = ibuf->rect_float + offset;
96 }
97
98 /* BICUBIC Interpolation */
99
100 void bicubic_interpolation_color(struct ImBuf *in, unsigned char outI[4], float outF[4], float u, float v)
101 {
102         if (outF) {
103                 BLI_bicubic_interpolation_fl(in->rect_float, outF, in->x, in->y, 4, u, v);
104         }
105         else {
106                 BLI_bicubic_interpolation_char((unsigned char *) in->rect, outI, in->x, in->y, 4, u, v);
107         }
108 }
109
110
111 void bicubic_interpolation(ImBuf *in, ImBuf *out, float u, float v, int xout, int yout)
112 {
113         unsigned char *outI = NULL;
114         float *outF = NULL;
115         
116         if (in == NULL || (in->rect == NULL && in->rect_float == NULL)) {
117                 return;
118         }
119         
120         pixel_from_buffer(out, &outI, &outF, xout, yout); /* gcc warns these could be uninitialized, but its ok */
121         
122         bicubic_interpolation_color(in, outI, outF, u, v);
123 }
124
125 /* BILINEAR INTERPOLATION */
126 void bilinear_interpolation_color(struct ImBuf *in, unsigned char outI[4], float outF[4], float u, float v)
127 {
128         if (outF) {
129                 BLI_bilinear_interpolation_fl(in->rect_float, outF, in->x, in->y, 4, u, v);
130         }
131         else {
132                 BLI_bilinear_interpolation_char((unsigned char *) in->rect, outI, in->x, in->y, 4, u, v);
133         }
134 }
135
136 /* function assumes out to be zero'ed, only does RGBA */
137 /* BILINEAR INTERPOLATION */
138
139 /* Note about wrapping, the u/v still needs to be within the image bounds,
140  * just the interpolation is wrapped.
141  * This the same as bilinear_interpolation_color except it wraps rather than using empty and emptyI */
142 void bilinear_interpolation_color_wrap(struct ImBuf *in, unsigned char outI[4], float outF[4], float u, float v)
143 {
144         float *row1, *row2, *row3, *row4, a, b;
145         unsigned char *row1I, *row2I, *row3I, *row4I;
146         float a_b, ma_b, a_mb, ma_mb;
147         int y1, y2, x1, x2;
148         
149         
150         /* ImBuf in must have a valid rect or rect_float, assume this is already checked */
151
152         x1 = (int)floor(u);
153         x2 = (int)ceil(u);
154         y1 = (int)floor(v);
155         y2 = (int)ceil(v);
156
157         /* sample area entirely outside image? */
158         if (x2 < 0 || x1 > in->x - 1 || y2 < 0 || y1 > in->y - 1) {
159                 return;
160         }
161
162         /* wrap interpolation pixels - main difference from bilinear_interpolation_color  */
163         if (x1 < 0) x1 = in->x + x1;
164         if (y1 < 0) y1 = in->y + y1;
165
166         if (x2 >= in->x) x2 = x2 - in->x;
167         if (y2 >= in->y) y2 = y2 - in->y;
168
169         if (outF) {
170                 /* sample including outside of edges of image */
171                 row1 = in->rect_float + in->x * y1 * 4 + 4 * x1;
172                 row2 = in->rect_float + in->x * y2 * 4 + 4 * x1;
173                 row3 = in->rect_float + in->x * y1 * 4 + 4 * x2;
174                 row4 = in->rect_float + in->x * y2 * 4 + 4 * x2;
175
176                 a = u - floorf(u);
177                 b = v - floorf(v);
178                 a_b = a * b; ma_b = (1.0f - a) * b; a_mb = a * (1.0f - b); ma_mb = (1.0f - a) * (1.0f - b);
179
180                 outF[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
181                 outF[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
182                 outF[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
183                 outF[3] = ma_mb * row1[3] + a_mb * row3[3] + ma_b * row2[3] + a_b * row4[3];
184         }
185         if (outI) {
186                 /* sample including outside of edges of image */
187                 row1I = (unsigned char *)in->rect + in->x * y1 * 4 + 4 * x1;
188                 row2I = (unsigned char *)in->rect + in->x * y2 * 4 + 4 * x1;
189                 row3I = (unsigned char *)in->rect + in->x * y1 * 4 + 4 * x2;
190                 row4I = (unsigned char *)in->rect + in->x * y2 * 4 + 4 * x2;
191
192                 a = u - floorf(u);
193                 b = v - floorf(v);
194                 a_b = a * b; ma_b = (1.0f - a) * b; a_mb = a * (1.0f - b); ma_mb = (1.0f - a) * (1.0f - b);
195                 
196                 /* need to add 0.5 to avoid rounding down (causes darken with the smear brush)
197                  * tested with white images and this should not wrap back to zero */
198                 outI[0] = (ma_mb * row1I[0] + a_mb * row3I[0] + ma_b * row2I[0] + a_b * row4I[0]) + 0.5f;
199                 outI[1] = (ma_mb * row1I[1] + a_mb * row3I[1] + ma_b * row2I[1] + a_b * row4I[1]) + 0.5f;
200                 outI[2] = (ma_mb * row1I[2] + a_mb * row3I[2] + ma_b * row2I[2] + a_b * row4I[2]) + 0.5f;
201                 outI[3] = (ma_mb * row1I[3] + a_mb * row3I[3] + ma_b * row2I[3] + a_b * row4I[3]) + 0.5f;
202         }
203 }
204
205 void bilinear_interpolation(ImBuf *in, ImBuf *out, float u, float v, int xout, int yout)
206 {
207         unsigned char *outI = NULL;
208         float *outF = NULL;
209         
210         if (in == NULL || (in->rect == NULL && in->rect_float == NULL)) {
211                 return;
212         }
213         
214         pixel_from_buffer(out, &outI, &outF, xout, yout); /* gcc warns these could be uninitialized, but its ok */
215         
216         bilinear_interpolation_color(in, outI, outF, u, v);
217 }
218
219 /* function assumes out to be zero'ed, only does RGBA */
220 /* NEAREST INTERPOLATION */
221 void nearest_interpolation_color(struct ImBuf *in, unsigned char outI[4], float outF[4], float u, float v)
222 {
223         const float *dataF;
224         unsigned char *dataI;
225         int y1, x1;
226
227         /* ImBuf in must have a valid rect or rect_float, assume this is already checked */
228         
229         x1 = (int)(u);
230         y1 = (int)(v);
231
232         /* sample area entirely outside image? */
233         if (x1 < 0 || x1 > in->x - 1 || y1 < 0 || y1 > in->y - 1) {
234                 if (outI)
235                         outI[0] = outI[1] = outI[2] = outI[3] = 0;
236                 if (outF)
237                         outF[0] = outF[1] = outF[2] = outF[3] = 0.0f;
238                 return;
239         }
240
241         /* sample including outside of edges of image */
242         if (x1 < 0 || y1 < 0) {
243                 if (outI) {
244                         outI[0] = 0;
245                         outI[1] = 0;
246                         outI[2] = 0;
247                         outI[3] = 0;
248                 }
249                 if (outF) {
250                         outF[0] = 0.0f;
251                         outF[1] = 0.0f;
252                         outF[2] = 0.0f;
253                         outF[3] = 0.0f;
254                 }
255         }
256         else {
257                 dataI = (unsigned char *)in->rect + in->x * y1 * 4 + 4 * x1;
258                 if (outI) {
259                         outI[0] = dataI[0];
260                         outI[1] = dataI[1];
261                         outI[2] = dataI[2];
262                         outI[3] = dataI[3];
263                 }
264                 dataF = in->rect_float + in->x * y1 * 4 + 4 * x1;
265                 if (outF) {
266                         outF[0] = dataF[0];
267                         outF[1] = dataF[1];
268                         outF[2] = dataF[2];
269                         outF[3] = dataF[3];
270                 }
271         }
272 }
273
274 void nearest_interpolation(ImBuf *in, ImBuf *out, float x, float y, int xout, int yout)
275 {
276         unsigned char *outI = NULL;
277         float *outF = NULL;
278
279         if (in == NULL || (in->rect == NULL && in->rect_float == NULL)) {
280                 return;
281         }
282         
283         pixel_from_buffer(out, &outI, &outF, xout, yout); /* gcc warns these could be uninitialized, but its ok */
284         
285         nearest_interpolation_color(in, outI, outF, x, y);
286 }
287
288 /*********************** Threaded image processing *************************/
289
290 static void processor_apply_func(TaskPool *pool, void *taskdata, int UNUSED(threadid))
291 {
292         void (*do_thread) (void *) = (void (*) (void *)) BLI_task_pool_userdata(pool);
293         do_thread(taskdata);
294 }
295
296 void IMB_processor_apply_threaded(int buffer_lines, int handle_size, void *init_customdata,
297                                   void (init_handle) (void *handle, int start_line, int tot_line,
298                                                       void *customdata),
299                                   void *(do_thread) (void *))
300 {
301         const int lines_per_task = 64;
302
303         TaskScheduler *task_scheduler = BLI_task_scheduler_get();
304         TaskPool *task_pool;
305
306         void *handles;
307         int total_tasks = (buffer_lines + lines_per_task - 1) / lines_per_task;
308         int i, start_line;
309
310         task_pool = BLI_task_pool_create(task_scheduler, do_thread);
311
312         handles = MEM_callocN(handle_size * total_tasks, "processor apply threaded handles");
313
314         start_line = 0;
315
316         for (i = 0; i < total_tasks; i++) {
317                 int lines_per_current_task;
318                 void *handle = ((char *) handles) + handle_size * i;
319
320                 if (i < total_tasks - 1)
321                         lines_per_current_task = lines_per_task;
322                 else
323                         lines_per_current_task = buffer_lines - start_line;
324
325                 init_handle(handle, start_line, lines_per_current_task, init_customdata);
326
327                 BLI_task_pool_push(task_pool, processor_apply_func, handle, false, TASK_PRIORITY_LOW);
328
329                 start_line += lines_per_task;
330         }
331
332         /* work and wait until tasks are done */
333         BLI_task_pool_work_and_wait(task_pool);
334
335         /* Free memory. */
336         MEM_freeN(handles);
337         BLI_task_pool_free(task_pool);
338 }
339
340 /* Alpha-under */
341
342 void IMB_alpha_under_color_float(float *rect_float, int x, int y, float backcol[3])
343 {
344         int a = x * y;
345         float *fp = rect_float;
346
347         while (a--) {
348                 if (fp[3] == 0.0f) {
349                         copy_v3_v3(fp, backcol);
350                 }
351                 else {
352                         float mul = 1.0f - fp[3];
353
354                         fp[0] += mul * backcol[0];
355                         fp[1] += mul * backcol[1];
356                         fp[2] += mul * backcol[2];
357                 }
358
359                 fp[3] = 1.0f;
360
361                 fp += 4;
362         }
363 }
364
365 void IMB_alpha_under_color_byte(unsigned char *rect, int x, int y, float backcol[3])
366 {
367         int a = x * y;
368         unsigned char *cp = rect;
369
370         while (a--) {
371                 if (cp[3] == 255) {
372                         /* pass */
373                 }
374                 else if (cp[3] == 0) {
375                         cp[0] = backcol[0] * 255;
376                         cp[1] = backcol[1] * 255;
377                         cp[2] = backcol[2] * 255;
378                 }
379                 else {
380                         float alpha = cp[3] / 255.0;
381                         float mul = 1.0f - alpha;
382
383                         cp[0] = (cp[0] * alpha) + mul * backcol[0];
384                         cp[1] = (cp[1] * alpha) + mul * backcol[1];
385                         cp[2] = (cp[2] * alpha) + mul * backcol[2];
386                 }
387
388                 cp[3] = 255;
389
390                 cp += 4;
391         }
392 }