14b2ded73e0a54c7d0b7d4e1374dd5f775a2ed2b
[blender.git] / source / blender / imbuf / intern / scaling.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  * allocimbuf.c
19  */
20
21 /** \file
22  * \ingroup imbuf
23  */
24
25 #include "BLI_utildefines.h"
26 #include "BLI_math_color.h"
27 #include "BLI_math_interp.h"
28 #include "MEM_guardedalloc.h"
29
30 #include "imbuf.h"
31 #include "IMB_imbuf_types.h"
32 #include "IMB_imbuf.h"
33
34 #include "IMB_filter.h"
35
36 #include "BLI_sys_types.h"  // for intptr_t support
37
38 static void imb_half_x_no_alloc(struct ImBuf *ibuf2, struct ImBuf *ibuf1)
39 {
40   uchar *p1, *_p1, *dest;
41   short a, r, g, b;
42   int x, y;
43   float af, rf, gf, bf, *p1f, *_p1f, *destf;
44   bool do_rect, do_float;
45
46   do_rect = (ibuf1->rect != NULL);
47   do_float = (ibuf1->rect_float != NULL && ibuf2->rect_float != NULL);
48
49   _p1 = (uchar *)ibuf1->rect;
50   dest = (uchar *)ibuf2->rect;
51
52   _p1f = ibuf1->rect_float;
53   destf = ibuf2->rect_float;
54
55   for (y = ibuf2->y; y > 0; y--) {
56     p1 = _p1;
57     p1f = _p1f;
58     for (x = ibuf2->x; x > 0; x--) {
59       if (do_rect) {
60         a = *(p1++);
61         b = *(p1++);
62         g = *(p1++);
63         r = *(p1++);
64         a += *(p1++);
65         b += *(p1++);
66         g += *(p1++);
67         r += *(p1++);
68         *(dest++) = a >> 1;
69         *(dest++) = b >> 1;
70         *(dest++) = g >> 1;
71         *(dest++) = r >> 1;
72       }
73       if (do_float) {
74         af = *(p1f++);
75         bf = *(p1f++);
76         gf = *(p1f++);
77         rf = *(p1f++);
78         af += *(p1f++);
79         bf += *(p1f++);
80         gf += *(p1f++);
81         rf += *(p1f++);
82         *(destf++) = 0.5f * af;
83         *(destf++) = 0.5f * bf;
84         *(destf++) = 0.5f * gf;
85         *(destf++) = 0.5f * rf;
86       }
87     }
88     if (do_rect)
89       _p1 += (ibuf1->x << 2);
90     if (do_float)
91       _p1f += (ibuf1->x << 2);
92   }
93 }
94
95 struct ImBuf *IMB_half_x(struct ImBuf *ibuf1)
96 {
97   struct ImBuf *ibuf2;
98
99   if (ibuf1 == NULL)
100     return (NULL);
101   if (ibuf1->rect == NULL && ibuf1->rect_float == NULL)
102     return (NULL);
103
104   if (ibuf1->x <= 1)
105     return (IMB_dupImBuf(ibuf1));
106
107   ibuf2 = IMB_allocImBuf((ibuf1->x) / 2, ibuf1->y, ibuf1->planes, ibuf1->flags);
108   if (ibuf2 == NULL)
109     return (NULL);
110
111   imb_half_x_no_alloc(ibuf2, ibuf1);
112
113   return (ibuf2);
114 }
115
116 struct ImBuf *IMB_double_fast_x(struct ImBuf *ibuf1)
117 {
118   struct ImBuf *ibuf2;
119   int *p1, *dest, i, col, do_rect, do_float;
120   float *p1f, *destf;
121
122   if (ibuf1 == NULL)
123     return (NULL);
124   if (ibuf1->rect == NULL && ibuf1->rect_float == NULL)
125     return (NULL);
126
127   do_rect = (ibuf1->rect != NULL);
128   do_float = (ibuf1->rect_float != NULL);
129
130   ibuf2 = IMB_allocImBuf(2 * ibuf1->x, ibuf1->y, ibuf1->planes, ibuf1->flags);
131   if (ibuf2 == NULL)
132     return (NULL);
133
134   p1 = (int *)ibuf1->rect;
135   dest = (int *)ibuf2->rect;
136   p1f = (float *)ibuf1->rect_float;
137   destf = (float *)ibuf2->rect_float;
138
139   for (i = ibuf1->y * ibuf1->x; i > 0; i--) {
140     if (do_rect) {
141       col = *p1++;
142       *dest++ = col;
143       *dest++ = col;
144     }
145     if (do_float) {
146       destf[0] = destf[4] = p1f[0];
147       destf[1] = destf[5] = p1f[1];
148       destf[2] = destf[6] = p1f[2];
149       destf[3] = destf[7] = p1f[3];
150       destf += 8;
151       p1f += 4;
152     }
153   }
154
155   return (ibuf2);
156 }
157
158 struct ImBuf *IMB_double_x(struct ImBuf *ibuf1)
159 {
160   struct ImBuf *ibuf2;
161
162   if (ibuf1 == NULL)
163     return (NULL);
164   if (ibuf1->rect == NULL && ibuf1->rect_float == NULL)
165     return (NULL);
166
167   ibuf2 = IMB_double_fast_x(ibuf1);
168
169   imb_filterx(ibuf2);
170   return (ibuf2);
171 }
172
173 static void imb_half_y_no_alloc(struct ImBuf *ibuf2, struct ImBuf *ibuf1)
174 {
175   uchar *p1, *p2, *_p1, *dest;
176   short a, r, g, b;
177   int x, y;
178   int do_rect, do_float;
179   float af, rf, gf, bf, *p1f, *p2f, *_p1f, *destf;
180
181   p1 = p2 = NULL;
182   p1f = p2f = NULL;
183
184   do_rect = (ibuf1->rect != NULL);
185   do_float = (ibuf1->rect_float != NULL && ibuf2->rect_float != NULL);
186
187   _p1 = (uchar *)ibuf1->rect;
188   dest = (uchar *)ibuf2->rect;
189   _p1f = (float *)ibuf1->rect_float;
190   destf = (float *)ibuf2->rect_float;
191
192   for (y = ibuf2->y; y > 0; y--) {
193     if (do_rect) {
194       p1 = _p1;
195       p2 = _p1 + (ibuf1->x << 2);
196     }
197     if (do_float) {
198       p1f = _p1f;
199       p2f = _p1f + (ibuf1->x << 2);
200     }
201     for (x = ibuf2->x; x > 0; x--) {
202       if (do_rect) {
203         a = *(p1++);
204         b = *(p1++);
205         g = *(p1++);
206         r = *(p1++);
207         a += *(p2++);
208         b += *(p2++);
209         g += *(p2++);
210         r += *(p2++);
211         *(dest++) = a >> 1;
212         *(dest++) = b >> 1;
213         *(dest++) = g >> 1;
214         *(dest++) = r >> 1;
215       }
216       if (do_float) {
217         af = *(p1f++);
218         bf = *(p1f++);
219         gf = *(p1f++);
220         rf = *(p1f++);
221         af += *(p2f++);
222         bf += *(p2f++);
223         gf += *(p2f++);
224         rf += *(p2f++);
225         *(destf++) = 0.5f * af;
226         *(destf++) = 0.5f * bf;
227         *(destf++) = 0.5f * gf;
228         *(destf++) = 0.5f * rf;
229       }
230     }
231     if (do_rect)
232       _p1 += (ibuf1->x << 3);
233     if (do_float)
234       _p1f += (ibuf1->x << 3);
235   }
236 }
237
238 struct ImBuf *IMB_half_y(struct ImBuf *ibuf1)
239 {
240   struct ImBuf *ibuf2;
241
242   if (ibuf1 == NULL)
243     return (NULL);
244   if (ibuf1->rect == NULL && ibuf1->rect_float == NULL)
245     return (NULL);
246
247   if (ibuf1->y <= 1)
248     return (IMB_dupImBuf(ibuf1));
249
250   ibuf2 = IMB_allocImBuf(ibuf1->x, (ibuf1->y) / 2, ibuf1->planes, ibuf1->flags);
251   if (ibuf2 == NULL)
252     return (NULL);
253
254   imb_half_y_no_alloc(ibuf2, ibuf1);
255
256   return (ibuf2);
257 }
258
259 struct ImBuf *IMB_double_fast_y(struct ImBuf *ibuf1)
260 {
261   struct ImBuf *ibuf2;
262   int *p1, *dest1, *dest2;
263   float *p1f, *dest1f, *dest2f;
264   int x, y;
265   int do_rect, do_float;
266
267   if (ibuf1 == NULL)
268     return (NULL);
269   if (ibuf1->rect == NULL && ibuf1->rect_float == NULL)
270     return (NULL);
271
272   do_rect = (ibuf1->rect != NULL);
273   do_float = (ibuf1->rect_float != NULL);
274
275   ibuf2 = IMB_allocImBuf(ibuf1->x, 2 * ibuf1->y, ibuf1->planes, ibuf1->flags);
276   if (ibuf2 == NULL)
277     return (NULL);
278
279   p1 = (int *)ibuf1->rect;
280   dest1 = (int *)ibuf2->rect;
281   p1f = (float *)ibuf1->rect_float;
282   dest1f = (float *)ibuf2->rect_float;
283
284   for (y = ibuf1->y; y > 0; y--) {
285     if (do_rect) {
286       dest2 = dest1 + ibuf2->x;
287       for (x = ibuf2->x; x > 0; x--)
288         *dest1++ = *dest2++ = *p1++;
289       dest1 = dest2;
290     }
291     if (do_float) {
292       dest2f = dest1f + (4 * ibuf2->x);
293       for (x = ibuf2->x * 4; x > 0; x--)
294         *dest1f++ = *dest2f++ = *p1f++;
295       dest1f = dest2f;
296     }
297   }
298
299   return (ibuf2);
300 }
301
302 struct ImBuf *IMB_double_y(struct ImBuf *ibuf1)
303 {
304   struct ImBuf *ibuf2;
305
306   if (ibuf1 == NULL)
307     return (NULL);
308   if (ibuf1->rect == NULL)
309     return (NULL);
310
311   ibuf2 = IMB_double_fast_y(ibuf1);
312
313   IMB_filtery(ibuf2);
314   return (ibuf2);
315 }
316
317 /* pretty much specific functions which converts uchar <-> ushort but assumes
318  * ushort range of 255*255 which is more convenient here
319  */
320 MINLINE void straight_uchar_to_premul_ushort(unsigned short result[4],
321                                              const unsigned char color[4])
322 {
323   unsigned short alpha = color[3];
324
325   result[0] = color[0] * alpha;
326   result[1] = color[1] * alpha;
327   result[2] = color[2] * alpha;
328   result[3] = alpha * 256;
329 }
330
331 MINLINE void premul_ushort_to_straight_uchar(unsigned char *result, const unsigned short color[4])
332 {
333   if (color[3] <= 255) {
334     result[0] = unit_ushort_to_uchar(color[0]);
335     result[1] = unit_ushort_to_uchar(color[1]);
336     result[2] = unit_ushort_to_uchar(color[2]);
337     result[3] = unit_ushort_to_uchar(color[3]);
338   }
339   else {
340     unsigned short alpha = color[3] / 256;
341
342     result[0] = unit_ushort_to_uchar((ushort)(color[0] / alpha * 256));
343     result[1] = unit_ushort_to_uchar((ushort)(color[1] / alpha * 256));
344     result[2] = unit_ushort_to_uchar((ushort)(color[2] / alpha * 256));
345     result[3] = unit_ushort_to_uchar(color[3]);
346   }
347 }
348
349 /* result in ibuf2, scaling should be done correctly */
350 void imb_onehalf_no_alloc(struct ImBuf *ibuf2, struct ImBuf *ibuf1)
351 {
352   int x, y;
353   const short do_rect = (ibuf1->rect != NULL);
354   const short do_float = (ibuf1->rect_float != NULL) && (ibuf2->rect_float != NULL);
355
356   if (do_rect && (ibuf2->rect == NULL)) {
357     imb_addrectImBuf(ibuf2);
358   }
359
360   if (ibuf1->x <= 1) {
361     imb_half_y_no_alloc(ibuf2, ibuf1);
362     return;
363   }
364   if (ibuf1->y <= 1) {
365     imb_half_x_no_alloc(ibuf2, ibuf1);
366     return;
367   }
368
369   if (do_rect) {
370     unsigned char *cp1, *cp2, *dest;
371
372     cp1 = (unsigned char *)ibuf1->rect;
373     dest = (unsigned char *)ibuf2->rect;
374
375     for (y = ibuf2->y; y > 0; y--) {
376       cp2 = cp1 + (ibuf1->x << 2);
377       for (x = ibuf2->x; x > 0; x--) {
378         unsigned short p1i[8], p2i[8], desti[4];
379
380         straight_uchar_to_premul_ushort(p1i, cp1);
381         straight_uchar_to_premul_ushort(p2i, cp2);
382         straight_uchar_to_premul_ushort(p1i + 4, cp1 + 4);
383         straight_uchar_to_premul_ushort(p2i + 4, cp2 + 4);
384
385         desti[0] = ((unsigned int)p1i[0] + p2i[0] + p1i[4] + p2i[4]) >> 2;
386         desti[1] = ((unsigned int)p1i[1] + p2i[1] + p1i[5] + p2i[5]) >> 2;
387         desti[2] = ((unsigned int)p1i[2] + p2i[2] + p1i[6] + p2i[6]) >> 2;
388         desti[3] = ((unsigned int)p1i[3] + p2i[3] + p1i[7] + p2i[7]) >> 2;
389
390         premul_ushort_to_straight_uchar(dest, desti);
391
392         cp1 += 8;
393         cp2 += 8;
394         dest += 4;
395       }
396       cp1 = cp2;
397       if (ibuf1->x & 1)
398         cp1 += 4;
399     }
400   }
401
402   if (do_float) {
403     float *p1f, *p2f, *destf;
404
405     p1f = ibuf1->rect_float;
406     destf = ibuf2->rect_float;
407     for (y = ibuf2->y; y > 0; y--) {
408       p2f = p1f + (ibuf1->x << 2);
409       for (x = ibuf2->x; x > 0; x--) {
410         destf[0] = 0.25f * (p1f[0] + p2f[0] + p1f[4] + p2f[4]);
411         destf[1] = 0.25f * (p1f[1] + p2f[1] + p1f[5] + p2f[5]);
412         destf[2] = 0.25f * (p1f[2] + p2f[2] + p1f[6] + p2f[6]);
413         destf[3] = 0.25f * (p1f[3] + p2f[3] + p1f[7] + p2f[7]);
414         p1f += 8;
415         p2f += 8;
416         destf += 4;
417       }
418       p1f = p2f;
419       if (ibuf1->x & 1)
420         p1f += 4;
421     }
422   }
423 }
424
425 ImBuf *IMB_onehalf(struct ImBuf *ibuf1)
426 {
427   struct ImBuf *ibuf2;
428
429   if (ibuf1 == NULL)
430     return (NULL);
431   if (ibuf1->rect == NULL && ibuf1->rect_float == NULL)
432     return (NULL);
433
434   if (ibuf1->x <= 1)
435     return (IMB_half_y(ibuf1));
436   if (ibuf1->y <= 1)
437     return (IMB_half_x(ibuf1));
438
439   ibuf2 = IMB_allocImBuf((ibuf1->x) / 2, (ibuf1->y) / 2, ibuf1->planes, ibuf1->flags);
440   if (ibuf2 == NULL)
441     return (NULL);
442
443   imb_onehalf_no_alloc(ibuf2, ibuf1);
444
445   return (ibuf2);
446 }
447
448 /* q_scale_linear_interpolation helper functions */
449
450 static void enlarge_picture_byte(unsigned char *src,
451                                  unsigned char *dst,
452                                  int src_width,
453                                  int src_height,
454                                  int dst_width,
455                                  int dst_height)
456 {
457   double ratiox = (double)(dst_width - 1.0) / (double)(src_width - 1.001);
458   double ratioy = (double)(dst_height - 1.0) / (double)(src_height - 1.001);
459   uintptr_t x_src, dx_src, x_dst;
460   uintptr_t y_src, dy_src, y_dst;
461
462   dx_src = 65536.0 / ratiox;
463   dy_src = 65536.0 / ratioy;
464
465   y_src = 0;
466   for (y_dst = 0; y_dst < dst_height; y_dst++) {
467     unsigned char *line1 = src + (y_src >> 16) * 4 * src_width;
468     unsigned char *line2 = line1 + 4 * src_width;
469     uintptr_t weight1y = 65536 - (y_src & 0xffff);
470     uintptr_t weight2y = 65536 - weight1y;
471
472     if ((y_src >> 16) == src_height - 1) {
473       line2 = line1;
474     }
475
476     x_src = 0;
477     for (x_dst = 0; x_dst < dst_width; x_dst++) {
478       uintptr_t weight1x = 65536 - (x_src & 0xffff);
479       uintptr_t weight2x = 65536 - weight1x;
480
481       unsigned long x = (x_src >> 16) * 4;
482
483       *dst++ = ((((line1[x] * weight1y) >> 16) * weight1x) >> 16) +
484                ((((line2[x] * weight2y) >> 16) * weight1x) >> 16) +
485                ((((line1[4 + x] * weight1y) >> 16) * weight2x) >> 16) +
486                ((((line2[4 + x] * weight2y) >> 16) * weight2x) >> 16);
487
488       *dst++ = ((((line1[x + 1] * weight1y) >> 16) * weight1x) >> 16) +
489                ((((line2[x + 1] * weight2y) >> 16) * weight1x) >> 16) +
490                ((((line1[4 + x + 1] * weight1y) >> 16) * weight2x) >> 16) +
491                ((((line2[4 + x + 1] * weight2y) >> 16) * weight2x) >> 16);
492
493       *dst++ = ((((line1[x + 2] * weight1y) >> 16) * weight1x) >> 16) +
494                ((((line2[x + 2] * weight2y) >> 16) * weight1x) >> 16) +
495                ((((line1[4 + x + 2] * weight1y) >> 16) * weight2x) >> 16) +
496                ((((line2[4 + x + 2] * weight2y) >> 16) * weight2x) >> 16);
497
498       *dst++ = ((((line1[x + 3] * weight1y) >> 16) * weight1x) >> 16) +
499                ((((line2[x + 3] * weight2y) >> 16) * weight1x) >> 16) +
500                ((((line1[4 + x + 3] * weight1y) >> 16) * weight2x) >> 16) +
501                ((((line2[4 + x + 3] * weight2y) >> 16) * weight2x) >> 16);
502
503       x_src += dx_src;
504     }
505     y_src += dy_src;
506   }
507 }
508
509 struct scale_outpix_byte {
510   uintptr_t r;
511   uintptr_t g;
512   uintptr_t b;
513   uintptr_t a;
514
515   uintptr_t weight;
516 };
517
518 static void shrink_picture_byte(unsigned char *src,
519                                 unsigned char *dst,
520                                 int src_width,
521                                 int src_height,
522                                 int dst_width,
523                                 int dst_height)
524 {
525   double ratiox = (double)(dst_width) / (double)(src_width);
526   double ratioy = (double)(dst_height) / (double)(src_height);
527   uintptr_t x_src, dx_dst, x_dst;
528   uintptr_t y_src, dy_dst, y_dst;
529   intptr_t y_counter;
530   unsigned char *dst_begin = dst;
531
532   struct scale_outpix_byte *dst_line1 = NULL;
533   struct scale_outpix_byte *dst_line2 = NULL;
534
535   dst_line1 = (struct scale_outpix_byte *)MEM_callocN(
536       (dst_width + 1) * sizeof(struct scale_outpix_byte), "shrink_picture_byte 1");
537   dst_line2 = (struct scale_outpix_byte *)MEM_callocN(
538       (dst_width + 1) * sizeof(struct scale_outpix_byte), "shrink_picture_byte 2");
539
540   dx_dst = 65536.0 * ratiox;
541   dy_dst = 65536.0 * ratioy;
542
543   y_dst = 0;
544   y_counter = 65536;
545   for (y_src = 0; y_src < src_height; y_src++) {
546     unsigned char *line = src + y_src * 4 * src_width;
547     uintptr_t weight1y = 65535 - (y_dst & 0xffff);
548     uintptr_t weight2y = 65535 - weight1y;
549     x_dst = 0;
550     for (x_src = 0; x_src < src_width; x_src++) {
551       uintptr_t weight1x = 65535 - (x_dst & 0xffff);
552       uintptr_t weight2x = 65535 - weight1x;
553
554       uintptr_t x = x_dst >> 16;
555
556       uintptr_t w;
557
558       w = (weight1y * weight1x) >> 16;
559
560       /* Ensure correct rounding, without this you get ugly banding,
561        * or too low color values (ton). */
562       dst_line1[x].r += (line[0] * w + 32767) >> 16;
563       dst_line1[x].g += (line[1] * w + 32767) >> 16;
564       dst_line1[x].b += (line[2] * w + 32767) >> 16;
565       dst_line1[x].a += (line[3] * w + 32767) >> 16;
566       dst_line1[x].weight += w;
567
568       w = (weight2y * weight1x) >> 16;
569
570       dst_line2[x].r += (line[0] * w + 32767) >> 16;
571       dst_line2[x].g += (line[1] * w + 32767) >> 16;
572       dst_line2[x].b += (line[2] * w + 32767) >> 16;
573       dst_line2[x].a += (line[3] * w + 32767) >> 16;
574       dst_line2[x].weight += w;
575
576       w = (weight1y * weight2x) >> 16;
577
578       dst_line1[x + 1].r += (line[0] * w + 32767) >> 16;
579       dst_line1[x + 1].g += (line[1] * w + 32767) >> 16;
580       dst_line1[x + 1].b += (line[2] * w + 32767) >> 16;
581       dst_line1[x + 1].a += (line[3] * w + 32767) >> 16;
582       dst_line1[x + 1].weight += w;
583
584       w = (weight2y * weight2x) >> 16;
585
586       dst_line2[x + 1].r += (line[0] * w + 32767) >> 16;
587       dst_line2[x + 1].g += (line[1] * w + 32767) >> 16;
588       dst_line2[x + 1].b += (line[2] * w + 32767) >> 16;
589       dst_line2[x + 1].a += (line[3] * w + 32767) >> 16;
590       dst_line2[x + 1].weight += w;
591
592       x_dst += dx_dst;
593       line += 4;
594     }
595
596     y_dst += dy_dst;
597     y_counter -= dy_dst;
598     if (y_counter < 0) {
599       int val;
600       uintptr_t x;
601       struct scale_outpix_byte *temp;
602
603       y_counter += 65536;
604
605       for (x = 0; x < dst_width; x++) {
606         uintptr_t f = 0x80000000UL / dst_line1[x].weight;
607         *dst++ = (val = (dst_line1[x].r * f) >> 15) > 255 ? 255 : val;
608         *dst++ = (val = (dst_line1[x].g * f) >> 15) > 255 ? 255 : val;
609         *dst++ = (val = (dst_line1[x].b * f) >> 15) > 255 ? 255 : val;
610         *dst++ = (val = (dst_line1[x].a * f) >> 15) > 255 ? 255 : val;
611       }
612       memset(dst_line1, 0, dst_width * sizeof(struct scale_outpix_byte));
613       temp = dst_line1;
614       dst_line1 = dst_line2;
615       dst_line2 = temp;
616     }
617   }
618   if (dst - dst_begin < dst_width * dst_height * 4) {
619     int val;
620     uintptr_t x;
621     for (x = 0; x < dst_width; x++) {
622       uintptr_t f = 0x80000000UL / dst_line1[x].weight;
623       *dst++ = (val = (dst_line1[x].r * f) >> 15) > 255 ? 255 : val;
624       *dst++ = (val = (dst_line1[x].g * f) >> 15) > 255 ? 255 : val;
625       *dst++ = (val = (dst_line1[x].b * f) >> 15) > 255 ? 255 : val;
626       *dst++ = (val = (dst_line1[x].a * f) >> 15) > 255 ? 255 : val;
627     }
628   }
629   MEM_freeN(dst_line1);
630   MEM_freeN(dst_line2);
631 }
632
633 static void q_scale_byte(unsigned char *in,
634                          unsigned char *out,
635                          int in_width,
636                          int in_height,
637                          int dst_width,
638                          int dst_height)
639 {
640   if (dst_width > in_width && dst_height > in_height) {
641     enlarge_picture_byte(in, out, in_width, in_height, dst_width, dst_height);
642   }
643   else if (dst_width < in_width && dst_height < in_height) {
644     shrink_picture_byte(in, out, in_width, in_height, dst_width, dst_height);
645   }
646 }
647
648 static void enlarge_picture_float(
649     float *src, float *dst, int src_width, int src_height, int dst_width, int dst_height)
650 {
651   double ratiox = (double)(dst_width - 1.0) / (double)(src_width - 1.001);
652   double ratioy = (double)(dst_height - 1.0) / (double)(src_height - 1.001);
653   uintptr_t x_dst;
654   uintptr_t y_dst;
655   double x_src, dx_src;
656   double y_src, dy_src;
657
658   dx_src = 1.0 / ratiox;
659   dy_src = 1.0 / ratioy;
660
661   y_src = 0;
662   for (y_dst = 0; y_dst < dst_height; y_dst++) {
663     float *line1 = src + ((int)y_src) * 4 * src_width;
664     const float *line2 = line1 + 4 * src_width;
665     const float weight1y = (float)(1.0 - (y_src - (int)y_src));
666     const float weight2y = 1.0f - weight1y;
667
668     if ((int)y_src == src_height - 1) {
669       line2 = line1;
670     }
671
672     x_src = 0;
673     for (x_dst = 0; x_dst < dst_width; x_dst++) {
674       const float weight1x = (float)(1.0 - (x_src - (int)x_src));
675       const float weight2x = (float)(1.0f - weight1x);
676
677       const float w11 = weight1y * weight1x;
678       const float w21 = weight2y * weight1x;
679       const float w12 = weight1y * weight2x;
680       const float w22 = weight2y * weight2x;
681
682       uintptr_t x = ((int)x_src) * 4;
683
684       *dst++ = line1[x] * w11 + line2[x] * w21 + line1[4 + x] * w12 + line2[4 + x] * w22;
685
686       *dst++ = line1[x + 1] * w11 + line2[x + 1] * w21 + line1[4 + x + 1] * w12 +
687                line2[4 + x + 1] * w22;
688
689       *dst++ = line1[x + 2] * w11 + line2[x + 2] * w21 + line1[4 + x + 2] * w12 +
690                line2[4 + x + 2] * w22;
691
692       *dst++ = line1[x + 3] * w11 + line2[x + 3] * w21 + line1[4 + x + 3] * w12 +
693                line2[4 + x + 3] * w22;
694
695       x_src += dx_src;
696     }
697     y_src += dy_src;
698   }
699 }
700
701 struct scale_outpix_float {
702   float r;
703   float g;
704   float b;
705   float a;
706
707   float weight;
708 };
709
710 static void shrink_picture_float(
711     const float *src, float *dst, int src_width, int src_height, int dst_width, int dst_height)
712 {
713   double ratiox = (double)(dst_width) / (double)(src_width);
714   double ratioy = (double)(dst_height) / (double)(src_height);
715   uintptr_t x_src;
716   uintptr_t y_src;
717   float dx_dst, x_dst;
718   float dy_dst, y_dst;
719   float y_counter;
720   const float *dst_begin = dst;
721
722   struct scale_outpix_float *dst_line1;
723   struct scale_outpix_float *dst_line2;
724
725   dst_line1 = (struct scale_outpix_float *)MEM_callocN(
726       (dst_width + 1) * sizeof(struct scale_outpix_float), "shrink_picture_float 1");
727   dst_line2 = (struct scale_outpix_float *)MEM_callocN(
728       (dst_width + 1) * sizeof(struct scale_outpix_float), "shrink_picture_float 2");
729
730   dx_dst = ratiox;
731   dy_dst = ratioy;
732
733   y_dst = 0;
734   y_counter = 1.0;
735   for (y_src = 0; y_src < src_height; y_src++) {
736     const float *line = src + y_src * 4 * src_width;
737     uintptr_t weight1y = 1.0f - (y_dst - (int)y_dst);
738     uintptr_t weight2y = 1.0f - weight1y;
739     x_dst = 0;
740     for (x_src = 0; x_src < src_width; x_src++) {
741       uintptr_t weight1x = 1.0f - (x_dst - (int)x_dst);
742       uintptr_t weight2x = 1.0f - weight1x;
743
744       uintptr_t x = (int)x_dst;
745
746       float w;
747
748       w = weight1y * weight1x;
749
750       dst_line1[x].r += line[0] * w;
751       dst_line1[x].g += line[1] * w;
752       dst_line1[x].b += line[2] * w;
753       dst_line1[x].a += line[3] * w;
754       dst_line1[x].weight += w;
755
756       w = weight2y * weight1x;
757
758       dst_line2[x].r += line[0] * w;
759       dst_line2[x].g += line[1] * w;
760       dst_line2[x].b += line[2] * w;
761       dst_line2[x].a += line[3] * w;
762       dst_line2[x].weight += w;
763
764       w = weight1y * weight2x;
765
766       dst_line1[x + 1].r += line[0] * w;
767       dst_line1[x + 1].g += line[1] * w;
768       dst_line1[x + 1].b += line[2] * w;
769       dst_line1[x + 1].a += line[3] * w;
770       dst_line1[x + 1].weight += w;
771
772       w = weight2y * weight2x;
773
774       dst_line2[x + 1].r += line[0] * w;
775       dst_line2[x + 1].g += line[1] * w;
776       dst_line2[x + 1].b += line[2] * w;
777       dst_line2[x + 1].a += line[3] * w;
778       dst_line2[x + 1].weight += w;
779
780       x_dst += dx_dst;
781       line += 4;
782     }
783
784     y_dst += dy_dst;
785     y_counter -= dy_dst;
786     if (y_counter < 0) {
787       uintptr_t x;
788       struct scale_outpix_float *temp;
789
790       y_counter += 1.0f;
791
792       for (x = 0; x < dst_width; x++) {
793         float f = 1.0f / dst_line1[x].weight;
794         *dst++ = dst_line1[x].r * f;
795         *dst++ = dst_line1[x].g * f;
796         *dst++ = dst_line1[x].b * f;
797         *dst++ = dst_line1[x].a * f;
798       }
799       memset(dst_line1, 0, dst_width * sizeof(struct scale_outpix_float));
800       temp = dst_line1;
801       dst_line1 = dst_line2;
802       dst_line2 = temp;
803     }
804   }
805   if (dst - dst_begin < dst_width * dst_height * 4) {
806     uintptr_t x;
807     for (x = 0; x < dst_width; x++) {
808       float f = 1.0f / dst_line1[x].weight;
809       *dst++ = dst_line1[x].r * f;
810       *dst++ = dst_line1[x].g * f;
811       *dst++ = dst_line1[x].b * f;
812       *dst++ = dst_line1[x].a * f;
813     }
814   }
815   MEM_freeN(dst_line1);
816   MEM_freeN(dst_line2);
817 }
818
819 static void q_scale_float(
820     float *in, float *out, int in_width, int in_height, int dst_width, int dst_height)
821 {
822   if (dst_width > in_width && dst_height > in_height) {
823     enlarge_picture_float(in, out, in_width, in_height, dst_width, dst_height);
824   }
825   else if (dst_width < in_width && dst_height < in_height) {
826     shrink_picture_float(in, out, in_width, in_height, dst_width, dst_height);
827   }
828 }
829
830 /**
831  * q_scale_linear_interpolation (derived from ppmqscale, http://libdv.sf.net)
832  *
833  * q stands for quick _and_ quality :)
834  *
835  * only handles common cases when we either
836  *
837  * scale  both, x and y or
838  * shrink both, x and y
839  *
840  * but that is pretty fast:
841  * - does only blit once instead of two passes like the old code
842  *   (fewer cache misses)
843  * - uses fixed point integer arithmetic for byte buffers
844  * - doesn't branch in tight loops
845  *
846  * Should be comparable in speed to the ImBuf ..._fast functions at least
847  * for byte-buffers.
848  *
849  * NOTE: disabled, due to unacceptable inaccuracy and quality loss, see bug #18609 (ton)
850  */
851 static bool q_scale_linear_interpolation(struct ImBuf *ibuf, int newx, int newy)
852 {
853   if ((newx >= ibuf->x && newy <= ibuf->y) || (newx <= ibuf->x && newy >= ibuf->y)) {
854     return false;
855   }
856
857   if (ibuf->rect) {
858     unsigned char *newrect = MEM_mallocN(newx * newy * sizeof(int), "q_scale rect");
859     q_scale_byte((unsigned char *)ibuf->rect, newrect, ibuf->x, ibuf->y, newx, newy);
860
861     imb_freerectImBuf(ibuf);
862     ibuf->mall |= IB_rect;
863     ibuf->rect = (unsigned int *)newrect;
864   }
865   if (ibuf->rect_float) {
866     float *newrect = MEM_mallocN(newx * newy * 4 * sizeof(float), "q_scale rectfloat");
867     q_scale_float(ibuf->rect_float, newrect, ibuf->x, ibuf->y, newx, newy);
868     imb_freerectfloatImBuf(ibuf);
869     ibuf->mall |= IB_rectfloat;
870     ibuf->rect_float = newrect;
871   }
872   ibuf->x = newx;
873   ibuf->y = newy;
874
875   return true;
876 }
877
878 static ImBuf *scaledownx(struct ImBuf *ibuf, int newx)
879 {
880   const int do_rect = (ibuf->rect != NULL);
881   const int do_float = (ibuf->rect_float != NULL);
882   const size_t rect_size = ibuf->x * ibuf->y * 4;
883
884   uchar *rect, *_newrect, *newrect;
885   float *rectf, *_newrectf, *newrectf;
886   float sample, add, val[4], nval[4], valf[4], nvalf[4];
887   int x, y;
888
889   rectf = _newrectf = newrectf = NULL;
890   rect = _newrect = newrect = NULL;
891   nval[0] = nval[1] = nval[2] = nval[3] = 0.0f;
892   nvalf[0] = nvalf[1] = nvalf[2] = nvalf[3] = 0.0f;
893
894   if (!do_rect && !do_float)
895     return (ibuf);
896
897   if (do_rect) {
898     _newrect = MEM_mallocN(newx * ibuf->y * sizeof(uchar) * 4, "scaledownx");
899     if (_newrect == NULL)
900       return (ibuf);
901   }
902   if (do_float) {
903     _newrectf = MEM_mallocN(newx * ibuf->y * sizeof(float) * 4, "scaledownxf");
904     if (_newrectf == NULL) {
905       if (_newrect)
906         MEM_freeN(_newrect);
907       return (ibuf);
908     }
909   }
910
911   add = (ibuf->x - 0.01) / newx;
912
913   if (do_rect) {
914     rect = (uchar *)ibuf->rect;
915     newrect = _newrect;
916   }
917   if (do_float) {
918     rectf = ibuf->rect_float;
919     newrectf = _newrectf;
920   }
921
922   for (y = ibuf->y; y > 0; y--) {
923     sample = 0.0f;
924     val[0] = val[1] = val[2] = val[3] = 0.0f;
925     valf[0] = valf[1] = valf[2] = valf[3] = 0.0f;
926
927     for (x = newx; x > 0; x--) {
928       if (do_rect) {
929         nval[0] = -val[0] * sample;
930         nval[1] = -val[1] * sample;
931         nval[2] = -val[2] * sample;
932         nval[3] = -val[3] * sample;
933       }
934       if (do_float) {
935         nvalf[0] = -valf[0] * sample;
936         nvalf[1] = -valf[1] * sample;
937         nvalf[2] = -valf[2] * sample;
938         nvalf[3] = -valf[3] * sample;
939       }
940
941       sample += add;
942
943       while (sample >= 1.0f) {
944         sample -= 1.0f;
945
946         if (do_rect) {
947           nval[0] += rect[0];
948           nval[1] += rect[1];
949           nval[2] += rect[2];
950           nval[3] += rect[3];
951           rect += 4;
952         }
953         if (do_float) {
954           nvalf[0] += rectf[0];
955           nvalf[1] += rectf[1];
956           nvalf[2] += rectf[2];
957           nvalf[3] += rectf[3];
958           rectf += 4;
959         }
960       }
961
962       if (do_rect) {
963         val[0] = rect[0];
964         val[1] = rect[1];
965         val[2] = rect[2];
966         val[3] = rect[3];
967         rect += 4;
968
969         newrect[0] = ((nval[0] + sample * val[0]) / add + 0.5f);
970         newrect[1] = ((nval[1] + sample * val[1]) / add + 0.5f);
971         newrect[2] = ((nval[2] + sample * val[2]) / add + 0.5f);
972         newrect[3] = ((nval[3] + sample * val[3]) / add + 0.5f);
973
974         newrect += 4;
975       }
976       if (do_float) {
977
978         valf[0] = rectf[0];
979         valf[1] = rectf[1];
980         valf[2] = rectf[2];
981         valf[3] = rectf[3];
982         rectf += 4;
983
984         newrectf[0] = ((nvalf[0] + sample * valf[0]) / add);
985         newrectf[1] = ((nvalf[1] + sample * valf[1]) / add);
986         newrectf[2] = ((nvalf[2] + sample * valf[2]) / add);
987         newrectf[3] = ((nvalf[3] + sample * valf[3]) / add);
988
989         newrectf += 4;
990       }
991
992       sample -= 1.0f;
993     }
994   }
995
996   if (do_rect) {
997     // printf("%ld %ld\n", (uchar *)rect - ((uchar *)ibuf->rect), rect_size);
998     BLI_assert((uchar *)rect - ((uchar *)ibuf->rect) == rect_size); /* see bug [#26502] */
999     imb_freerectImBuf(ibuf);
1000     ibuf->mall |= IB_rect;
1001     ibuf->rect = (unsigned int *)_newrect;
1002   }
1003   if (do_float) {
1004     // printf("%ld %ld\n", rectf - ibuf->rect_float, rect_size);
1005     BLI_assert((rectf - ibuf->rect_float) == rect_size); /* see bug [#26502] */
1006     imb_freerectfloatImBuf(ibuf);
1007     ibuf->mall |= IB_rectfloat;
1008     ibuf->rect_float = _newrectf;
1009   }
1010   (void)rect_size; /* UNUSED in release builds */
1011
1012   ibuf->x = newx;
1013   return (ibuf);
1014 }
1015
1016 static ImBuf *scaledowny(struct ImBuf *ibuf, int newy)
1017 {
1018   const int do_rect = (ibuf->rect != NULL);
1019   const int do_float = (ibuf->rect_float != NULL);
1020   const size_t rect_size = ibuf->x * ibuf->y * 4;
1021
1022   uchar *rect, *_newrect, *newrect;
1023   float *rectf, *_newrectf, *newrectf;
1024   float sample, add, val[4], nval[4], valf[4], nvalf[4];
1025   int x, y, skipx;
1026
1027   rectf = _newrectf = newrectf = NULL;
1028   rect = _newrect = newrect = NULL;
1029   nval[0] = nval[1] = nval[2] = nval[3] = 0.0f;
1030   nvalf[0] = nvalf[1] = nvalf[2] = nvalf[3] = 0.0f;
1031
1032   if (!do_rect && !do_float)
1033     return (ibuf);
1034
1035   if (do_rect) {
1036     _newrect = MEM_mallocN(newy * ibuf->x * sizeof(uchar) * 4, "scaledowny");
1037     if (_newrect == NULL)
1038       return (ibuf);
1039   }
1040   if (do_float) {
1041     _newrectf = MEM_mallocN(newy * ibuf->x * sizeof(float) * 4, "scaledownyf");
1042     if (_newrectf == NULL) {
1043       if (_newrect)
1044         MEM_freeN(_newrect);
1045       return (ibuf);
1046     }
1047   }
1048
1049   add = (ibuf->y - 0.01) / newy;
1050   skipx = 4 * ibuf->x;
1051
1052   for (x = skipx - 4; x >= 0; x -= 4) {
1053     if (do_rect) {
1054       rect = ((uchar *)ibuf->rect) + x;
1055       newrect = _newrect + x;
1056     }
1057     if (do_float) {
1058       rectf = ibuf->rect_float + x;
1059       newrectf = _newrectf + x;
1060     }
1061
1062     sample = 0.0f;
1063     val[0] = val[1] = val[2] = val[3] = 0.0f;
1064     valf[0] = valf[1] = valf[2] = valf[3] = 0.0f;
1065
1066     for (y = newy; y > 0; y--) {
1067       if (do_rect) {
1068         nval[0] = -val[0] * sample;
1069         nval[1] = -val[1] * sample;
1070         nval[2] = -val[2] * sample;
1071         nval[3] = -val[3] * sample;
1072       }
1073       if (do_float) {
1074         nvalf[0] = -valf[0] * sample;
1075         nvalf[1] = -valf[1] * sample;
1076         nvalf[2] = -valf[2] * sample;
1077         nvalf[3] = -valf[3] * sample;
1078       }
1079
1080       sample += add;
1081
1082       while (sample >= 1.0f) {
1083         sample -= 1.0f;
1084
1085         if (do_rect) {
1086           nval[0] += rect[0];
1087           nval[1] += rect[1];
1088           nval[2] += rect[2];
1089           nval[3] += rect[3];
1090           rect += skipx;
1091         }
1092         if (do_float) {
1093           nvalf[0] += rectf[0];
1094           nvalf[1] += rectf[1];
1095           nvalf[2] += rectf[2];
1096           nvalf[3] += rectf[3];
1097           rectf += skipx;
1098         }
1099       }
1100
1101       if (do_rect) {
1102         val[0] = rect[0];
1103         val[1] = rect[1];
1104         val[2] = rect[2];
1105         val[3] = rect[3];
1106         rect += skipx;
1107
1108         newrect[0] = ((nval[0] + sample * val[0]) / add + 0.5f);
1109         newrect[1] = ((nval[1] + sample * val[1]) / add + 0.5f);
1110         newrect[2] = ((nval[2] + sample * val[2]) / add + 0.5f);
1111         newrect[3] = ((nval[3] + sample * val[3]) / add + 0.5f);
1112
1113         newrect += skipx;
1114       }
1115       if (do_float) {
1116
1117         valf[0] = rectf[0];
1118         valf[1] = rectf[1];
1119         valf[2] = rectf[2];
1120         valf[3] = rectf[3];
1121         rectf += skipx;
1122
1123         newrectf[0] = ((nvalf[0] + sample * valf[0]) / add);
1124         newrectf[1] = ((nvalf[1] + sample * valf[1]) / add);
1125         newrectf[2] = ((nvalf[2] + sample * valf[2]) / add);
1126         newrectf[3] = ((nvalf[3] + sample * valf[3]) / add);
1127
1128         newrectf += skipx;
1129       }
1130
1131       sample -= 1.0f;
1132     }
1133   }
1134
1135   if (do_rect) {
1136     // printf("%ld %ld\n", (uchar *)rect - ((uchar *)ibuf->rect), rect_size);
1137     BLI_assert((uchar *)rect - ((uchar *)ibuf->rect) == rect_size); /* see bug [#26502] */
1138     imb_freerectImBuf(ibuf);
1139     ibuf->mall |= IB_rect;
1140     ibuf->rect = (unsigned int *)_newrect;
1141   }
1142   if (do_float) {
1143     // printf("%ld %ld\n", rectf - ibuf->rect_float, rect_size);
1144     BLI_assert((rectf - ibuf->rect_float) == rect_size); /* see bug [#26502] */
1145     imb_freerectfloatImBuf(ibuf);
1146     ibuf->mall |= IB_rectfloat;
1147     ibuf->rect_float = (float *)_newrectf;
1148   }
1149   (void)rect_size; /* UNUSED in release builds */
1150
1151   ibuf->y = newy;
1152   return (ibuf);
1153 }
1154
1155 static ImBuf *scaleupx(struct ImBuf *ibuf, int newx)
1156 {
1157   uchar *rect, *_newrect = NULL, *newrect;
1158   float *rectf, *_newrectf = NULL, *newrectf;
1159   float sample, add;
1160   float val_a, nval_a, diff_a;
1161   float val_b, nval_b, diff_b;
1162   float val_g, nval_g, diff_g;
1163   float val_r, nval_r, diff_r;
1164   float val_af, nval_af, diff_af;
1165   float val_bf, nval_bf, diff_bf;
1166   float val_gf, nval_gf, diff_gf;
1167   float val_rf, nval_rf, diff_rf;
1168   int x, y;
1169   bool do_rect = false, do_float = false;
1170
1171   val_a = nval_a = diff_a = val_b = nval_b = diff_b = 0;
1172   val_g = nval_g = diff_g = val_r = nval_r = diff_r = 0;
1173   val_af = nval_af = diff_af = val_bf = nval_bf = diff_bf = 0;
1174   val_gf = nval_gf = diff_gf = val_rf = nval_rf = diff_rf = 0;
1175   if (ibuf == NULL)
1176     return (NULL);
1177   if (ibuf->rect == NULL && ibuf->rect_float == NULL)
1178     return (ibuf);
1179
1180   if (ibuf->rect) {
1181     do_rect = true;
1182     _newrect = MEM_mallocN(newx * ibuf->y * sizeof(int), "scaleupx");
1183     if (_newrect == NULL)
1184       return (ibuf);
1185   }
1186   if (ibuf->rect_float) {
1187     do_float = true;
1188     _newrectf = MEM_mallocN(newx * ibuf->y * sizeof(float) * 4, "scaleupxf");
1189     if (_newrectf == NULL) {
1190       if (_newrect)
1191         MEM_freeN(_newrect);
1192       return (ibuf);
1193     }
1194   }
1195
1196   add = (ibuf->x - 1.001) / (newx - 1.0);
1197
1198   rect = (uchar *)ibuf->rect;
1199   rectf = (float *)ibuf->rect_float;
1200   newrect = _newrect;
1201   newrectf = _newrectf;
1202
1203   for (y = ibuf->y; y > 0; y--) {
1204
1205     sample = 0;
1206
1207     if (do_rect) {
1208       val_a = rect[0];
1209       nval_a = rect[4];
1210       diff_a = nval_a - val_a;
1211       val_a += 0.5f;
1212
1213       val_b = rect[1];
1214       nval_b = rect[5];
1215       diff_b = nval_b - val_b;
1216       val_b += 0.5f;
1217
1218       val_g = rect[2];
1219       nval_g = rect[6];
1220       diff_g = nval_g - val_g;
1221       val_g += 0.5f;
1222
1223       val_r = rect[3];
1224       nval_r = rect[7];
1225       diff_r = nval_r - val_r;
1226       val_r += 0.5f;
1227
1228       rect += 8;
1229     }
1230     if (do_float) {
1231       val_af = rectf[0];
1232       nval_af = rectf[4];
1233       diff_af = nval_af - val_af;
1234
1235       val_bf = rectf[1];
1236       nval_bf = rectf[5];
1237       diff_bf = nval_bf - val_bf;
1238
1239       val_gf = rectf[2];
1240       nval_gf = rectf[6];
1241       diff_gf = nval_gf - val_gf;
1242
1243       val_rf = rectf[3];
1244       nval_rf = rectf[7];
1245       diff_rf = nval_rf - val_rf;
1246
1247       rectf += 8;
1248     }
1249     for (x = newx; x > 0; x--) {
1250       if (sample >= 1.0f) {
1251         sample -= 1.0f;
1252
1253         if (do_rect) {
1254           val_a = nval_a;
1255           nval_a = rect[0];
1256           diff_a = nval_a - val_a;
1257           val_a += 0.5f;
1258
1259           val_b = nval_b;
1260           nval_b = rect[1];
1261           diff_b = nval_b - val_b;
1262           val_b += 0.5f;
1263
1264           val_g = nval_g;
1265           nval_g = rect[2];
1266           diff_g = nval_g - val_g;
1267           val_g += 0.5f;
1268
1269           val_r = nval_r;
1270           nval_r = rect[3];
1271           diff_r = nval_r - val_r;
1272           val_r += 0.5f;
1273           rect += 4;
1274         }
1275         if (do_float) {
1276           val_af = nval_af;
1277           nval_af = rectf[0];
1278           diff_af = nval_af - val_af;
1279
1280           val_bf = nval_bf;
1281           nval_bf = rectf[1];
1282           diff_bf = nval_bf - val_bf;
1283
1284           val_gf = nval_gf;
1285           nval_gf = rectf[2];
1286           diff_gf = nval_gf - val_gf;
1287
1288           val_rf = nval_rf;
1289           nval_rf = rectf[3];
1290           diff_rf = nval_rf - val_rf;
1291           rectf += 4;
1292         }
1293       }
1294       if (do_rect) {
1295         newrect[0] = val_a + sample * diff_a;
1296         newrect[1] = val_b + sample * diff_b;
1297         newrect[2] = val_g + sample * diff_g;
1298         newrect[3] = val_r + sample * diff_r;
1299         newrect += 4;
1300       }
1301       if (do_float) {
1302         newrectf[0] = val_af + sample * diff_af;
1303         newrectf[1] = val_bf + sample * diff_bf;
1304         newrectf[2] = val_gf + sample * diff_gf;
1305         newrectf[3] = val_rf + sample * diff_rf;
1306         newrectf += 4;
1307       }
1308       sample += add;
1309     }
1310   }
1311
1312   if (do_rect) {
1313     imb_freerectImBuf(ibuf);
1314     ibuf->mall |= IB_rect;
1315     ibuf->rect = (unsigned int *)_newrect;
1316   }
1317   if (do_float) {
1318     imb_freerectfloatImBuf(ibuf);
1319     ibuf->mall |= IB_rectfloat;
1320     ibuf->rect_float = (float *)_newrectf;
1321   }
1322
1323   ibuf->x = newx;
1324   return (ibuf);
1325 }
1326
1327 static ImBuf *scaleupy(struct ImBuf *ibuf, int newy)
1328 {
1329   uchar *rect, *_newrect = NULL, *newrect;
1330   float *rectf, *_newrectf = NULL, *newrectf;
1331   float sample, add;
1332   float val_a, nval_a, diff_a;
1333   float val_b, nval_b, diff_b;
1334   float val_g, nval_g, diff_g;
1335   float val_r, nval_r, diff_r;
1336   float val_af, nval_af, diff_af;
1337   float val_bf, nval_bf, diff_bf;
1338   float val_gf, nval_gf, diff_gf;
1339   float val_rf, nval_rf, diff_rf;
1340   int x, y, skipx;
1341   bool do_rect = false, do_float = false;
1342
1343   val_a = nval_a = diff_a = val_b = nval_b = diff_b = 0;
1344   val_g = nval_g = diff_g = val_r = nval_r = diff_r = 0;
1345   val_af = nval_af = diff_af = val_bf = nval_bf = diff_bf = 0;
1346   val_gf = nval_gf = diff_gf = val_rf = nval_rf = diff_rf = 0;
1347   if (ibuf == NULL)
1348     return (NULL);
1349   if (ibuf->rect == NULL && ibuf->rect_float == NULL)
1350     return (ibuf);
1351
1352   if (ibuf->rect) {
1353     do_rect = true;
1354     _newrect = MEM_mallocN(ibuf->x * newy * sizeof(int), "scaleupy");
1355     if (_newrect == NULL)
1356       return (ibuf);
1357   }
1358   if (ibuf->rect_float) {
1359     do_float = true;
1360     _newrectf = MEM_mallocN(ibuf->x * newy * sizeof(float) * 4, "scaleupyf");
1361     if (_newrectf == NULL) {
1362       if (_newrect)
1363         MEM_freeN(_newrect);
1364       return (ibuf);
1365     }
1366   }
1367
1368   add = (ibuf->y - 1.001) / (newy - 1.0);
1369   skipx = 4 * ibuf->x;
1370
1371   rect = (uchar *)ibuf->rect;
1372   rectf = (float *)ibuf->rect_float;
1373   newrect = _newrect;
1374   newrectf = _newrectf;
1375
1376   for (x = ibuf->x; x > 0; x--) {
1377
1378     sample = 0;
1379     if (do_rect) {
1380       rect = ((uchar *)ibuf->rect) + 4 * (x - 1);
1381       newrect = _newrect + 4 * (x - 1);
1382
1383       val_a = rect[0];
1384       nval_a = rect[skipx];
1385       diff_a = nval_a - val_a;
1386       val_a += 0.5f;
1387
1388       val_b = rect[1];
1389       nval_b = rect[skipx + 1];
1390       diff_b = nval_b - val_b;
1391       val_b += 0.5f;
1392
1393       val_g = rect[2];
1394       nval_g = rect[skipx + 2];
1395       diff_g = nval_g - val_g;
1396       val_g += 0.5f;
1397
1398       val_r = rect[3];
1399       nval_r = rect[skipx + 3];
1400       diff_r = nval_r - val_r;
1401       val_r += 0.5f;
1402
1403       rect += 2 * skipx;
1404     }
1405     if (do_float) {
1406       rectf = ibuf->rect_float + 4 * (x - 1);
1407       newrectf = _newrectf + 4 * (x - 1);
1408
1409       val_af = rectf[0];
1410       nval_af = rectf[skipx];
1411       diff_af = nval_af - val_af;
1412
1413       val_bf = rectf[1];
1414       nval_bf = rectf[skipx + 1];
1415       diff_bf = nval_bf - val_bf;
1416
1417       val_gf = rectf[2];
1418       nval_gf = rectf[skipx + 2];
1419       diff_gf = nval_gf - val_gf;
1420
1421       val_rf = rectf[3];
1422       nval_rf = rectf[skipx + 3];
1423       diff_rf = nval_rf - val_rf;
1424
1425       rectf += 2 * skipx;
1426     }
1427
1428     for (y = newy; y > 0; y--) {
1429       if (sample >= 1.0f) {
1430         sample -= 1.0f;
1431
1432         if (do_rect) {
1433           val_a = nval_a;
1434           nval_a = rect[0];
1435           diff_a = nval_a - val_a;
1436           val_a += 0.5f;
1437
1438           val_b = nval_b;
1439           nval_b = rect[1];
1440           diff_b = nval_b - val_b;
1441           val_b += 0.5f;
1442
1443           val_g = nval_g;
1444           nval_g = rect[2];
1445           diff_g = nval_g - val_g;
1446           val_g += 0.5f;
1447
1448           val_r = nval_r;
1449           nval_r = rect[3];
1450           diff_r = nval_r - val_r;
1451           val_r += 0.5f;
1452           rect += skipx;
1453         }
1454         if (do_float) {
1455           val_af = nval_af;
1456           nval_af = rectf[0];
1457           diff_af = nval_af - val_af;
1458
1459           val_bf = nval_bf;
1460           nval_bf = rectf[1];
1461           diff_bf = nval_bf - val_bf;
1462
1463           val_gf = nval_gf;
1464           nval_gf = rectf[2];
1465           diff_gf = nval_gf - val_gf;
1466
1467           val_rf = nval_rf;
1468           nval_rf = rectf[3];
1469           diff_rf = nval_rf - val_rf;
1470           rectf += skipx;
1471         }
1472       }
1473       if (do_rect) {
1474         newrect[0] = val_a + sample * diff_a;
1475         newrect[1] = val_b + sample * diff_b;
1476         newrect[2] = val_g + sample * diff_g;
1477         newrect[3] = val_r + sample * diff_r;
1478         newrect += skipx;
1479       }
1480       if (do_float) {
1481         newrectf[0] = val_af + sample * diff_af;
1482         newrectf[1] = val_bf + sample * diff_bf;
1483         newrectf[2] = val_gf + sample * diff_gf;
1484         newrectf[3] = val_rf + sample * diff_rf;
1485         newrectf += skipx;
1486       }
1487       sample += add;
1488     }
1489   }
1490
1491   if (do_rect) {
1492     imb_freerectImBuf(ibuf);
1493     ibuf->mall |= IB_rect;
1494     ibuf->rect = (unsigned int *)_newrect;
1495   }
1496   if (do_float) {
1497     imb_freerectfloatImBuf(ibuf);
1498     ibuf->mall |= IB_rectfloat;
1499     ibuf->rect_float = (float *)_newrectf;
1500   }
1501
1502   ibuf->y = newy;
1503   return (ibuf);
1504 }
1505
1506 static void scalefast_Z_ImBuf(ImBuf *ibuf, int newx, int newy)
1507 {
1508   int *zbuf, *newzbuf, *_newzbuf = NULL;
1509   float *zbuf_float, *newzbuf_float, *_newzbuf_float = NULL;
1510   int x, y;
1511   int ofsx, ofsy, stepx, stepy;
1512
1513   if (ibuf->zbuf) {
1514     _newzbuf = MEM_mallocN(newx * newy * sizeof(int), __func__);
1515     if (_newzbuf == NULL) {
1516       IMB_freezbufImBuf(ibuf);
1517     }
1518   }
1519
1520   if (ibuf->zbuf_float) {
1521     _newzbuf_float = MEM_mallocN((size_t)newx * newy * sizeof(float), __func__);
1522     if (_newzbuf_float == NULL) {
1523       IMB_freezbuffloatImBuf(ibuf);
1524     }
1525   }
1526
1527   if (!_newzbuf && !_newzbuf_float) {
1528     return;
1529   }
1530
1531   stepx = (65536.0 * (ibuf->x - 1.0) / (newx - 1.0)) + 0.5;
1532   stepy = (65536.0 * (ibuf->y - 1.0) / (newy - 1.0)) + 0.5;
1533   ofsy = 32768;
1534
1535   newzbuf = _newzbuf;
1536   newzbuf_float = _newzbuf_float;
1537
1538   for (y = newy; y > 0; y--, ofsy += stepy) {
1539     if (newzbuf) {
1540       zbuf = ibuf->zbuf;
1541       zbuf += (ofsy >> 16) * ibuf->x;
1542       ofsx = 32768;
1543       for (x = newx; x > 0; x--, ofsx += stepx) {
1544         *newzbuf++ = zbuf[ofsx >> 16];
1545       }
1546     }
1547
1548     if (newzbuf_float) {
1549       zbuf_float = ibuf->zbuf_float;
1550       zbuf_float += (ofsy >> 16) * ibuf->x;
1551       ofsx = 32768;
1552       for (x = newx; x > 0; x--, ofsx += stepx) {
1553         *newzbuf_float++ = zbuf_float[ofsx >> 16];
1554       }
1555     }
1556   }
1557
1558   if (_newzbuf) {
1559     IMB_freezbufImBuf(ibuf);
1560     ibuf->mall |= IB_zbuf;
1561     ibuf->zbuf = _newzbuf;
1562   }
1563
1564   if (_newzbuf_float) {
1565     IMB_freezbuffloatImBuf(ibuf);
1566     ibuf->mall |= IB_zbuffloat;
1567     ibuf->zbuf_float = _newzbuf_float;
1568   }
1569 }
1570
1571 /**
1572  * Return true if \a ibuf is modified.
1573  */
1574 bool IMB_scaleImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int newy)
1575 {
1576   if (ibuf == NULL)
1577     return false;
1578   if (ibuf->rect == NULL && ibuf->rect_float == NULL)
1579     return false;
1580
1581   if (newx == ibuf->x && newy == ibuf->y) {
1582     return false;
1583   }
1584
1585   /* scaleup / scaledown functions below change ibuf->x and ibuf->y
1586    * so we first scale the Z-buffer (if any) */
1587   scalefast_Z_ImBuf(ibuf, newx, newy);
1588
1589   /* try to scale common cases in a fast way */
1590   /* disabled, quality loss is unacceptable, see report #18609  (ton) */
1591   if (0 && q_scale_linear_interpolation(ibuf, newx, newy)) {
1592     return true;
1593   }
1594
1595   if (newx && (newx < ibuf->x))
1596     scaledownx(ibuf, newx);
1597   if (newy && (newy < ibuf->y))
1598     scaledowny(ibuf, newy);
1599   if (newx && (newx > ibuf->x))
1600     scaleupx(ibuf, newx);
1601   if (newy && (newy > ibuf->y))
1602     scaleupy(ibuf, newy);
1603
1604   return true;
1605 }
1606
1607 struct imbufRGBA {
1608   float r, g, b, a;
1609 };
1610
1611 /**
1612  * Return true if \a ibuf is modified.
1613  */
1614 bool IMB_scalefastImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int newy)
1615 {
1616   unsigned int *rect, *_newrect, *newrect;
1617   struct imbufRGBA *rectf, *_newrectf, *newrectf;
1618   int x, y;
1619   bool do_float = false, do_rect = false;
1620   size_t ofsx, ofsy, stepx, stepy;
1621
1622   rect = NULL;
1623   _newrect = NULL;
1624   newrect = NULL;
1625   rectf = NULL;
1626   _newrectf = NULL;
1627   newrectf = NULL;
1628
1629   if (ibuf == NULL)
1630     return false;
1631   if (ibuf->rect)
1632     do_rect = true;
1633   if (ibuf->rect_float)
1634     do_float = true;
1635   if (do_rect == false && do_float == false)
1636     return false;
1637
1638   if (newx == ibuf->x && newy == ibuf->y)
1639     return false;
1640
1641   if (do_rect) {
1642     _newrect = MEM_mallocN(newx * newy * sizeof(int), "scalefastimbuf");
1643     if (_newrect == NULL)
1644       return false;
1645     newrect = _newrect;
1646   }
1647
1648   if (do_float) {
1649     _newrectf = MEM_mallocN(newx * newy * sizeof(float) * 4, "scalefastimbuf f");
1650     if (_newrectf == NULL) {
1651       if (_newrect)
1652         MEM_freeN(_newrect);
1653       return false;
1654     }
1655     newrectf = _newrectf;
1656   }
1657
1658   stepx = (65536.0 * (ibuf->x - 1.0) / (newx - 1.0)) + 0.5;
1659   stepy = (65536.0 * (ibuf->y - 1.0) / (newy - 1.0)) + 0.5;
1660   ofsy = 32768;
1661
1662   for (y = newy; y > 0; y--, ofsy += stepy) {
1663     if (do_rect) {
1664       rect = ibuf->rect;
1665       rect += (ofsy >> 16) * ibuf->x;
1666       ofsx = 32768;
1667
1668       for (x = newx; x > 0; x--, ofsx += stepx) {
1669         *newrect++ = rect[ofsx >> 16];
1670       }
1671     }
1672
1673     if (do_float) {
1674       rectf = (struct imbufRGBA *)ibuf->rect_float;
1675       rectf += (ofsy >> 16) * ibuf->x;
1676       ofsx = 32768;
1677
1678       for (x = newx; x > 0; x--, ofsx += stepx) {
1679         *newrectf++ = rectf[ofsx >> 16];
1680       }
1681     }
1682   }
1683
1684   if (do_rect) {
1685     imb_freerectImBuf(ibuf);
1686     ibuf->mall |= IB_rect;
1687     ibuf->rect = _newrect;
1688   }
1689
1690   if (do_float) {
1691     imb_freerectfloatImBuf(ibuf);
1692     ibuf->mall |= IB_rectfloat;
1693     ibuf->rect_float = (float *)_newrectf;
1694   }
1695
1696   scalefast_Z_ImBuf(ibuf, newx, newy);
1697
1698   ibuf->x = newx;
1699   ibuf->y = newy;
1700   return true;
1701 }
1702
1703 /* ******** threaded scaling ******** */
1704
1705 typedef struct ScaleTreadInitData {
1706   ImBuf *ibuf;
1707
1708   unsigned int newx;
1709   unsigned int newy;
1710
1711   unsigned char *byte_buffer;
1712   float *float_buffer;
1713 } ScaleTreadInitData;
1714
1715 typedef struct ScaleThreadData {
1716   ImBuf *ibuf;
1717
1718   unsigned int newx;
1719   unsigned int newy;
1720
1721   int start_line;
1722   int tot_line;
1723
1724   unsigned char *byte_buffer;
1725   float *float_buffer;
1726 } ScaleThreadData;
1727
1728 static void scale_thread_init(void *data_v, int start_line, int tot_line, void *init_data_v)
1729 {
1730   ScaleThreadData *data = (ScaleThreadData *)data_v;
1731   ScaleTreadInitData *init_data = (ScaleTreadInitData *)init_data_v;
1732
1733   data->ibuf = init_data->ibuf;
1734
1735   data->newx = init_data->newx;
1736   data->newy = init_data->newy;
1737
1738   data->start_line = start_line;
1739   data->tot_line = tot_line;
1740
1741   data->byte_buffer = init_data->byte_buffer;
1742   data->float_buffer = init_data->float_buffer;
1743 }
1744
1745 static void *do_scale_thread(void *data_v)
1746 {
1747   ScaleThreadData *data = (ScaleThreadData *)data_v;
1748   ImBuf *ibuf = data->ibuf;
1749   int i;
1750   float factor_x = (float)ibuf->x / data->newx;
1751   float factor_y = (float)ibuf->y / data->newy;
1752
1753   for (i = 0; i < data->tot_line; i++) {
1754     int y = data->start_line + i;
1755     int x;
1756
1757     for (x = 0; x < data->newx; x++) {
1758       float u = (float)x * factor_x;
1759       float v = (float)y * factor_y;
1760       int offset = y * data->newx + x;
1761
1762       if (data->byte_buffer) {
1763         unsigned char *pixel = data->byte_buffer + 4 * offset;
1764         BLI_bilinear_interpolation_char(
1765             (unsigned char *)ibuf->rect, pixel, ibuf->x, ibuf->y, 4, u, v);
1766       }
1767
1768       if (data->float_buffer) {
1769         float *pixel = data->float_buffer + ibuf->channels * offset;
1770         BLI_bilinear_interpolation_fl(
1771             ibuf->rect_float, pixel, ibuf->x, ibuf->y, ibuf->channels, u, v);
1772       }
1773     }
1774   }
1775
1776   return NULL;
1777 }
1778
1779 void IMB_scaleImBuf_threaded(ImBuf *ibuf, unsigned int newx, unsigned int newy)
1780 {
1781   ScaleTreadInitData init_data = {NULL};
1782
1783   /* prepare initialization data */
1784   init_data.ibuf = ibuf;
1785
1786   init_data.newx = newx;
1787   init_data.newy = newy;
1788
1789   if (ibuf->rect)
1790     init_data.byte_buffer = MEM_mallocN(4 * newx * newy * sizeof(char),
1791                                         "threaded scale byte buffer");
1792
1793   if (ibuf->rect_float)
1794     init_data.float_buffer = MEM_mallocN(ibuf->channels * newx * newy * sizeof(float),
1795                                          "threaded scale float buffer");
1796
1797   /* actual scaling threads */
1798   IMB_processor_apply_threaded(
1799       newy, sizeof(ScaleThreadData), &init_data, scale_thread_init, do_scale_thread);
1800
1801   /* alter image buffer */
1802   ibuf->x = newx;
1803   ibuf->y = newy;
1804
1805   if (ibuf->rect) {
1806     imb_freerectImBuf(ibuf);
1807     ibuf->mall |= IB_rect;
1808     ibuf->rect = (unsigned int *)init_data.byte_buffer;
1809   }
1810
1811   if (ibuf->rect_float) {
1812     imb_freerectfloatImBuf(ibuf);
1813     ibuf->mall |= IB_rectfloat;
1814     ibuf->rect_float = init_data.float_buffer;
1815   }
1816 }