1 | // Copyright 2012 Google Inc. All Rights Reserved. |
2 | // |
3 | // Use of this source code is governed by a BSD-style license |
4 | // that can be found in the COPYING file in the root of the source |
5 | // tree. An additional intellectual property rights grant can be found |
6 | // in the file PATENTS. All contributing project authors may |
7 | // be found in the AUTHORS file in the root of the source tree. |
8 | // ----------------------------------------------------------------------------- |
9 | // |
10 | // Rescaling functions |
11 | // |
12 | // Author: Skal (pascal.massimino@gmail.com) |
13 | |
14 | #include <assert.h> |
15 | #include <limits.h> |
16 | #include <stdlib.h> |
17 | #include <string.h> |
18 | #include "src/dsp/dsp.h" |
19 | #include "src/utils/rescaler_utils.h" |
20 | #include "src/utils/utils.h" |
21 | |
22 | //------------------------------------------------------------------------------ |
23 | |
24 | int WebPRescalerInit(WebPRescaler* const rescaler, |
25 | int src_width, int src_height, |
26 | uint8_t* const dst, |
27 | int dst_width, int dst_height, int dst_stride, |
28 | int num_channels, rescaler_t* const work) { |
29 | const int x_add = src_width, x_sub = dst_width; |
30 | const int y_add = src_height, y_sub = dst_height; |
31 | const uint64_t total_size = 2ull * dst_width * num_channels * sizeof(*work); |
32 | if (!CheckSizeOverflow(total_size)) return 0; |
33 | |
34 | rescaler->x_expand = (src_width < dst_width); |
35 | rescaler->y_expand = (src_height < dst_height); |
36 | rescaler->src_width = src_width; |
37 | rescaler->src_height = src_height; |
38 | rescaler->dst_width = dst_width; |
39 | rescaler->dst_height = dst_height; |
40 | rescaler->src_y = 0; |
41 | rescaler->dst_y = 0; |
42 | rescaler->dst = dst; |
43 | rescaler->dst_stride = dst_stride; |
44 | rescaler->num_channels = num_channels; |
45 | |
46 | // for 'x_expand', we use bilinear interpolation |
47 | rescaler->x_add = rescaler->x_expand ? (x_sub - 1) : x_add; |
48 | rescaler->x_sub = rescaler->x_expand ? (x_add - 1) : x_sub; |
49 | if (!rescaler->x_expand) { // fx_scale is not used otherwise |
50 | rescaler->fx_scale = WEBP_RESCALER_FRAC(1, rescaler->x_sub); |
51 | } |
52 | // vertical scaling parameters |
53 | rescaler->y_add = rescaler->y_expand ? y_add - 1 : y_add; |
54 | rescaler->y_sub = rescaler->y_expand ? y_sub - 1 : y_sub; |
55 | rescaler->y_accum = rescaler->y_expand ? rescaler->y_sub : rescaler->y_add; |
56 | if (!rescaler->y_expand) { |
57 | // This is WEBP_RESCALER_FRAC(dst_height, x_add * y_add) without the cast. |
58 | // Its value is <= WEBP_RESCALER_ONE, because dst_height <= rescaler->y_add |
59 | // and rescaler->x_add >= 1; |
60 | const uint64_t num = (uint64_t)dst_height * WEBP_RESCALER_ONE; |
61 | const uint64_t den = (uint64_t)rescaler->x_add * rescaler->y_add; |
62 | const uint64_t ratio = num / den; |
63 | if (ratio != (uint32_t)ratio) { |
64 | // When ratio == WEBP_RESCALER_ONE, we can't represent the ratio with the |
65 | // current fixed-point precision. This happens when src_height == |
66 | // rescaler->y_add (which == src_height), and rescaler->x_add == 1. |
67 | // => We special-case fxy_scale = 0, in WebPRescalerExportRow(). |
68 | rescaler->fxy_scale = 0; |
69 | } else { |
70 | rescaler->fxy_scale = (uint32_t)ratio; |
71 | } |
72 | rescaler->fy_scale = WEBP_RESCALER_FRAC(1, rescaler->y_sub); |
73 | } else { |
74 | rescaler->fy_scale = WEBP_RESCALER_FRAC(1, rescaler->x_add); |
75 | // rescaler->fxy_scale is unused here. |
76 | } |
77 | rescaler->irow = work; |
78 | rescaler->frow = work + num_channels * dst_width; |
79 | memset(work, 0, (size_t)total_size); |
80 | |
81 | WebPRescalerDspInit(); |
82 | return 1; |
83 | } |
84 | |
85 | int WebPRescalerGetScaledDimensions(int src_width, int src_height, |
86 | int* const scaled_width, |
87 | int* const scaled_height) { |
88 | assert(scaled_width != NULL); |
89 | assert(scaled_height != NULL); |
90 | { |
91 | int width = *scaled_width; |
92 | int height = *scaled_height; |
93 | const int max_size = INT_MAX / 2; |
94 | |
95 | // if width is unspecified, scale original proportionally to height ratio. |
96 | if (width == 0 && src_height > 0) { |
97 | width = |
98 | (int)(((uint64_t)src_width * height + src_height - 1) / src_height); |
99 | } |
100 | // if height is unspecified, scale original proportionally to width ratio. |
101 | if (height == 0 && src_width > 0) { |
102 | height = |
103 | (int)(((uint64_t)src_height * width + src_width - 1) / src_width); |
104 | } |
105 | // Check if the overall dimensions still make sense. |
106 | if (width <= 0 || height <= 0 || width > max_size || height > max_size) { |
107 | return 0; |
108 | } |
109 | |
110 | *scaled_width = width; |
111 | *scaled_height = height; |
112 | return 1; |
113 | } |
114 | } |
115 | |
116 | //------------------------------------------------------------------------------ |
117 | // all-in-one calls |
118 | |
119 | int WebPRescaleNeededLines(const WebPRescaler* const rescaler, |
120 | int max_num_lines) { |
121 | const int num_lines = |
122 | (rescaler->y_accum + rescaler->y_sub - 1) / rescaler->y_sub; |
123 | return (num_lines > max_num_lines) ? max_num_lines : num_lines; |
124 | } |
125 | |
126 | int WebPRescalerImport(WebPRescaler* const rescaler, int num_lines, |
127 | const uint8_t* src, int src_stride) { |
128 | int total_imported = 0; |
129 | while (total_imported < num_lines && |
130 | !WebPRescalerHasPendingOutput(rescaler)) { |
131 | if (rescaler->y_expand) { |
132 | rescaler_t* const tmp = rescaler->irow; |
133 | rescaler->irow = rescaler->frow; |
134 | rescaler->frow = tmp; |
135 | } |
136 | WebPRescalerImportRow(rescaler, src); |
137 | if (!rescaler->y_expand) { // Accumulate the contribution of the new row. |
138 | int x; |
139 | for (x = 0; x < rescaler->num_channels * rescaler->dst_width; ++x) { |
140 | rescaler->irow[x] += rescaler->frow[x]; |
141 | } |
142 | } |
143 | ++rescaler->src_y; |
144 | src += src_stride; |
145 | ++total_imported; |
146 | rescaler->y_accum -= rescaler->y_sub; |
147 | } |
148 | return total_imported; |
149 | } |
150 | |
151 | int WebPRescalerExport(WebPRescaler* const rescaler) { |
152 | int total_exported = 0; |
153 | while (WebPRescalerHasPendingOutput(rescaler)) { |
154 | WebPRescalerExportRow(rescaler); |
155 | ++total_exported; |
156 | } |
157 | return total_exported; |
158 | } |
159 | |
160 | //------------------------------------------------------------------------------ |
161 | |