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
24int 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
85int 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
119int 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
126int 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
151int 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