GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/colorspacedsp_template.c Lines: 80 171 46.8 %
Date: 2020-08-13 15:06:06 Branches: 8 16 50.0 %

Line Branch Exec Source
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"