1 |
|
|
/* |
2 |
|
|
* Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com> |
3 |
|
|
* |
4 |
|
|
* This file is part of FFmpeg. |
5 |
|
|
* |
6 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
7 |
|
|
* modify it under the terms of the GNU Lesser General Public |
8 |
|
|
* License as published by the Free Software Foundation; either |
9 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
10 |
|
|
* |
11 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
12 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 |
|
|
* Lesser General Public License for more details. |
15 |
|
|
* |
16 |
|
|
* You should have received a copy of the GNU Lesser General Public |
17 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
18 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 |
|
|
*/ |
20 |
|
|
|
21 |
|
|
#include "libavutil/avassert.h" |
22 |
|
|
|
23 |
|
|
#undef avg |
24 |
|
|
#undef ss |
25 |
|
|
|
26 |
|
|
#if SS_W == 0 |
27 |
|
|
#define ss 444 |
28 |
|
|
#define avg(a,b,c,d) (a) |
29 |
|
|
#elif SS_H == 0 |
30 |
|
|
#define ss 422 |
31 |
|
|
#define avg(a,b,c,d) (((a) + (b) + 1) >> 1) |
32 |
|
|
#else |
33 |
|
|
#define ss 420 |
34 |
|
|
#define avg(a,b,c,d) (((a) + (b) + (c) + (d) + 2) >> 2) |
35 |
|
|
#endif |
36 |
|
|
|
37 |
|
|
#undef fn |
38 |
|
|
#undef fn2 |
39 |
|
|
#undef fn3 |
40 |
|
|
#define fn3(a,b,c) a##_##c##p##b##_c |
41 |
|
|
#define fn2(a,b,c) fn3(a,b,c) |
42 |
|
|
#define fn(a) fn2(a, BIT_DEPTH, ss) |
43 |
|
|
|
44 |
|
|
#undef pixel |
45 |
|
|
#undef av_clip_pixel |
46 |
|
|
#if BIT_DEPTH == 8 |
47 |
|
|
#define pixel uint8_t |
48 |
|
|
#define av_clip_pixel(x) av_clip_uint8(x) |
49 |
|
|
#else |
50 |
|
|
#define pixel uint16_t |
51 |
|
|
#define av_clip_pixel(x) av_clip_uintp2(x, BIT_DEPTH) |
52 |
|
|
#endif |
53 |
|
|
|
54 |
|
54 |
static void fn(yuv2rgb)(int16_t *rgb[3], ptrdiff_t rgb_stride, |
55 |
|
|
uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], |
56 |
|
|
int w, int h, const int16_t yuv2rgb_coeffs[3][3][8], |
57 |
|
|
const int16_t yuv_offset[8]) |
58 |
|
|
{ |
59 |
|
54 |
pixel **yuv = (pixel **) _yuv; |
60 |
|
54 |
const pixel *yuv0 = yuv[0], *yuv1 = yuv[1], *yuv2 = yuv[2]; |
61 |
|
54 |
int16_t *rgb0 = rgb[0], *rgb1 = rgb[1], *rgb2 = rgb[2]; |
62 |
|
|
int y, x; |
63 |
|
54 |
int cy = yuv2rgb_coeffs[0][0][0]; |
64 |
|
54 |
int crv = yuv2rgb_coeffs[0][2][0]; |
65 |
|
54 |
int cgu = yuv2rgb_coeffs[1][1][0]; |
66 |
|
54 |
int cgv = yuv2rgb_coeffs[1][2][0]; |
67 |
|
54 |
int cbu = yuv2rgb_coeffs[2][1][0]; |
68 |
|
54 |
const int sh = BIT_DEPTH - 1, rnd = 1 << (sh - 1); |
69 |
|
54 |
const int uv_offset = 128 << (BIT_DEPTH - 8); |
70 |
|
|
|
71 |
|
|
av_assert2(yuv2rgb_coeffs[0][1][0] == 0); |
72 |
|
|
av_assert2(yuv2rgb_coeffs[2][2][0] == 0); |
73 |
|
|
av_assert2(yuv2rgb_coeffs[1][0][0] == cy && yuv2rgb_coeffs[2][0][0] == cy); |
74 |
|
|
|
75 |
|
54 |
w = AV_CEIL_RSHIFT(w, SS_W); |
76 |
|
54 |
h = AV_CEIL_RSHIFT(h, SS_H); |
77 |
✓✓ |
2934 |
for (y = 0; y < h; y++) { |
78 |
✓✓ |
131904 |
for (x = 0; x < w; x++) { |
79 |
|
129024 |
int y00 = yuv0[x << SS_W] - yuv_offset[0]; |
80 |
|
|
#if SS_W == 1 |
81 |
|
55296 |
int y01 = yuv0[2 * x + 1] - yuv_offset[0]; |
82 |
|
|
#if SS_H == 1 |
83 |
|
18432 |
int y10 = yuv0[yuv_stride[0] / sizeof(pixel) + 2 * x] - yuv_offset[0]; |
84 |
|
18432 |
int y11 = yuv0[yuv_stride[0] / sizeof(pixel) + 2 * x + 1] - yuv_offset[0]; |
85 |
|
|
#endif |
86 |
|
|
#endif |
87 |
|
129024 |
int u = yuv1[x] - uv_offset, v = yuv2[x] - uv_offset; |
88 |
|
|
|
89 |
|
129024 |
rgb0[x << SS_W] = av_clip_int16((y00 * cy + crv * v + rnd) >> sh); |
90 |
|
|
#if SS_W == 1 |
91 |
|
55296 |
rgb0[2 * x + 1] = av_clip_int16((y01 * cy + crv * v + rnd) >> sh); |
92 |
|
|
#if SS_H == 1 |
93 |
|
18432 |
rgb0[2 * x + rgb_stride] = av_clip_int16((y10 * cy + crv * v + rnd) >> sh); |
94 |
|
18432 |
rgb0[2 * x + rgb_stride + 1] = av_clip_int16((y11 * cy + crv * v + rnd) >> sh); |
95 |
|
|
#endif |
96 |
|
|
#endif |
97 |
|
|
|
98 |
|
129024 |
rgb1[x << SS_W] = av_clip_int16((y00 * cy + cgu * u + |
99 |
|
129024 |
cgv * v + rnd) >> sh); |
100 |
|
|
#if SS_W == 1 |
101 |
|
55296 |
rgb1[2 * x + 1] = av_clip_int16((y01 * cy + cgu * u + |
102 |
|
55296 |
cgv * v + rnd) >> sh); |
103 |
|
|
#if SS_H == 1 |
104 |
|
18432 |
rgb1[2 * x + rgb_stride] = av_clip_int16((y10 * cy + cgu * u + |
105 |
|
18432 |
cgv * v + rnd) >> sh); |
106 |
|
18432 |
rgb1[2 * x + rgb_stride + 1] = av_clip_int16((y11 * cy + cgu * u + |
107 |
|
18432 |
cgv * v + rnd) >> sh); |
108 |
|
|
#endif |
109 |
|
|
#endif |
110 |
|
|
|
111 |
|
129024 |
rgb2[x << SS_W] = av_clip_int16((y00 * cy + cbu * u + rnd) >> sh); |
112 |
|
|
#if SS_W == 1 |
113 |
|
55296 |
rgb2[2 * x + 1] = av_clip_int16((y01 * cy + cbu * u + rnd) >> sh); |
114 |
|
|
#if SS_H == 1 |
115 |
|
18432 |
rgb2[2 * x + rgb_stride] = av_clip_int16((y10 * cy + cbu * u + rnd) >> sh); |
116 |
|
18432 |
rgb2[2 * x + rgb_stride + 1] = av_clip_int16((y11 * cy + cbu * u + rnd) >> sh); |
117 |
|
|
#endif |
118 |
|
|
#endif |
119 |
|
|
} |
120 |
|
|
|
121 |
|
2880 |
yuv0 += (yuv_stride[0] * (1 << SS_H)) / sizeof(pixel); |
122 |
|
2880 |
yuv1 += yuv_stride[1] / sizeof(pixel); |
123 |
|
2880 |
yuv2 += yuv_stride[2] / sizeof(pixel); |
124 |
|
2880 |
rgb0 += rgb_stride * (1 << SS_H); |
125 |
|
2880 |
rgb1 += rgb_stride * (1 << SS_H); |
126 |
|
2880 |
rgb2 += rgb_stride * (1 << SS_H); |
127 |
|
|
} |
128 |
|
54 |
} |
129 |
|
|
|
130 |
|
54 |
static void fn(rgb2yuv)(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], |
131 |
|
|
int16_t *rgb[3], ptrdiff_t s, |
132 |
|
|
int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], |
133 |
|
|
const int16_t yuv_offset[8]) |
134 |
|
|
{ |
135 |
|
54 |
pixel **yuv = (pixel **) _yuv; |
136 |
|
54 |
pixel *yuv0 = yuv[0], *yuv1 = yuv[1], *yuv2 = yuv[2]; |
137 |
|
54 |
const int16_t *rgb0 = rgb[0], *rgb1 = rgb[1], *rgb2 = rgb[2]; |
138 |
|
|
int y, x; |
139 |
|
54 |
const int sh = 29 - BIT_DEPTH; |
140 |
|
54 |
const int rnd = 1 << (sh - 1); |
141 |
|
54 |
int cry = rgb2yuv_coeffs[0][0][0]; |
142 |
|
54 |
int cgy = rgb2yuv_coeffs[0][1][0]; |
143 |
|
54 |
int cby = rgb2yuv_coeffs[0][2][0]; |
144 |
|
54 |
int cru = rgb2yuv_coeffs[1][0][0]; |
145 |
|
54 |
int cgu = rgb2yuv_coeffs[1][1][0]; |
146 |
|
54 |
int cburv = rgb2yuv_coeffs[1][2][0]; |
147 |
|
54 |
int cgv = rgb2yuv_coeffs[2][1][0]; |
148 |
|
54 |
int cbv = rgb2yuv_coeffs[2][2][0]; |
149 |
|
54 |
ptrdiff_t s0 = yuv_stride[0] / sizeof(pixel); |
150 |
|
54 |
const int uv_offset = 128 << (BIT_DEPTH - 8); |
151 |
|
|
|
152 |
|
|
av_assert2(rgb2yuv_coeffs[1][2][0] == rgb2yuv_coeffs[2][0][0]); |
153 |
|
54 |
w = AV_CEIL_RSHIFT(w, SS_W); |
154 |
|
54 |
h = AV_CEIL_RSHIFT(h, SS_H); |
155 |
✓✓ |
2934 |
for (y = 0; y < h; y++) { |
156 |
✓✓ |
131904 |
for (x = 0; x < w; x++) { |
157 |
|
129024 |
int r00 = rgb0[x << SS_W], g00 = rgb1[x << SS_W], b00 = rgb2[x << SS_W]; |
158 |
|
|
#if SS_W == 1 |
159 |
|
55296 |
int r01 = rgb0[x * 2 + 1], g01 = rgb1[x * 2 + 1], b01 = rgb2[x * 2 + 1]; |
160 |
|
|
#if SS_H == 1 |
161 |
|
18432 |
int r10 = rgb0[x * 2 + 0 + s], g10 = rgb1[x * 2 + 0 + s], b10 = rgb2[x * 2 + 0 + s]; |
162 |
|
18432 |
int r11 = rgb0[x * 2 + 1 + s], g11 = rgb1[x * 2 + 1 + s], b11 = rgb2[x * 2 + 1 + s]; |
163 |
|
|
#endif |
164 |
|
|
#endif |
165 |
|
|
|
166 |
|
129024 |
yuv0[x << SS_W] = av_clip_pixel(yuv_offset[0] + |
167 |
|
|
((r00 * cry + g00 * cgy + |
168 |
|
|
b00 * cby + rnd) >> sh)); |
169 |
|
|
#if SS_W == 1 |
170 |
|
55296 |
yuv0[x * 2 + 1] = av_clip_pixel(yuv_offset[0] + |
171 |
|
|
((r01 * cry + g01 * cgy + |
172 |
|
|
b01 * cby + rnd) >> sh)); |
173 |
|
|
#if SS_H == 1 |
174 |
|
18432 |
yuv0[x * 2 + 0 + s0] = av_clip_pixel(yuv_offset[0] + |
175 |
|
|
((r10 * cry + g10 * cgy + |
176 |
|
|
b10 * cby + rnd) >> sh)); |
177 |
|
18432 |
yuv0[x * 2 + 1 + s0] = av_clip_pixel(yuv_offset[0] + |
178 |
|
|
((r11 * cry + g11 * cgy + |
179 |
|
|
b11 * cby + rnd) >> sh)); |
180 |
|
|
#endif |
181 |
|
|
#endif |
182 |
|
|
|
183 |
|
129024 |
yuv1[x] = av_clip_pixel(uv_offset + |
184 |
|
|
((avg(r00, r01, r10, r11) * cru + |
185 |
|
|
avg(g00, g01, g10, g11) * cgu + |
186 |
|
|
avg(b00, b01, b10, b11) * cburv + rnd) >> sh)); |
187 |
|
129024 |
yuv2[x] = av_clip_pixel(uv_offset + |
188 |
|
|
((avg(r00, r01, r10, r11) * cburv + |
189 |
|
|
avg(g00, g01, g10, g11) * cgv + |
190 |
|
|
avg(b00, b01, b10, b11) * cbv + rnd) >> sh)); |
191 |
|
|
} |
192 |
|
|
|
193 |
|
2880 |
yuv0 += s0 * (1 << SS_H); |
194 |
|
2880 |
yuv1 += yuv_stride[1] / sizeof(pixel); |
195 |
|
2880 |
yuv2 += yuv_stride[2] / sizeof(pixel); |
196 |
|
2880 |
rgb0 += s * (1 << SS_H); |
197 |
|
2880 |
rgb1 += s * (1 << SS_H); |
198 |
|
2880 |
rgb2 += s * (1 << SS_H); |
199 |
|
|
} |
200 |
|
54 |
} |
201 |
|
|
|
202 |
|
|
/* floyd-steinberg dithering - for any mid-top pixel A in a 3x2 block of pixels: |
203 |
|
|
* 1 A 2 |
204 |
|
|
* 3 4 5 |
205 |
|
|
* the rounding error is distributed over the neighbouring pixels: |
206 |
|
|
* 2: 7/16th, 3: 3/16th, 4: 5/16th and 5: 1/16th |
207 |
|
|
*/ |
208 |
|
|
static void fn(rgb2yuv_fsb)(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], |
209 |
|
|
int16_t *rgb[3], ptrdiff_t s, |
210 |
|
|
int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], |
211 |
|
|
const int16_t yuv_offset[8], |
212 |
|
|
int *rnd_scratch[3][2]) |
213 |
|
|
{ |
214 |
|
|
pixel **yuv = (pixel **) _yuv; |
215 |
|
|
pixel *yuv0 = yuv[0], *yuv1 = yuv[1], *yuv2 = yuv[2]; |
216 |
|
|
const int16_t *rgb0 = rgb[0], *rgb1 = rgb[1], *rgb2 = rgb[2]; |
217 |
|
|
int y, x; |
218 |
|
|
const int sh = 29 - BIT_DEPTH; |
219 |
|
|
const int rnd = 1 << (sh - 1); |
220 |
|
|
int cry = rgb2yuv_coeffs[0][0][0]; |
221 |
|
|
int cgy = rgb2yuv_coeffs[0][1][0]; |
222 |
|
|
int cby = rgb2yuv_coeffs[0][2][0]; |
223 |
|
|
int cru = rgb2yuv_coeffs[1][0][0]; |
224 |
|
|
int cgu = rgb2yuv_coeffs[1][1][0]; |
225 |
|
|
int cburv = rgb2yuv_coeffs[1][2][0]; |
226 |
|
|
int cgv = rgb2yuv_coeffs[2][1][0]; |
227 |
|
|
int cbv = rgb2yuv_coeffs[2][2][0]; |
228 |
|
|
ptrdiff_t s0 = yuv_stride[0] / sizeof(pixel); |
229 |
|
|
const int uv_offset = 128 << (BIT_DEPTH - 8); |
230 |
|
|
unsigned mask = (1 << sh) - 1; |
231 |
|
|
|
232 |
|
|
for (x = 0; x < w; x++) { |
233 |
|
|
rnd_scratch[0][0][x] = |
234 |
|
|
rnd_scratch[0][1][x] = rnd; |
235 |
|
|
} |
236 |
|
|
av_assert2(rgb2yuv_coeffs[1][2][0] == rgb2yuv_coeffs[2][0][0]); |
237 |
|
|
w = AV_CEIL_RSHIFT(w, SS_W); |
238 |
|
|
h = AV_CEIL_RSHIFT(h, SS_H); |
239 |
|
|
for (x = 0; x < w; x++) { |
240 |
|
|
rnd_scratch[1][0][x] = |
241 |
|
|
rnd_scratch[1][1][x] = |
242 |
|
|
rnd_scratch[2][0][x] = |
243 |
|
|
rnd_scratch[2][1][x] = rnd; |
244 |
|
|
} |
245 |
|
|
for (y = 0; y < h; y++) { |
246 |
|
|
for (x = 0; x < w; x++) { |
247 |
|
|
int r00 = rgb0[x << SS_W], g00 = rgb1[x << SS_W], b00 = rgb2[x << SS_W]; |
248 |
|
|
int y00; |
249 |
|
|
#if SS_W == 1 |
250 |
|
|
int r01 = rgb0[x * 2 + 1], g01 = rgb1[x * 2 + 1], b01 = rgb2[x * 2 + 1]; |
251 |
|
|
int y01; |
252 |
|
|
#if SS_H == 1 |
253 |
|
|
int r10 = rgb0[x * 2 + 0 + s], g10 = rgb1[x * 2 + 0 + s], b10 = rgb2[x * 2 + 0 + s]; |
254 |
|
|
int r11 = rgb0[x * 2 + 1 + s], g11 = rgb1[x * 2 + 1 + s], b11 = rgb2[x * 2 + 1 + s]; |
255 |
|
|
int y10, y11; |
256 |
|
|
#endif |
257 |
|
|
#endif |
258 |
|
|
int u, v, diff; |
259 |
|
|
|
260 |
|
|
y00 = r00 * cry + g00 * cgy + b00 * cby + rnd_scratch[0][y & !SS_H][x << SS_W]; |
261 |
|
|
diff = (y00 & mask) - rnd; |
262 |
|
|
yuv0[x << SS_W] = av_clip_pixel(yuv_offset[0] + (y00 >> sh)); |
263 |
|
|
rnd_scratch[0][ (y & !SS_H)][(x << SS_W) + 1] += (diff * 7 + 8) >> 4; |
264 |
|
|
rnd_scratch[0][!(y & !SS_H)][(x << SS_W) - 1] += (diff * 3 + 8) >> 4; |
265 |
|
|
rnd_scratch[0][!(y & !SS_H)][(x << SS_W) + 0] += (diff * 5 + 8) >> 4; |
266 |
|
|
rnd_scratch[0][!(y & !SS_H)][(x << SS_W) + 1] += (diff * 1 + 8) >> 4; |
267 |
|
|
rnd_scratch[0][ (y & !SS_H)][(x << SS_W) + 0] = rnd; |
268 |
|
|
#if SS_W == 1 |
269 |
|
|
y01 = r01 * cry + g01 * cgy + b01 * cby + rnd_scratch[0][y & !SS_H][x * 2 + 1]; |
270 |
|
|
diff = (y01 & mask) - rnd; |
271 |
|
|
yuv0[x * 2 + 1] = av_clip_pixel(yuv_offset[0] + (y01 >> sh)); |
272 |
|
|
rnd_scratch[0][ (y & !SS_H)][x * 2 + 2] += (diff * 7 + 8) >> 4; |
273 |
|
|
rnd_scratch[0][!(y & !SS_H)][x * 2 + 0] += (diff * 3 + 8) >> 4; |
274 |
|
|
rnd_scratch[0][!(y & !SS_H)][x * 2 + 1] += (diff * 5 + 8) >> 4; |
275 |
|
|
rnd_scratch[0][!(y & !SS_H)][x * 2 + 2] += (diff * 1 + 8) >> 4; |
276 |
|
|
rnd_scratch[0][ (y & !SS_H)][x * 2 + 1] = rnd; |
277 |
|
|
#if SS_H == 1 |
278 |
|
|
y10 = r10 * cry + g10 * cgy + b10 * cby + rnd_scratch[0][1][x * 2 + 0]; |
279 |
|
|
diff = (y10 & mask) - rnd; |
280 |
|
|
yuv0[x * 2 + 0 + s0] = av_clip_pixel(yuv_offset[0] + (y10 >> sh)); |
281 |
|
|
rnd_scratch[0][1][x * 2 + 1] += (diff * 7 + 8) >> 4; |
282 |
|
|
rnd_scratch[0][0][x * 2 - 1] += (diff * 3 + 8) >> 4; |
283 |
|
|
rnd_scratch[0][0][x * 2 + 0] += (diff * 5 + 8) >> 4; |
284 |
|
|
rnd_scratch[0][0][x * 2 + 1] += (diff * 1 + 8) >> 4; |
285 |
|
|
rnd_scratch[0][1][x * 2 + 0] = rnd; |
286 |
|
|
|
287 |
|
|
y11 = r11 * cry + g11 * cgy + b11 * cby + rnd_scratch[0][1][x * 2 + 1]; |
288 |
|
|
diff = (y11 & mask) - rnd; |
289 |
|
|
yuv0[x * 2 + 1 + s0] = av_clip_pixel(yuv_offset[0] + (y11 >> sh)); |
290 |
|
|
rnd_scratch[0][1][x * 2 + 2] += (diff * 7 + 8) >> 4; |
291 |
|
|
rnd_scratch[0][0][x * 2 + 0] += (diff * 3 + 8) >> 4; |
292 |
|
|
rnd_scratch[0][0][x * 2 + 1] += (diff * 5 + 8) >> 4; |
293 |
|
|
rnd_scratch[0][0][x * 2 + 2] += (diff * 1 + 8) >> 4; |
294 |
|
|
rnd_scratch[0][1][x * 2 + 1] = rnd; |
295 |
|
|
#endif |
296 |
|
|
#endif |
297 |
|
|
|
298 |
|
|
u = avg(r00, r01, r10, r11) * cru + |
299 |
|
|
avg(g00, g01, g10, g11) * cgu + |
300 |
|
|
avg(b00, b01, b10, b11) * cburv + rnd_scratch[1][y & 1][x]; |
301 |
|
|
diff = (u & mask) - rnd; |
302 |
|
|
yuv1[x] = av_clip_pixel(uv_offset + (u >> sh)); |
303 |
|
|
rnd_scratch[1][ (y & 1)][x + 1] += (diff * 7 + 8) >> 4; |
304 |
|
|
rnd_scratch[1][!(y & 1)][x - 1] += (diff * 3 + 8) >> 4; |
305 |
|
|
rnd_scratch[1][!(y & 1)][x + 0] += (diff * 5 + 8) >> 4; |
306 |
|
|
rnd_scratch[1][!(y & 1)][x + 1] += (diff * 1 + 8) >> 4; |
307 |
|
|
rnd_scratch[1][ (y & 1)][x + 0] = rnd; |
308 |
|
|
|
309 |
|
|
v = avg(r00, r01, r10, r11) * cburv + |
310 |
|
|
avg(g00, g01, g10, g11) * cgv + |
311 |
|
|
avg(b00, b01, b10, b11) * cbv + rnd_scratch[2][y & 1][x]; |
312 |
|
|
diff = (v & mask) - rnd; |
313 |
|
|
yuv2[x] = av_clip_pixel(uv_offset + (v >> sh)); |
314 |
|
|
rnd_scratch[2][ (y & 1)][x + 1] += (diff * 7 + 8) >> 4; |
315 |
|
|
rnd_scratch[2][!(y & 1)][x - 1] += (diff * 3 + 8) >> 4; |
316 |
|
|
rnd_scratch[2][!(y & 1)][x + 0] += (diff * 5 + 8) >> 4; |
317 |
|
|
rnd_scratch[2][!(y & 1)][x + 1] += (diff * 1 + 8) >> 4; |
318 |
|
|
rnd_scratch[2][ (y & 1)][x + 0] = rnd; |
319 |
|
|
} |
320 |
|
|
|
321 |
|
|
yuv0 += s0 * (1 << SS_H); |
322 |
|
|
yuv1 += yuv_stride[1] / sizeof(pixel); |
323 |
|
|
yuv2 += yuv_stride[2] / sizeof(pixel); |
324 |
|
|
rgb0 += s * (1 << SS_H); |
325 |
|
|
rgb1 += s * (1 << SS_H); |
326 |
|
|
rgb2 += s * (1 << SS_H); |
327 |
|
|
} |
328 |
|
|
} |
329 |
|
|
|
330 |
|
|
#undef IN_BIT_DEPTH |
331 |
|
|
#undef OUT_BIT_DEPTH |
332 |
|
|
#define OUT_BIT_DEPTH BIT_DEPTH |
333 |
|
|
#define IN_BIT_DEPTH 8 |
334 |
|
|
#include "colorspacedsp_yuv2yuv_template.c" |
335 |
|
|
|
336 |
|
|
#undef IN_BIT_DEPTH |
337 |
|
|
#define IN_BIT_DEPTH 10 |
338 |
|
|
#include "colorspacedsp_yuv2yuv_template.c" |
339 |
|
|
|
340 |
|
|
#undef IN_BIT_DEPTH |
341 |
|
|
#define IN_BIT_DEPTH 12 |
342 |
|
|
#include "colorspacedsp_yuv2yuv_template.c" |