Coverage Report

Created: 2026-09-14 08:00

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/ffmpeg/libavcodec/h26x/h2656_inter_template.c
Line
Count
Source
1
/*
2
 * inter prediction template for HEVC/VVC
3
 *
4
 * Copyright (C) 2022 Nuo Mi
5
 * Copyright (C) 2024 Wu Jianhua
6
 *
7
 * This file is part of FFmpeg.
8
 *
9
 * FFmpeg is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU Lesser General Public
11
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23
24
30.5M
#define CHROMA_EXTRA_BEFORE     1
25
155M
#define CHROMA_EXTRA            3
26
35.4M
#define LUMA_EXTRA_BEFORE       3
27
244M
#define LUMA_EXTRA              7
28
29
static void FUNC(put_pixels)(int16_t *dst,
30
    const uint8_t *_src, const ptrdiff_t _src_stride,
31
    const int height, const int8_t *hf, const int8_t *vf, const int width)
32
27.2M
{
33
27.2M
    const pixel *src            = (const pixel *)_src;
34
27.2M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
227M
    for (int y = 0; y < height; y++) {
37
3.73G
        for (int x = 0; x < width; x++)
38
3.53G
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
200M
        src += src_stride;
40
200M
        dst += MAX_PB_SIZE;
41
200M
    }
42
27.2M
}
dsp.c:put_pixels_9
Line
Count
Source
32
492k
{
33
492k
    const pixel *src            = (const pixel *)_src;
34
492k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
10.6M
    for (int y = 0; y < height; y++) {
37
221M
        for (int x = 0; x < width; x++)
38
211M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
10.1M
        src += src_stride;
40
10.1M
        dst += MAX_PB_SIZE;
41
10.1M
    }
42
492k
}
dsp.c:put_pixels_10
Line
Count
Source
32
9.56M
{
33
9.56M
    const pixel *src            = (const pixel *)_src;
34
9.56M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
65.7M
    for (int y = 0; y < height; y++) {
37
1.04G
        for (int x = 0; x < width; x++)
38
983M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
56.2M
        src += src_stride;
40
56.2M
        dst += MAX_PB_SIZE;
41
56.2M
    }
42
9.56M
}
dsp.c:put_pixels_12
Line
Count
Source
32
1.95M
{
33
1.95M
    const pixel *src            = (const pixel *)_src;
34
1.95M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
22.0M
    for (int y = 0; y < height; y++) {
37
373M
        for (int x = 0; x < width; x++)
38
353M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
20.0M
        src += src_stride;
40
20.0M
        dst += MAX_PB_SIZE;
41
20.0M
    }
42
1.95M
}
dsp.c:put_pixels_8
Line
Count
Source
32
1.87M
{
33
1.87M
    const pixel *src            = (const pixel *)_src;
34
1.87M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
20.6M
    for (int y = 0; y < height; y++) {
37
342M
        for (int x = 0; x < width; x++)
38
323M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
18.7M
        src += src_stride;
40
18.7M
        dst += MAX_PB_SIZE;
41
18.7M
    }
42
1.87M
}
dsp.c:put_pixels_12
Line
Count
Source
32
1.95M
{
33
1.95M
    const pixel *src            = (const pixel *)_src;
34
1.95M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
22.0M
    for (int y = 0; y < height; y++) {
37
373M
        for (int x = 0; x < width; x++)
38
353M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
20.0M
        src += src_stride;
40
20.0M
        dst += MAX_PB_SIZE;
41
20.0M
    }
42
1.95M
}
dsp.c:put_pixels_10
Line
Count
Source
32
9.56M
{
33
9.56M
    const pixel *src            = (const pixel *)_src;
34
9.56M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
65.7M
    for (int y = 0; y < height; y++) {
37
1.04G
        for (int x = 0; x < width; x++)
38
983M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
56.2M
        src += src_stride;
40
56.2M
        dst += MAX_PB_SIZE;
41
56.2M
    }
42
9.56M
}
dsp.c:put_pixels_8
Line
Count
Source
32
1.87M
{
33
1.87M
    const pixel *src            = (const pixel *)_src;
34
1.87M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
35
36
20.6M
    for (int y = 0; y < height; y++) {
37
342M
        for (int x = 0; x < width; x++)
38
323M
            dst[x] = src[x] << (14 - BIT_DEPTH);
39
18.7M
        src += src_stride;
40
18.7M
        dst += MAX_PB_SIZE;
41
18.7M
    }
42
1.87M
}
43
44
static void FUNC(put_uni_pixels)(uint8_t *_dst, const ptrdiff_t _dst_stride,
45
    const uint8_t *_src, const ptrdiff_t _src_stride, const int height,
46
     const int8_t *hf, const int8_t *vf, const int width)
47
4.27M
{
48
4.27M
    const pixel *src            = (const pixel *)_src;
49
4.27M
    pixel *dst                  = (pixel *)_dst;
50
4.27M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
51
4.27M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
52
53
30.3M
    for (int y = 0; y < height; y++) {
54
26.1M
        memcpy(dst, src, width * sizeof(pixel));
55
26.1M
        src += src_stride;
56
26.1M
        dst += dst_stride;
57
26.1M
    }
58
4.27M
}
dsp.c:put_uni_pixels_9
Line
Count
Source
47
166k
{
48
166k
    const pixel *src            = (const pixel *)_src;
49
166k
    pixel *dst                  = (pixel *)_dst;
50
166k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
51
166k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
52
53
1.40M
    for (int y = 0; y < height; y++) {
54
1.24M
        memcpy(dst, src, width * sizeof(pixel));
55
1.24M
        src += src_stride;
56
1.24M
        dst += dst_stride;
57
1.24M
    }
58
166k
}
dsp.c:put_uni_pixels_10
Line
Count
Source
47
2.35M
{
48
2.35M
    const pixel *src            = (const pixel *)_src;
49
2.35M
    pixel *dst                  = (pixel *)_dst;
50
2.35M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
51
2.35M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
52
53
14.5M
    for (int y = 0; y < height; y++) {
54
12.2M
        memcpy(dst, src, width * sizeof(pixel));
55
12.2M
        src += src_stride;
56
12.2M
        dst += dst_stride;
57
12.2M
    }
58
2.35M
}
dsp.c:put_uni_pixels_12
Line
Count
Source
47
895k
{
48
895k
    const pixel *src            = (const pixel *)_src;
49
895k
    pixel *dst                  = (pixel *)_dst;
50
895k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
51
895k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
52
53
7.77M
    for (int y = 0; y < height; y++) {
54
6.88M
        memcpy(dst, src, width * sizeof(pixel));
55
6.88M
        src += src_stride;
56
6.88M
        dst += dst_stride;
57
6.88M
    }
58
895k
}
dsp.c:put_uni_pixels_8
Line
Count
Source
47
863k
{
48
863k
    const pixel *src            = (const pixel *)_src;
49
863k
    pixel *dst                  = (pixel *)_dst;
50
863k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
51
863k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
52
53
6.61M
    for (int y = 0; y < height; y++) {
54
5.74M
        memcpy(dst, src, width * sizeof(pixel));
55
5.74M
        src += src_stride;
56
5.74M
        dst += dst_stride;
57
5.74M
    }
58
863k
}
59
60
static void FUNC(put_uni_w_pixels)(uint8_t *_dst, const ptrdiff_t _dst_stride,
61
    const uint8_t *_src, const ptrdiff_t _src_stride, const int height,
62
    const int denom, const int wx, const int _ox,  const int8_t *hf, const int8_t *vf,
63
    const int width)
64
4.80M
{
65
4.80M
    const pixel *src            = (const pixel *)_src;
66
4.80M
    pixel *dst                  = (pixel *)_dst;
67
4.80M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
4.80M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
4.80M
    const int shift             = denom + 14 - BIT_DEPTH;
70
4.80M
#if BIT_DEPTH < 14
71
4.80M
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
4.80M
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
38.0M
    for (int y = 0; y < height; y++) {
78
398M
        for (int x = 0; x < width; x++) {
79
364M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
364M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
364M
        }
82
33.2M
        src += src_stride;
83
33.2M
        dst += dst_stride;
84
33.2M
    }
85
4.80M
}
dsp.c:put_uni_w_pixels_9
Line
Count
Source
64
110k
{
65
110k
    const pixel *src            = (const pixel *)_src;
66
110k
    pixel *dst                  = (pixel *)_dst;
67
110k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
110k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
110k
    const int shift             = denom + 14 - BIT_DEPTH;
70
110k
#if BIT_DEPTH < 14
71
110k
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
110k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
1.45M
    for (int y = 0; y < height; y++) {
78
25.2M
        for (int x = 0; x < width; x++) {
79
23.8M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
23.8M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
23.8M
        }
82
1.34M
        src += src_stride;
83
1.34M
        dst += dst_stride;
84
1.34M
    }
85
110k
}
dsp.c:put_uni_w_pixels_10
Line
Count
Source
64
1.75M
{
65
1.75M
    const pixel *src            = (const pixel *)_src;
66
1.75M
    pixel *dst                  = (pixel *)_dst;
67
1.75M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
1.75M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
1.75M
    const int shift             = denom + 14 - BIT_DEPTH;
70
1.75M
#if BIT_DEPTH < 14
71
1.75M
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
1.75M
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
13.3M
    for (int y = 0; y < height; y++) {
78
126M
        for (int x = 0; x < width; x++) {
79
114M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
114M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
114M
        }
82
11.6M
        src += src_stride;
83
11.6M
        dst += dst_stride;
84
11.6M
    }
85
1.75M
}
dsp.c:put_uni_w_pixels_12
Line
Count
Source
64
349k
{
65
349k
    const pixel *src            = (const pixel *)_src;
66
349k
    pixel *dst                  = (pixel *)_dst;
67
349k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
349k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
349k
    const int shift             = denom + 14 - BIT_DEPTH;
70
349k
#if BIT_DEPTH < 14
71
349k
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
349k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
3.01M
    for (int y = 0; y < height; y++) {
78
37.5M
        for (int x = 0; x < width; x++) {
79
34.8M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
34.8M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
34.8M
        }
82
2.66M
        src += src_stride;
83
2.66M
        dst += dst_stride;
84
2.66M
    }
85
349k
}
dsp.c:put_uni_w_pixels_8
Line
Count
Source
64
244k
{
65
244k
    const pixel *src            = (const pixel *)_src;
66
244k
    pixel *dst                  = (pixel *)_dst;
67
244k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
244k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
244k
    const int shift             = denom + 14 - BIT_DEPTH;
70
244k
#if BIT_DEPTH < 14
71
244k
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
244k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
1.89M
    for (int y = 0; y < height; y++) {
78
22.5M
        for (int x = 0; x < width; x++) {
79
20.9M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
20.9M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
20.9M
        }
82
1.65M
        src += src_stride;
83
1.65M
        dst += dst_stride;
84
1.65M
    }
85
244k
}
dsp.c:put_uni_w_pixels_12
Line
Count
Source
64
349k
{
65
349k
    const pixel *src            = (const pixel *)_src;
66
349k
    pixel *dst                  = (pixel *)_dst;
67
349k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
349k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
349k
    const int shift             = denom + 14 - BIT_DEPTH;
70
349k
#if BIT_DEPTH < 14
71
349k
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
349k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
3.01M
    for (int y = 0; y < height; y++) {
78
37.5M
        for (int x = 0; x < width; x++) {
79
34.8M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
34.8M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
34.8M
        }
82
2.66M
        src += src_stride;
83
2.66M
        dst += dst_stride;
84
2.66M
    }
85
349k
}
dsp.c:put_uni_w_pixels_10
Line
Count
Source
64
1.75M
{
65
1.75M
    const pixel *src            = (const pixel *)_src;
66
1.75M
    pixel *dst                  = (pixel *)_dst;
67
1.75M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
1.75M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
1.75M
    const int shift             = denom + 14 - BIT_DEPTH;
70
1.75M
#if BIT_DEPTH < 14
71
1.75M
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
1.75M
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
13.3M
    for (int y = 0; y < height; y++) {
78
126M
        for (int x = 0; x < width; x++) {
79
114M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
114M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
114M
        }
82
11.6M
        src += src_stride;
83
11.6M
        dst += dst_stride;
84
11.6M
    }
85
1.75M
}
dsp.c:put_uni_w_pixels_8
Line
Count
Source
64
244k
{
65
244k
    const pixel *src            = (const pixel *)_src;
66
244k
    pixel *dst                  = (pixel *)_dst;
67
244k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
68
244k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
69
244k
    const int shift             = denom + 14 - BIT_DEPTH;
70
244k
#if BIT_DEPTH < 14
71
244k
    const int offset            = 1 << (shift - 1);
72
#else
73
    const int offset            = 0;
74
#endif
75
244k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
76
77
1.89M
    for (int y = 0; y < height; y++) {
78
22.5M
        for (int x = 0; x < width; x++) {
79
20.9M
            const int v = (src[x] << (14 - BIT_DEPTH));
80
20.9M
            dst[x] = av_clip_pixel(((v * wx + offset) >> shift) + ox);
81
20.9M
        }
82
1.65M
        src += src_stride;
83
1.65M
        dst += dst_stride;
84
1.65M
    }
85
244k
}
86
87
#define LUMA_FILTER(src, stride)                                               \
88
4.44G
    (filter[0] * src[x - 3 * stride] +                                         \
89
4.44G
     filter[1] * src[x - 2 * stride] +                                         \
90
4.44G
     filter[2] * src[x -     stride] +                                         \
91
4.44G
     filter[3] * src[x             ] +                                         \
92
4.44G
     filter[4] * src[x +     stride] +                                         \
93
4.44G
     filter[5] * src[x + 2 * stride] +                                         \
94
4.44G
     filter[6] * src[x + 3 * stride] +                                         \
95
4.44G
     filter[7] * src[x + 4 * stride])
96
97
static void FUNC(put_luma_h)(int16_t *dst, const uint8_t *_src, const ptrdiff_t _src_stride,
98
    const int height, const int8_t *hf, const int8_t *vf, const int width)
99
2.09M
{
100
2.09M
    const pixel *src           = (const pixel*)_src;
101
2.09M
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
2.09M
    const int8_t *filter       = hf;
103
104
15.3M
    for (int y = 0; y < height; y++) {
105
253M
        for (int x = 0; x < width; x++)
106
240M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
13.2M
        src += src_stride;
108
13.2M
        dst += MAX_PB_SIZE;
109
13.2M
    }
110
2.09M
}
dsp.c:put_luma_h_9
Line
Count
Source
99
26.1k
{
100
26.1k
    const pixel *src           = (const pixel*)_src;
101
26.1k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
26.1k
    const int8_t *filter       = hf;
103
104
477k
    for (int y = 0; y < height; y++) {
105
12.0M
        for (int x = 0; x < width; x++)
106
11.5M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
450k
        src += src_stride;
108
450k
        dst += MAX_PB_SIZE;
109
450k
    }
110
26.1k
}
dsp.c:put_luma_h_10
Line
Count
Source
99
903k
{
100
903k
    const pixel *src           = (const pixel*)_src;
101
903k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
903k
    const int8_t *filter       = hf;
103
104
5.43M
    for (int y = 0; y < height; y++) {
105
73.8M
        for (int x = 0; x < width; x++)
106
69.3M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
4.53M
        src += src_stride;
108
4.53M
        dst += MAX_PB_SIZE;
109
4.53M
    }
110
903k
}
dsp.c:put_luma_h_12
Line
Count
Source
99
67.9k
{
100
67.9k
    const pixel *src           = (const pixel*)_src;
101
67.9k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
67.9k
    const int8_t *filter       = hf;
103
104
944k
    for (int y = 0; y < height; y++) {
105
20.5M
        for (int x = 0; x < width; x++)
106
19.6M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
876k
        src += src_stride;
108
876k
        dst += MAX_PB_SIZE;
109
876k
    }
110
67.9k
}
dsp.c:put_luma_h_8
Line
Count
Source
99
63.9k
{
100
63.9k
    const pixel *src           = (const pixel*)_src;
101
63.9k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
63.9k
    const int8_t *filter       = hf;
103
104
1.07M
    for (int y = 0; y < height; y++) {
105
26.4M
        for (int x = 0; x < width; x++)
106
25.4M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
1.01M
        src += src_stride;
108
1.01M
        dst += MAX_PB_SIZE;
109
1.01M
    }
110
63.9k
}
dsp.c:put_luma_h_12
Line
Count
Source
99
67.9k
{
100
67.9k
    const pixel *src           = (const pixel*)_src;
101
67.9k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
67.9k
    const int8_t *filter       = hf;
103
104
944k
    for (int y = 0; y < height; y++) {
105
20.5M
        for (int x = 0; x < width; x++)
106
19.6M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
876k
        src += src_stride;
108
876k
        dst += MAX_PB_SIZE;
109
876k
    }
110
67.9k
}
dsp.c:put_luma_h_10
Line
Count
Source
99
903k
{
100
903k
    const pixel *src           = (const pixel*)_src;
101
903k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
903k
    const int8_t *filter       = hf;
103
104
5.43M
    for (int y = 0; y < height; y++) {
105
73.8M
        for (int x = 0; x < width; x++)
106
69.3M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
4.53M
        src += src_stride;
108
4.53M
        dst += MAX_PB_SIZE;
109
4.53M
    }
110
903k
}
dsp.c:put_luma_h_8
Line
Count
Source
99
63.9k
{
100
63.9k
    const pixel *src           = (const pixel*)_src;
101
63.9k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
102
63.9k
    const int8_t *filter       = hf;
103
104
1.07M
    for (int y = 0; y < height; y++) {
105
26.4M
        for (int x = 0; x < width; x++)
106
25.4M
            dst[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
107
1.01M
        src += src_stride;
108
1.01M
        dst += MAX_PB_SIZE;
109
1.01M
    }
110
63.9k
}
111
112
static void FUNC(put_luma_v)(int16_t *dst, const uint8_t *_src, const ptrdiff_t _src_stride,
113
    const int height, const int8_t *hf, const int8_t *vf, const int width)
114
2.41M
{
115
2.41M
    const pixel *src           = (pixel*)_src;
116
2.41M
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
2.41M
    const int8_t *filter       = vf;
118
119
18.0M
    for (int y = 0; y < height; y++)  {
120
427M
        for (int x = 0; x < width; x++)
121
411M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
15.6M
        src += src_stride;
123
15.6M
        dst += MAX_PB_SIZE;
124
15.6M
    }
125
2.41M
}
dsp.c:put_luma_v_9
Line
Count
Source
114
29.2k
{
115
29.2k
    const pixel *src           = (pixel*)_src;
116
29.2k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
29.2k
    const int8_t *filter       = vf;
118
119
708k
    for (int y = 0; y < height; y++)  {
120
21.5M
        for (int x = 0; x < width; x++)
121
20.9M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
678k
        src += src_stride;
123
678k
        dst += MAX_PB_SIZE;
124
678k
    }
125
29.2k
}
dsp.c:put_luma_v_10
Line
Count
Source
114
1.09M
{
115
1.09M
    const pixel *src           = (pixel*)_src;
116
1.09M
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
1.09M
    const int8_t *filter       = vf;
118
119
6.95M
    for (int y = 0; y < height; y++)  {
120
159M
        for (int x = 0; x < width; x++)
121
153M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
5.86M
        src += src_stride;
123
5.86M
        dst += MAX_PB_SIZE;
124
5.86M
    }
125
1.09M
}
dsp.c:put_luma_v_12
Line
Count
Source
114
51.2k
{
115
51.2k
    const pixel *src           = (pixel*)_src;
116
51.2k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
51.2k
    const int8_t *filter       = vf;
118
119
814k
    for (int y = 0; y < height; y++)  {
120
20.6M
        for (int x = 0; x < width; x++)
121
19.9M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
763k
        src += src_stride;
123
763k
        dst += MAX_PB_SIZE;
124
763k
    }
125
51.2k
}
dsp.c:put_luma_v_8
Line
Count
Source
114
51.3k
{
115
51.3k
    const pixel *src           = (pixel*)_src;
116
51.3k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
51.3k
    const int8_t *filter       = vf;
118
119
904k
    for (int y = 0; y < height; y++)  {
120
22.6M
        for (int x = 0; x < width; x++)
121
21.7M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
852k
        src += src_stride;
123
852k
        dst += MAX_PB_SIZE;
124
852k
    }
125
51.3k
}
dsp.c:put_luma_v_12
Line
Count
Source
114
51.2k
{
115
51.2k
    const pixel *src           = (pixel*)_src;
116
51.2k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
51.2k
    const int8_t *filter       = vf;
118
119
814k
    for (int y = 0; y < height; y++)  {
120
20.6M
        for (int x = 0; x < width; x++)
121
19.9M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
763k
        src += src_stride;
123
763k
        dst += MAX_PB_SIZE;
124
763k
    }
125
51.2k
}
dsp.c:put_luma_v_10
Line
Count
Source
114
1.09M
{
115
1.09M
    const pixel *src           = (pixel*)_src;
116
1.09M
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
1.09M
    const int8_t *filter       = vf;
118
119
6.95M
    for (int y = 0; y < height; y++)  {
120
159M
        for (int x = 0; x < width; x++)
121
153M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
5.86M
        src += src_stride;
123
5.86M
        dst += MAX_PB_SIZE;
124
5.86M
    }
125
1.09M
}
dsp.c:put_luma_v_8
Line
Count
Source
114
51.3k
{
115
51.3k
    const pixel *src           = (pixel*)_src;
116
51.3k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
117
51.3k
    const int8_t *filter       = vf;
118
119
904k
    for (int y = 0; y < height; y++)  {
120
22.6M
        for (int x = 0; x < width; x++)
121
21.7M
            dst[x] = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
122
852k
        src += src_stride;
123
852k
        dst += MAX_PB_SIZE;
124
852k
    }
125
51.3k
}
126
127
static void FUNC(put_luma_hv)(int16_t *dst, const uint8_t *_src, const ptrdiff_t _src_stride,
128
    const int height, const int8_t *hf, const int8_t *vf, const int width)
129
14.1M
{
130
14.1M
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
14.1M
    int16_t *tmp                = tmp_array;
132
14.1M
    const pixel *src            = (const pixel*)_src;
133
14.1M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
14.1M
    const int8_t *filter        = hf;
135
136
14.1M
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
184M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
1.56G
        for (int x = 0; x < width; x++)
139
1.39G
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
170M
        src += src_stride;
141
170M
        tmp += MAX_PB_SIZE;
142
170M
    }
143
144
14.1M
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
14.1M
    filter = vf;
146
84.9M
    for (int y = 0; y < height; y++) {
147
967M
        for (int x = 0; x < width; x++)
148
896M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
70.7M
        tmp += MAX_PB_SIZE;
150
70.7M
        dst += MAX_PB_SIZE;
151
70.7M
    }
152
14.1M
}
dsp.c:put_luma_hv_9
Line
Count
Source
129
69.7k
{
130
69.7k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
69.7k
    int16_t *tmp                = tmp_array;
132
69.7k
    const pixel *src            = (const pixel*)_src;
133
69.7k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
69.7k
    const int8_t *filter        = hf;
135
136
69.7k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
2.07M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
57.0M
        for (int x = 0; x < width; x++)
139
55.0M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
2.00M
        src += src_stride;
141
2.00M
        tmp += MAX_PB_SIZE;
142
2.00M
    }
143
144
69.7k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
69.7k
    filter = vf;
146
1.58M
    for (int y = 0; y < height; y++) {
147
45.4M
        for (int x = 0; x < width; x++)
148
43.9M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
1.51M
        tmp += MAX_PB_SIZE;
150
1.51M
        dst += MAX_PB_SIZE;
151
1.51M
    }
152
69.7k
}
dsp.c:put_luma_hv_10
Line
Count
Source
129
6.74M
{
130
6.74M
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
6.74M
    int16_t *tmp                = tmp_array;
132
6.74M
    const pixel *src            = (const pixel*)_src;
133
6.74M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
6.74M
    const int8_t *filter        = hf;
135
136
6.74M
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
83.9M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
608M
        for (int x = 0; x < width; x++)
139
531M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
77.2M
        src += src_stride;
141
77.2M
        tmp += MAX_PB_SIZE;
142
77.2M
    }
143
144
6.74M
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
6.74M
    filter = vf;
146
36.7M
    for (int y = 0; y < height; y++) {
147
348M
        for (int x = 0; x < width; x++)
148
318M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
29.9M
        tmp += MAX_PB_SIZE;
150
29.9M
        dst += MAX_PB_SIZE;
151
29.9M
    }
152
6.74M
}
dsp.c:put_luma_hv_12
Line
Count
Source
129
148k
{
130
148k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
148k
    int16_t *tmp                = tmp_array;
132
148k
    const pixel *src            = (const pixel*)_src;
133
148k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
148k
    const int8_t *filter        = hf;
135
136
148k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
3.30M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
69.9M
        for (int x = 0; x < width; x++)
139
66.8M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
3.15M
        src += src_stride;
141
3.15M
        tmp += MAX_PB_SIZE;
142
3.15M
    }
143
144
148k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
148k
    filter = vf;
146
2.27M
    for (int y = 0; y < height; y++) {
147
54.6M
        for (int x = 0; x < width; x++)
148
52.5M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
2.12M
        tmp += MAX_PB_SIZE;
150
2.12M
        dst += MAX_PB_SIZE;
151
2.12M
    }
152
148k
}
dsp.c:put_luma_hv_8
Line
Count
Source
129
171k
{
130
171k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
171k
    int16_t *tmp                = tmp_array;
132
171k
    const pixel *src            = (const pixel*)_src;
133
171k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
171k
    const int8_t *filter        = hf;
135
136
171k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
3.90M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
76.0M
        for (int x = 0; x < width; x++)
139
72.2M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
3.73M
        src += src_stride;
141
3.73M
        tmp += MAX_PB_SIZE;
142
3.73M
    }
143
144
171k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
171k
    filter = vf;
146
2.70M
    for (int y = 0; y < height; y++) {
147
57.5M
        for (int x = 0; x < width; x++)
148
55.0M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
2.53M
        tmp += MAX_PB_SIZE;
150
2.53M
        dst += MAX_PB_SIZE;
151
2.53M
    }
152
171k
}
dsp.c:put_luma_hv_12
Line
Count
Source
129
148k
{
130
148k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
148k
    int16_t *tmp                = tmp_array;
132
148k
    const pixel *src            = (const pixel*)_src;
133
148k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
148k
    const int8_t *filter        = hf;
135
136
148k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
3.30M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
69.9M
        for (int x = 0; x < width; x++)
139
66.8M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
3.15M
        src += src_stride;
141
3.15M
        tmp += MAX_PB_SIZE;
142
3.15M
    }
143
144
148k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
148k
    filter = vf;
146
2.27M
    for (int y = 0; y < height; y++) {
147
54.6M
        for (int x = 0; x < width; x++)
148
52.5M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
2.12M
        tmp += MAX_PB_SIZE;
150
2.12M
        dst += MAX_PB_SIZE;
151
2.12M
    }
152
148k
}
dsp.c:put_luma_hv_10
Line
Count
Source
129
6.74M
{
130
6.74M
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
6.74M
    int16_t *tmp                = tmp_array;
132
6.74M
    const pixel *src            = (const pixel*)_src;
133
6.74M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
6.74M
    const int8_t *filter        = hf;
135
136
6.74M
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
83.9M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
608M
        for (int x = 0; x < width; x++)
139
531M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
77.2M
        src += src_stride;
141
77.2M
        tmp += MAX_PB_SIZE;
142
77.2M
    }
143
144
6.74M
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
6.74M
    filter = vf;
146
36.7M
    for (int y = 0; y < height; y++) {
147
348M
        for (int x = 0; x < width; x++)
148
318M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
29.9M
        tmp += MAX_PB_SIZE;
150
29.9M
        dst += MAX_PB_SIZE;
151
29.9M
    }
152
6.74M
}
dsp.c:put_luma_hv_8
Line
Count
Source
129
171k
{
130
171k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
131
171k
    int16_t *tmp                = tmp_array;
132
171k
    const pixel *src            = (const pixel*)_src;
133
171k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
134
171k
    const int8_t *filter        = hf;
135
136
171k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
137
3.90M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
138
76.0M
        for (int x = 0; x < width; x++)
139
72.2M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
140
3.73M
        src += src_stride;
141
3.73M
        tmp += MAX_PB_SIZE;
142
3.73M
    }
143
144
171k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
145
171k
    filter = vf;
146
2.70M
    for (int y = 0; y < height; y++) {
147
57.5M
        for (int x = 0; x < width; x++)
148
55.0M
            dst[x] = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
149
2.53M
        tmp += MAX_PB_SIZE;
150
2.53M
        dst += MAX_PB_SIZE;
151
2.53M
    }
152
171k
}
153
154
static void FUNC(put_uni_luma_h)(uint8_t *_dst,  const ptrdiff_t _dst_stride,
155
    const uint8_t *_src, const ptrdiff_t _src_stride,
156
    const int height, const int8_t *hf, const int8_t *vf, const int width)
157
1.00M
{
158
1.00M
    const pixel *src           = (const pixel*)_src;
159
1.00M
    pixel *dst                 = (pixel *)_dst;
160
1.00M
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
1.00M
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
1.00M
    const int8_t *filter       = hf;
163
1.00M
    const int shift            = 14 - BIT_DEPTH;
164
1.00M
#if BIT_DEPTH < 14
165
1.00M
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
10.5M
    for (int y = 0; y < height; y++) {
171
184M
        for (int x = 0; x < width; x++) {
172
174M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
174M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
174M
        }
175
9.54M
        src   += src_stride;
176
9.54M
        dst   += dst_stride;
177
9.54M
    }
178
1.00M
}
dsp.c:put_uni_luma_h_9
Line
Count
Source
157
19.9k
{
158
19.9k
    const pixel *src           = (const pixel*)_src;
159
19.9k
    pixel *dst                 = (pixel *)_dst;
160
19.9k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
19.9k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
19.9k
    const int8_t *filter       = hf;
163
19.9k
    const int shift            = 14 - BIT_DEPTH;
164
19.9k
#if BIT_DEPTH < 14
165
19.9k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
261k
    for (int y = 0; y < height; y++) {
171
5.30M
        for (int x = 0; x < width; x++) {
172
5.06M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
5.06M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
5.06M
        }
175
242k
        src   += src_stride;
176
242k
        dst   += dst_stride;
177
242k
    }
178
19.9k
}
dsp.c:put_uni_luma_h_10
Line
Count
Source
157
260k
{
158
260k
    const pixel *src           = (const pixel*)_src;
159
260k
    pixel *dst                 = (pixel *)_dst;
160
260k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
260k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
260k
    const int8_t *filter       = hf;
163
260k
    const int shift            = 14 - BIT_DEPTH;
164
260k
#if BIT_DEPTH < 14
165
260k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
2.25M
    for (int y = 0; y < height; y++) {
171
37.8M
        for (int x = 0; x < width; x++) {
172
35.8M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
35.8M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
35.8M
        }
175
1.99M
        src   += src_stride;
176
1.99M
        dst   += dst_stride;
177
1.99M
    }
178
260k
}
dsp.c:put_uni_luma_h_12
Line
Count
Source
157
73.3k
{
158
73.3k
    const pixel *src           = (const pixel*)_src;
159
73.3k
    pixel *dst                 = (pixel *)_dst;
160
73.3k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
73.3k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
73.3k
    const int8_t *filter       = hf;
163
73.3k
    const int shift            = 14 - BIT_DEPTH;
164
73.3k
#if BIT_DEPTH < 14
165
73.3k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
913k
    for (int y = 0; y < height; y++) {
171
16.6M
        for (int x = 0; x < width; x++) {
172
15.8M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
15.8M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
15.8M
        }
175
840k
        src   += src_stride;
176
840k
        dst   += dst_stride;
177
840k
    }
178
73.3k
}
dsp.c:put_uni_luma_h_8
Line
Count
Source
157
159k
{
158
159k
    const pixel *src           = (const pixel*)_src;
159
159k
    pixel *dst                 = (pixel *)_dst;
160
159k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
159k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
159k
    const int8_t *filter       = hf;
163
159k
    const int shift            = 14 - BIT_DEPTH;
164
159k
#if BIT_DEPTH < 14
165
159k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
1.97M
    for (int y = 0; y < height; y++) {
171
34.9M
        for (int x = 0; x < width; x++) {
172
33.0M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
33.0M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
33.0M
        }
175
1.81M
        src   += src_stride;
176
1.81M
        dst   += dst_stride;
177
1.81M
    }
178
159k
}
dsp.c:put_uni_luma_h_12
Line
Count
Source
157
73.3k
{
158
73.3k
    const pixel *src           = (const pixel*)_src;
159
73.3k
    pixel *dst                 = (pixel *)_dst;
160
73.3k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
73.3k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
73.3k
    const int8_t *filter       = hf;
163
73.3k
    const int shift            = 14 - BIT_DEPTH;
164
73.3k
#if BIT_DEPTH < 14
165
73.3k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
913k
    for (int y = 0; y < height; y++) {
171
16.6M
        for (int x = 0; x < width; x++) {
172
15.8M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
15.8M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
15.8M
        }
175
840k
        src   += src_stride;
176
840k
        dst   += dst_stride;
177
840k
    }
178
73.3k
}
dsp.c:put_uni_luma_h_10
Line
Count
Source
157
260k
{
158
260k
    const pixel *src           = (const pixel*)_src;
159
260k
    pixel *dst                 = (pixel *)_dst;
160
260k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
260k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
260k
    const int8_t *filter       = hf;
163
260k
    const int shift            = 14 - BIT_DEPTH;
164
260k
#if BIT_DEPTH < 14
165
260k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
2.25M
    for (int y = 0; y < height; y++) {
171
37.8M
        for (int x = 0; x < width; x++) {
172
35.8M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
35.8M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
35.8M
        }
175
1.99M
        src   += src_stride;
176
1.99M
        dst   += dst_stride;
177
1.99M
    }
178
260k
}
dsp.c:put_uni_luma_h_8
Line
Count
Source
157
159k
{
158
159k
    const pixel *src           = (const pixel*)_src;
159
159k
    pixel *dst                 = (pixel *)_dst;
160
159k
    const ptrdiff_t src_stride = _src_stride / sizeof(pixel);
161
159k
    const ptrdiff_t dst_stride = _dst_stride / sizeof(pixel);
162
159k
    const int8_t *filter       = hf;
163
159k
    const int shift            = 14 - BIT_DEPTH;
164
159k
#if BIT_DEPTH < 14
165
159k
    const int offset           = 1 << (shift - 1);
166
#else
167
    const int offset           = 0;
168
#endif
169
170
1.97M
    for (int y = 0; y < height; y++) {
171
34.9M
        for (int x = 0; x < width; x++) {
172
33.0M
            const int val = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
173
33.0M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
174
33.0M
        }
175
1.81M
        src   += src_stride;
176
1.81M
        dst   += dst_stride;
177
1.81M
    }
178
159k
}
179
180
static void FUNC(put_uni_luma_v)(uint8_t *_dst,  const ptrdiff_t _dst_stride,
181
    const uint8_t *_src, const ptrdiff_t _src_stride,
182
    const int height, const int8_t *hf, const int8_t *vf, const int width)
183
1.34M
{
184
185
1.34M
    const pixel *src            = (const pixel*)_src;
186
1.34M
    pixel *dst                  = (pixel *)_dst;
187
1.34M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
1.34M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
1.34M
    const int8_t *filter        = vf;
190
1.34M
    const int shift             = 14 - BIT_DEPTH;
191
1.34M
#if BIT_DEPTH < 14
192
1.34M
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
11.3M
    for (int y = 0; y < height; y++) {
198
157M
        for (int x = 0; x < width; x++) {
199
147M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
147M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
147M
        }
202
10.0M
        src   += src_stride;
203
10.0M
        dst   += dst_stride;
204
10.0M
    }
205
1.34M
}
dsp.c:put_uni_luma_v_9
Line
Count
Source
183
19.4k
{
184
185
19.4k
    const pixel *src            = (const pixel*)_src;
186
19.4k
    pixel *dst                  = (pixel *)_dst;
187
19.4k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
19.4k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
19.4k
    const int8_t *filter        = vf;
190
19.4k
    const int shift             = 14 - BIT_DEPTH;
191
19.4k
#if BIT_DEPTH < 14
192
19.4k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
225k
    for (int y = 0; y < height; y++) {
198
4.24M
        for (int x = 0; x < width; x++) {
199
4.04M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
4.04M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
4.04M
        }
202
206k
        src   += src_stride;
203
206k
        dst   += dst_stride;
204
206k
    }
205
19.4k
}
dsp.c:put_uni_luma_v_10
Line
Count
Source
183
453k
{
184
185
453k
    const pixel *src            = (const pixel*)_src;
186
453k
    pixel *dst                  = (pixel *)_dst;
187
453k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
453k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
453k
    const int8_t *filter        = vf;
190
453k
    const int shift             = 14 - BIT_DEPTH;
191
453k
#if BIT_DEPTH < 14
192
453k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
3.28M
    for (int y = 0; y < height; y++) {
198
42.7M
        for (int x = 0; x < width; x++) {
199
39.9M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
39.9M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
39.9M
        }
202
2.82M
        src   += src_stride;
203
2.82M
        dst   += dst_stride;
204
2.82M
    }
205
453k
}
dsp.c:put_uni_luma_v_12
Line
Count
Source
183
66.3k
{
184
185
66.3k
    const pixel *src            = (const pixel*)_src;
186
66.3k
    pixel *dst                  = (pixel *)_dst;
187
66.3k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
66.3k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
66.3k
    const int8_t *filter        = vf;
190
66.3k
    const int shift             = 14 - BIT_DEPTH;
191
66.3k
#if BIT_DEPTH < 14
192
66.3k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
671k
    for (int y = 0; y < height; y++) {
198
8.93M
        for (int x = 0; x < width; x++) {
199
8.32M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
8.32M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
8.32M
        }
202
605k
        src   += src_stride;
203
605k
        dst   += dst_stride;
204
605k
    }
205
66.3k
}
dsp.c:put_uni_luma_v_8
Line
Count
Source
183
141k
{
184
185
141k
    const pixel *src            = (const pixel*)_src;
186
141k
    pixel *dst                  = (pixel *)_dst;
187
141k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
141k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
141k
    const int8_t *filter        = vf;
190
141k
    const int shift             = 14 - BIT_DEPTH;
191
141k
#if BIT_DEPTH < 14
192
141k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
1.61M
    for (int y = 0; y < height; y++) {
198
25.0M
        for (int x = 0; x < width; x++) {
199
23.5M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
23.5M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
23.5M
        }
202
1.47M
        src   += src_stride;
203
1.47M
        dst   += dst_stride;
204
1.47M
    }
205
141k
}
dsp.c:put_uni_luma_v_12
Line
Count
Source
183
66.3k
{
184
185
66.3k
    const pixel *src            = (const pixel*)_src;
186
66.3k
    pixel *dst                  = (pixel *)_dst;
187
66.3k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
66.3k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
66.3k
    const int8_t *filter        = vf;
190
66.3k
    const int shift             = 14 - BIT_DEPTH;
191
66.3k
#if BIT_DEPTH < 14
192
66.3k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
671k
    for (int y = 0; y < height; y++) {
198
8.93M
        for (int x = 0; x < width; x++) {
199
8.32M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
8.32M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
8.32M
        }
202
605k
        src   += src_stride;
203
605k
        dst   += dst_stride;
204
605k
    }
205
66.3k
}
dsp.c:put_uni_luma_v_10
Line
Count
Source
183
453k
{
184
185
453k
    const pixel *src            = (const pixel*)_src;
186
453k
    pixel *dst                  = (pixel *)_dst;
187
453k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
453k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
453k
    const int8_t *filter        = vf;
190
453k
    const int shift             = 14 - BIT_DEPTH;
191
453k
#if BIT_DEPTH < 14
192
453k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
3.28M
    for (int y = 0; y < height; y++) {
198
42.7M
        for (int x = 0; x < width; x++) {
199
39.9M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
39.9M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
39.9M
        }
202
2.82M
        src   += src_stride;
203
2.82M
        dst   += dst_stride;
204
2.82M
    }
205
453k
}
dsp.c:put_uni_luma_v_8
Line
Count
Source
183
141k
{
184
185
141k
    const pixel *src            = (const pixel*)_src;
186
141k
    pixel *dst                  = (pixel *)_dst;
187
141k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
188
141k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
189
141k
    const int8_t *filter        = vf;
190
141k
    const int shift             = 14 - BIT_DEPTH;
191
141k
#if BIT_DEPTH < 14
192
141k
    const int offset            = 1 << (shift - 1);
193
#else
194
    const int offset            = 0;
195
#endif
196
197
1.61M
    for (int y = 0; y < height; y++) {
198
25.0M
        for (int x = 0; x < width; x++) {
199
23.5M
            const int val = LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
200
23.5M
            dst[x]        = av_clip_pixel((val + offset) >> shift);
201
23.5M
        }
202
1.47M
        src   += src_stride;
203
1.47M
        dst   += dst_stride;
204
1.47M
    }
205
141k
}
206
207
static void FUNC(put_uni_luma_hv)(uint8_t *_dst, const ptrdiff_t _dst_stride,
208
    const uint8_t *_src, const ptrdiff_t _src_stride,
209
    const int height, const int8_t *hf, const int8_t *vf, const int width)
210
3.00M
{
211
3.00M
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
3.00M
    int16_t *tmp                = tmp_array;
213
3.00M
    const pixel *src            = (const pixel*)_src;
214
3.00M
    pixel *dst                  = (pixel *)_dst;
215
3.00M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
3.00M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
3.00M
    const int8_t *filter        = hf;
218
3.00M
    const int shift             =  14 - BIT_DEPTH;
219
3.00M
#if BIT_DEPTH < 14
220
3.00M
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
3.00M
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
49.4M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
643M
        for (int x = 0; x < width; x++)
228
597M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
46.4M
        src += src_stride;
230
46.4M
        tmp += MAX_PB_SIZE;
231
46.4M
    }
232
233
3.00M
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
3.00M
    filter = vf;
235
236
28.4M
    for (int y = 0; y < height; y++) {
237
443M
        for (int x = 0; x < width; x++) {
238
417M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
417M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
417M
        }
241
25.4M
        tmp += MAX_PB_SIZE;
242
25.4M
        dst += dst_stride;
243
25.4M
    }
244
245
3.00M
}
dsp.c:put_uni_luma_hv_9
Line
Count
Source
210
43.3k
{
211
43.3k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
43.3k
    int16_t *tmp                = tmp_array;
213
43.3k
    const pixel *src            = (const pixel*)_src;
214
43.3k
    pixel *dst                  = (pixel *)_dst;
215
43.3k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
43.3k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
43.3k
    const int8_t *filter        = hf;
218
43.3k
    const int shift             =  14 - BIT_DEPTH;
219
43.3k
#if BIT_DEPTH < 14
220
43.3k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
43.3k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
825k
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
13.5M
        for (int x = 0; x < width; x++)
228
12.7M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
782k
        src += src_stride;
230
782k
        tmp += MAX_PB_SIZE;
231
782k
    }
232
233
43.3k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
43.3k
    filter = vf;
235
236
522k
    for (int y = 0; y < height; y++) {
237
9.63M
        for (int x = 0; x < width; x++) {
238
9.15M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
9.15M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
9.15M
        }
241
478k
        tmp += MAX_PB_SIZE;
242
478k
        dst += dst_stride;
243
478k
    }
244
245
43.3k
}
dsp.c:put_uni_luma_hv_10
Line
Count
Source
210
887k
{
211
887k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
887k
    int16_t *tmp                = tmp_array;
213
887k
    const pixel *src            = (const pixel*)_src;
214
887k
    pixel *dst                  = (pixel *)_dst;
215
887k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
887k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
887k
    const int8_t *filter        = hf;
218
887k
    const int shift             =  14 - BIT_DEPTH;
219
887k
#if BIT_DEPTH < 14
220
887k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
887k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
13.4M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
171M
        for (int x = 0; x < width; x++)
228
159M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
12.5M
        src += src_stride;
230
12.5M
        tmp += MAX_PB_SIZE;
231
12.5M
    }
232
233
887k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
887k
    filter = vf;
235
236
7.26M
    for (int y = 0; y < height; y++) {
237
116M
        for (int x = 0; x < width; x++) {
238
110M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
110M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
110M
        }
241
6.37M
        tmp += MAX_PB_SIZE;
242
6.37M
        dst += dst_stride;
243
6.37M
    }
244
245
887k
}
dsp.c:put_uni_luma_hv_12
Line
Count
Source
210
232k
{
211
232k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
232k
    int16_t *tmp                = tmp_array;
213
232k
    const pixel *src            = (const pixel*)_src;
214
232k
    pixel *dst                  = (pixel *)_dst;
215
232k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
232k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
232k
    const int8_t *filter        = hf;
218
232k
    const int shift             =  14 - BIT_DEPTH;
219
232k
#if BIT_DEPTH < 14
220
232k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
232k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
4.07M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
46.7M
        for (int x = 0; x < width; x++)
228
42.9M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
3.83M
        src += src_stride;
230
3.83M
        tmp += MAX_PB_SIZE;
231
3.83M
    }
232
233
232k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
232k
    filter = vf;
235
236
2.43M
    for (int y = 0; y < height; y++) {
237
32.0M
        for (int x = 0; x < width; x++) {
238
29.8M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
29.8M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
29.8M
        }
241
2.20M
        tmp += MAX_PB_SIZE;
242
2.20M
        dst += dst_stride;
243
2.20M
    }
244
245
232k
}
dsp.c:put_uni_luma_hv_8
Line
Count
Source
210
359k
{
211
359k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
359k
    int16_t *tmp                = tmp_array;
213
359k
    const pixel *src            = (const pixel*)_src;
214
359k
    pixel *dst                  = (pixel *)_dst;
215
359k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
359k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
359k
    const int8_t *filter        = hf;
218
359k
    const int shift             =  14 - BIT_DEPTH;
219
359k
#if BIT_DEPTH < 14
220
359k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
359k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
6.78M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
96.6M
        for (int x = 0; x < width; x++)
228
90.2M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
6.42M
        src += src_stride;
230
6.42M
        tmp += MAX_PB_SIZE;
231
6.42M
    }
232
233
359k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
359k
    filter = vf;
235
236
4.27M
    for (int y = 0; y < height; y++) {
237
68.3M
        for (int x = 0; x < width; x++) {
238
64.4M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
64.4M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
64.4M
        }
241
3.91M
        tmp += MAX_PB_SIZE;
242
3.91M
        dst += dst_stride;
243
3.91M
    }
244
245
359k
}
dsp.c:put_uni_luma_hv_12
Line
Count
Source
210
232k
{
211
232k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
232k
    int16_t *tmp                = tmp_array;
213
232k
    const pixel *src            = (const pixel*)_src;
214
232k
    pixel *dst                  = (pixel *)_dst;
215
232k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
232k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
232k
    const int8_t *filter        = hf;
218
232k
    const int shift             =  14 - BIT_DEPTH;
219
232k
#if BIT_DEPTH < 14
220
232k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
232k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
4.07M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
46.7M
        for (int x = 0; x < width; x++)
228
42.9M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
3.83M
        src += src_stride;
230
3.83M
        tmp += MAX_PB_SIZE;
231
3.83M
    }
232
233
232k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
232k
    filter = vf;
235
236
2.43M
    for (int y = 0; y < height; y++) {
237
32.0M
        for (int x = 0; x < width; x++) {
238
29.8M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
29.8M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
29.8M
        }
241
2.20M
        tmp += MAX_PB_SIZE;
242
2.20M
        dst += dst_stride;
243
2.20M
    }
244
245
232k
}
dsp.c:put_uni_luma_hv_10
Line
Count
Source
210
887k
{
211
887k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
887k
    int16_t *tmp                = tmp_array;
213
887k
    const pixel *src            = (const pixel*)_src;
214
887k
    pixel *dst                  = (pixel *)_dst;
215
887k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
887k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
887k
    const int8_t *filter        = hf;
218
887k
    const int shift             =  14 - BIT_DEPTH;
219
887k
#if BIT_DEPTH < 14
220
887k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
887k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
13.4M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
171M
        for (int x = 0; x < width; x++)
228
159M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
12.5M
        src += src_stride;
230
12.5M
        tmp += MAX_PB_SIZE;
231
12.5M
    }
232
233
887k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
887k
    filter = vf;
235
236
7.26M
    for (int y = 0; y < height; y++) {
237
116M
        for (int x = 0; x < width; x++) {
238
110M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
110M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
110M
        }
241
6.37M
        tmp += MAX_PB_SIZE;
242
6.37M
        dst += dst_stride;
243
6.37M
    }
244
245
887k
}
dsp.c:put_uni_luma_hv_8
Line
Count
Source
210
359k
{
211
359k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
212
359k
    int16_t *tmp                = tmp_array;
213
359k
    const pixel *src            = (const pixel*)_src;
214
359k
    pixel *dst                  = (pixel *)_dst;
215
359k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
216
359k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
217
359k
    const int8_t *filter        = hf;
218
359k
    const int shift             =  14 - BIT_DEPTH;
219
359k
#if BIT_DEPTH < 14
220
359k
    const int offset            = 1 << (shift - 1);
221
#else
222
    const int offset            = 0;
223
#endif
224
225
359k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
226
6.78M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
227
96.6M
        for (int x = 0; x < width; x++)
228
90.2M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
229
6.42M
        src += src_stride;
230
6.42M
        tmp += MAX_PB_SIZE;
231
6.42M
    }
232
233
359k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
234
359k
    filter = vf;
235
236
4.27M
    for (int y = 0; y < height; y++) {
237
68.3M
        for (int x = 0; x < width; x++) {
238
64.4M
            const int val = LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
239
64.4M
            dst[x]  = av_clip_pixel((val  + offset) >> shift);
240
64.4M
        }
241
3.91M
        tmp += MAX_PB_SIZE;
242
3.91M
        dst += dst_stride;
243
3.91M
    }
244
245
359k
}
246
247
static void FUNC(put_uni_luma_w_h)(uint8_t *_dst,  const ptrdiff_t _dst_stride,
248
    const uint8_t *_src, const ptrdiff_t _src_stride, int height,
249
    const int denom, const int wx, const int _ox, const int8_t *hf, const int8_t *vf,
250
    const int width)
251
204k
{
252
204k
    const pixel *src            = (const pixel*)_src;
253
204k
    pixel *dst                  = (pixel *)_dst;
254
204k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
204k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
204k
    const int8_t *filter        = hf;
257
204k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
204k
    const int shift             = denom + 14 - BIT_DEPTH;
259
204k
#if BIT_DEPTH < 14
260
204k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
2.50M
    for (int y = 0; y < height; y++) {
266
44.4M
        for (int x = 0; x < width; x++)
267
42.1M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
2.29M
        src += src_stride;
269
2.29M
        dst += dst_stride;
270
2.29M
    }
271
204k
}
dsp.c:put_uni_luma_w_h_9
Line
Count
Source
251
13.1k
{
252
13.1k
    const pixel *src            = (const pixel*)_src;
253
13.1k
    pixel *dst                  = (pixel *)_dst;
254
13.1k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
13.1k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
13.1k
    const int8_t *filter        = hf;
257
13.1k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
13.1k
    const int shift             = denom + 14 - BIT_DEPTH;
259
13.1k
#if BIT_DEPTH < 14
260
13.1k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
235k
    for (int y = 0; y < height; y++) {
266
5.68M
        for (int x = 0; x < width; x++)
267
5.46M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
222k
        src += src_stride;
269
222k
        dst += dst_stride;
270
222k
    }
271
13.1k
}
dsp.c:put_uni_luma_w_h_10
Line
Count
Source
251
28.2k
{
252
28.2k
    const pixel *src            = (const pixel*)_src;
253
28.2k
    pixel *dst                  = (pixel *)_dst;
254
28.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
28.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
28.2k
    const int8_t *filter        = hf;
257
28.2k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
28.2k
    const int shift             = denom + 14 - BIT_DEPTH;
259
28.2k
#if BIT_DEPTH < 14
260
28.2k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
345k
    for (int y = 0; y < height; y++) {
266
6.33M
        for (int x = 0; x < width; x++)
267
6.02M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
316k
        src += src_stride;
269
316k
        dst += dst_stride;
270
316k
    }
271
28.2k
}
dsp.c:put_uni_luma_w_h_12
Line
Count
Source
251
32.5k
{
252
32.5k
    const pixel *src            = (const pixel*)_src;
253
32.5k
    pixel *dst                  = (pixel *)_dst;
254
32.5k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
32.5k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
32.5k
    const int8_t *filter        = hf;
257
32.5k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
32.5k
    const int shift             = denom + 14 - BIT_DEPTH;
259
32.5k
#if BIT_DEPTH < 14
260
32.5k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
407k
    for (int y = 0; y < height; y++) {
266
7.57M
        for (int x = 0; x < width; x++)
267
7.20M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
374k
        src += src_stride;
269
374k
        dst += dst_stride;
270
374k
    }
271
32.5k
}
dsp.c:put_uni_luma_w_h_8
Line
Count
Source
251
34.7k
{
252
34.7k
    const pixel *src            = (const pixel*)_src;
253
34.7k
    pixel *dst                  = (pixel *)_dst;
254
34.7k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
34.7k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
34.7k
    const int8_t *filter        = hf;
257
34.7k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
34.7k
    const int shift             = denom + 14 - BIT_DEPTH;
259
34.7k
#if BIT_DEPTH < 14
260
34.7k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
381k
    for (int y = 0; y < height; y++) {
266
5.48M
        for (int x = 0; x < width; x++)
267
5.13M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
346k
        src += src_stride;
269
346k
        dst += dst_stride;
270
346k
    }
271
34.7k
}
dsp.c:put_uni_luma_w_h_12
Line
Count
Source
251
32.5k
{
252
32.5k
    const pixel *src            = (const pixel*)_src;
253
32.5k
    pixel *dst                  = (pixel *)_dst;
254
32.5k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
32.5k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
32.5k
    const int8_t *filter        = hf;
257
32.5k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
32.5k
    const int shift             = denom + 14 - BIT_DEPTH;
259
32.5k
#if BIT_DEPTH < 14
260
32.5k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
407k
    for (int y = 0; y < height; y++) {
266
7.57M
        for (int x = 0; x < width; x++)
267
7.20M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
374k
        src += src_stride;
269
374k
        dst += dst_stride;
270
374k
    }
271
32.5k
}
dsp.c:put_uni_luma_w_h_10
Line
Count
Source
251
28.2k
{
252
28.2k
    const pixel *src            = (const pixel*)_src;
253
28.2k
    pixel *dst                  = (pixel *)_dst;
254
28.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
28.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
28.2k
    const int8_t *filter        = hf;
257
28.2k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
28.2k
    const int shift             = denom + 14 - BIT_DEPTH;
259
28.2k
#if BIT_DEPTH < 14
260
28.2k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
345k
    for (int y = 0; y < height; y++) {
266
6.33M
        for (int x = 0; x < width; x++)
267
6.02M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
316k
        src += src_stride;
269
316k
        dst += dst_stride;
270
316k
    }
271
28.2k
}
dsp.c:put_uni_luma_w_h_8
Line
Count
Source
251
34.7k
{
252
34.7k
    const pixel *src            = (const pixel*)_src;
253
34.7k
    pixel *dst                  = (pixel *)_dst;
254
34.7k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
255
34.7k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
256
34.7k
    const int8_t *filter        = hf;
257
34.7k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
258
34.7k
    const int shift             = denom + 14 - BIT_DEPTH;
259
34.7k
#if BIT_DEPTH < 14
260
34.7k
    const int offset            = 1 << (shift - 1);
261
#else
262
    const int offset            = 0;
263
#endif
264
265
381k
    for (int y = 0; y < height; y++) {
266
5.48M
        for (int x = 0; x < width; x++)
267
5.13M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
268
346k
        src += src_stride;
269
346k
        dst += dst_stride;
270
346k
    }
271
34.7k
}
272
273
static void FUNC(put_uni_luma_w_v)(uint8_t *_dst,  const ptrdiff_t _dst_stride,
274
    const uint8_t *_src, const ptrdiff_t _src_stride, const int height,
275
    const int denom, const int wx, const int _ox, const int8_t *hf, const int8_t *vf,
276
    const int width)
277
195k
{
278
195k
    const pixel *src            = (const pixel*)_src;
279
195k
    pixel *dst                  = (pixel *)_dst;
280
195k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
195k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
195k
    const int8_t *filter        = vf;
283
195k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
195k
    const int shift             = denom + 14 - BIT_DEPTH;
285
195k
#if BIT_DEPTH < 14
286
195k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
2.55M
    for (int y = 0; y < height; y++) {
292
49.6M
        for (int x = 0; x < width; x++)
293
47.3M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
2.36M
        src += src_stride;
295
2.36M
        dst += dst_stride;
296
2.36M
    }
297
195k
}
dsp.c:put_uni_luma_w_v_9
Line
Count
Source
277
18.2k
{
278
18.2k
    const pixel *src            = (const pixel*)_src;
279
18.2k
    pixel *dst                  = (pixel *)_dst;
280
18.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
18.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
18.2k
    const int8_t *filter        = vf;
283
18.2k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
18.2k
    const int shift             = denom + 14 - BIT_DEPTH;
285
18.2k
#if BIT_DEPTH < 14
286
18.2k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
259k
    for (int y = 0; y < height; y++) {
292
5.30M
        for (int x = 0; x < width; x++)
293
5.06M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
241k
        src += src_stride;
295
241k
        dst += dst_stride;
296
241k
    }
297
18.2k
}
dsp.c:put_uni_luma_w_v_10
Line
Count
Source
277
31.4k
{
278
31.4k
    const pixel *src            = (const pixel*)_src;
279
31.4k
    pixel *dst                  = (pixel *)_dst;
280
31.4k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
31.4k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
31.4k
    const int8_t *filter        = vf;
283
31.4k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
31.4k
    const int shift             = denom + 14 - BIT_DEPTH;
285
31.4k
#if BIT_DEPTH < 14
286
31.4k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
406k
    for (int y = 0; y < height; y++) {
292
8.15M
        for (int x = 0; x < width; x++)
293
7.78M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
374k
        src += src_stride;
295
374k
        dst += dst_stride;
296
374k
    }
297
31.4k
}
dsp.c:put_uni_luma_w_v_12
Line
Count
Source
277
26.1k
{
278
26.1k
    const pixel *src            = (const pixel*)_src;
279
26.1k
    pixel *dst                  = (pixel *)_dst;
280
26.1k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
26.1k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
26.1k
    const int8_t *filter        = vf;
283
26.1k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
26.1k
    const int shift             = denom + 14 - BIT_DEPTH;
285
26.1k
#if BIT_DEPTH < 14
286
26.1k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
372k
    for (int y = 0; y < height; y++) {
292
7.91M
        for (int x = 0; x < width; x++)
293
7.57M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
345k
        src += src_stride;
295
345k
        dst += dst_stride;
296
345k
    }
297
26.1k
}
dsp.c:put_uni_luma_w_v_8
Line
Count
Source
277
31.0k
{
278
31.0k
    const pixel *src            = (const pixel*)_src;
279
31.0k
    pixel *dst                  = (pixel *)_dst;
280
31.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
31.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
31.0k
    const int8_t *filter        = vf;
283
31.0k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
31.0k
    const int shift             = denom + 14 - BIT_DEPTH;
285
31.0k
#if BIT_DEPTH < 14
286
31.0k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
371k
    for (int y = 0; y < height; y++) {
292
6.11M
        for (int x = 0; x < width; x++)
293
5.76M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
340k
        src += src_stride;
295
340k
        dst += dst_stride;
296
340k
    }
297
31.0k
}
dsp.c:put_uni_luma_w_v_12
Line
Count
Source
277
26.1k
{
278
26.1k
    const pixel *src            = (const pixel*)_src;
279
26.1k
    pixel *dst                  = (pixel *)_dst;
280
26.1k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
26.1k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
26.1k
    const int8_t *filter        = vf;
283
26.1k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
26.1k
    const int shift             = denom + 14 - BIT_DEPTH;
285
26.1k
#if BIT_DEPTH < 14
286
26.1k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
372k
    for (int y = 0; y < height; y++) {
292
7.91M
        for (int x = 0; x < width; x++)
293
7.57M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
345k
        src += src_stride;
295
345k
        dst += dst_stride;
296
345k
    }
297
26.1k
}
dsp.c:put_uni_luma_w_v_10
Line
Count
Source
277
31.4k
{
278
31.4k
    const pixel *src            = (const pixel*)_src;
279
31.4k
    pixel *dst                  = (pixel *)_dst;
280
31.4k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
31.4k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
31.4k
    const int8_t *filter        = vf;
283
31.4k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
31.4k
    const int shift             = denom + 14 - BIT_DEPTH;
285
31.4k
#if BIT_DEPTH < 14
286
31.4k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
406k
    for (int y = 0; y < height; y++) {
292
8.15M
        for (int x = 0; x < width; x++)
293
7.78M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
374k
        src += src_stride;
295
374k
        dst += dst_stride;
296
374k
    }
297
31.4k
}
dsp.c:put_uni_luma_w_v_8
Line
Count
Source
277
31.0k
{
278
31.0k
    const pixel *src            = (const pixel*)_src;
279
31.0k
    pixel *dst                  = (pixel *)_dst;
280
31.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
281
31.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
282
31.0k
    const int8_t *filter        = vf;
283
31.0k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
284
31.0k
    const int shift             = denom + 14 - BIT_DEPTH;
285
31.0k
#if BIT_DEPTH < 14
286
31.0k
    const int offset            = 1 << (shift - 1);
287
#else
288
    const int offset            = 0;
289
#endif
290
291
371k
    for (int y = 0; y < height; y++) {
292
6.11M
        for (int x = 0; x < width; x++)
293
5.76M
            dst[x] = av_clip_pixel((((LUMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
294
340k
        src += src_stride;
295
340k
        dst += dst_stride;
296
340k
    }
297
31.0k
}
298
299
static void FUNC(put_uni_luma_w_hv)(uint8_t *_dst,  const ptrdiff_t _dst_stride,
300
    const uint8_t *_src, const ptrdiff_t _src_stride, const int height, const int denom,
301
    const int wx, const int _ox, const int8_t *hf, const int8_t *vf, const int width)
302
504k
{
303
504k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
504k
    int16_t *tmp                = tmp_array;
305
504k
    const pixel *src            = (const pixel*)_src;
306
504k
    pixel *dst                  = (pixel *)_dst;
307
504k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
504k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
504k
    const int8_t *filter        = hf;
310
504k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
504k
    const int shift             = denom + 14 - BIT_DEPTH;
312
504k
#if BIT_DEPTH < 14
313
504k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
504k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
10.3M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
173M
        for (int x = 0; x < width; x++)
321
163M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
9.85M
        src += src_stride;
323
9.85M
        tmp += MAX_PB_SIZE;
324
9.85M
    }
325
326
504k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
504k
    filter = vf;
328
6.83M
    for (int y = 0; y < height; y++) {
329
125M
        for (int x = 0; x < width; x++)
330
119M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
6.32M
        tmp += MAX_PB_SIZE;
332
6.32M
        dst += dst_stride;
333
6.32M
    }
334
504k
}
dsp.c:put_uni_luma_w_hv_9
Line
Count
Source
302
28.4k
{
303
28.4k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
28.4k
    int16_t *tmp                = tmp_array;
305
28.4k
    const pixel *src            = (const pixel*)_src;
306
28.4k
    pixel *dst                  = (pixel *)_dst;
307
28.4k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
28.4k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
28.4k
    const int8_t *filter        = hf;
310
28.4k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
28.4k
    const int shift             = denom + 14 - BIT_DEPTH;
312
28.4k
#if BIT_DEPTH < 14
313
28.4k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
28.4k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
669k
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
14.2M
        for (int x = 0; x < width; x++)
321
13.6M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
640k
        src += src_stride;
323
640k
        tmp += MAX_PB_SIZE;
324
640k
    }
325
326
28.4k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
28.4k
    filter = vf;
328
469k
    for (int y = 0; y < height; y++) {
329
10.8M
        for (int x = 0; x < width; x++)
330
10.4M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
441k
        tmp += MAX_PB_SIZE;
332
441k
        dst += dst_stride;
333
441k
    }
334
28.4k
}
dsp.c:put_uni_luma_w_hv_10
Line
Count
Source
302
63.5k
{
303
63.5k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
63.5k
    int16_t *tmp                = tmp_array;
305
63.5k
    const pixel *src            = (const pixel*)_src;
306
63.5k
    pixel *dst                  = (pixel *)_dst;
307
63.5k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
63.5k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
63.5k
    const int8_t *filter        = hf;
310
63.5k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
63.5k
    const int shift             = denom + 14 - BIT_DEPTH;
312
63.5k
#if BIT_DEPTH < 14
313
63.5k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
63.5k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
1.33M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
24.8M
        for (int x = 0; x < width; x++)
321
23.5M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
1.27M
        src += src_stride;
323
1.27M
        tmp += MAX_PB_SIZE;
324
1.27M
    }
325
326
63.5k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
63.5k
    filter = vf;
328
894k
    for (int y = 0; y < height; y++) {
329
18.6M
        for (int x = 0; x < width; x++)
330
17.7M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
830k
        tmp += MAX_PB_SIZE;
332
830k
        dst += dst_stride;
333
830k
    }
334
63.5k
}
dsp.c:put_uni_luma_w_hv_12
Line
Count
Source
302
84.2k
{
303
84.2k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
84.2k
    int16_t *tmp                = tmp_array;
305
84.2k
    const pixel *src            = (const pixel*)_src;
306
84.2k
    pixel *dst                  = (pixel *)_dst;
307
84.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
84.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
84.2k
    const int8_t *filter        = hf;
310
84.2k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
84.2k
    const int shift             = denom + 14 - BIT_DEPTH;
312
84.2k
#if BIT_DEPTH < 14
313
84.2k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
84.2k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
1.60M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
23.9M
        for (int x = 0; x < width; x++)
321
22.3M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
1.52M
        src += src_stride;
323
1.52M
        tmp += MAX_PB_SIZE;
324
1.52M
    }
325
326
84.2k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
84.2k
    filter = vf;
328
1.01M
    for (int y = 0; y < height; y++) {
329
16.8M
        for (int x = 0; x < width; x++)
330
15.9M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
931k
        tmp += MAX_PB_SIZE;
332
931k
        dst += dst_stride;
333
931k
    }
334
84.2k
}
dsp.c:put_uni_luma_w_hv_8
Line
Count
Source
302
90.1k
{
303
90.1k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
90.1k
    int16_t *tmp                = tmp_array;
305
90.1k
    const pixel *src            = (const pixel*)_src;
306
90.1k
    pixel *dst                  = (pixel *)_dst;
307
90.1k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
90.1k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
90.1k
    const int8_t *filter        = hf;
310
90.1k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
90.1k
    const int shift             = denom + 14 - BIT_DEPTH;
312
90.1k
#if BIT_DEPTH < 14
313
90.1k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
90.1k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
1.90M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
30.6M
        for (int x = 0; x < width; x++)
321
28.8M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
1.81M
        src += src_stride;
323
1.81M
        tmp += MAX_PB_SIZE;
324
1.81M
    }
325
326
90.1k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
90.1k
    filter = vf;
328
1.27M
    for (int y = 0; y < height; y++) {
329
21.9M
        for (int x = 0; x < width; x++)
330
20.7M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
1.18M
        tmp += MAX_PB_SIZE;
332
1.18M
        dst += dst_stride;
333
1.18M
    }
334
90.1k
}
dsp.c:put_uni_luma_w_hv_12
Line
Count
Source
302
84.2k
{
303
84.2k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
84.2k
    int16_t *tmp                = tmp_array;
305
84.2k
    const pixel *src            = (const pixel*)_src;
306
84.2k
    pixel *dst                  = (pixel *)_dst;
307
84.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
84.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
84.2k
    const int8_t *filter        = hf;
310
84.2k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
84.2k
    const int shift             = denom + 14 - BIT_DEPTH;
312
84.2k
#if BIT_DEPTH < 14
313
84.2k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
84.2k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
1.60M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
23.9M
        for (int x = 0; x < width; x++)
321
22.3M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
1.52M
        src += src_stride;
323
1.52M
        tmp += MAX_PB_SIZE;
324
1.52M
    }
325
326
84.2k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
84.2k
    filter = vf;
328
1.01M
    for (int y = 0; y < height; y++) {
329
16.8M
        for (int x = 0; x < width; x++)
330
15.9M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
931k
        tmp += MAX_PB_SIZE;
332
931k
        dst += dst_stride;
333
931k
    }
334
84.2k
}
dsp.c:put_uni_luma_w_hv_10
Line
Count
Source
302
63.5k
{
303
63.5k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
63.5k
    int16_t *tmp                = tmp_array;
305
63.5k
    const pixel *src            = (const pixel*)_src;
306
63.5k
    pixel *dst                  = (pixel *)_dst;
307
63.5k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
63.5k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
63.5k
    const int8_t *filter        = hf;
310
63.5k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
63.5k
    const int shift             = denom + 14 - BIT_DEPTH;
312
63.5k
#if BIT_DEPTH < 14
313
63.5k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
63.5k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
1.33M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
24.8M
        for (int x = 0; x < width; x++)
321
23.5M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
1.27M
        src += src_stride;
323
1.27M
        tmp += MAX_PB_SIZE;
324
1.27M
    }
325
326
63.5k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
63.5k
    filter = vf;
328
894k
    for (int y = 0; y < height; y++) {
329
18.6M
        for (int x = 0; x < width; x++)
330
17.7M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
830k
        tmp += MAX_PB_SIZE;
332
830k
        dst += dst_stride;
333
830k
    }
334
63.5k
}
dsp.c:put_uni_luma_w_hv_8
Line
Count
Source
302
90.1k
{
303
90.1k
    int16_t tmp_array[(MAX_PB_SIZE + LUMA_EXTRA) * MAX_PB_SIZE];
304
90.1k
    int16_t *tmp                = tmp_array;
305
90.1k
    const pixel *src            = (const pixel*)_src;
306
90.1k
    pixel *dst                  = (pixel *)_dst;
307
90.1k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
308
90.1k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
309
90.1k
    const int8_t *filter        = hf;
310
90.1k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
311
90.1k
    const int shift             = denom + 14 - BIT_DEPTH;
312
90.1k
#if BIT_DEPTH < 14
313
90.1k
    const int offset            = 1 << (shift - 1);
314
#else
315
    const int offset            = 0;
316
#endif
317
318
90.1k
    src   -= LUMA_EXTRA_BEFORE * src_stride;
319
1.90M
    for (int y = 0; y < height + LUMA_EXTRA; y++) {
320
30.6M
        for (int x = 0; x < width; x++)
321
28.8M
            tmp[x] = LUMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
322
1.81M
        src += src_stride;
323
1.81M
        tmp += MAX_PB_SIZE;
324
1.81M
    }
325
326
90.1k
    tmp    = tmp_array + LUMA_EXTRA_BEFORE * MAX_PB_SIZE;
327
90.1k
    filter = vf;
328
1.27M
    for (int y = 0; y < height; y++) {
329
21.9M
        for (int x = 0; x < width; x++)
330
20.7M
            dst[x] = av_clip_pixel((((LUMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
331
1.18M
        tmp += MAX_PB_SIZE;
332
1.18M
        dst += dst_stride;
333
1.18M
    }
334
90.1k
}
335
336
#define CHROMA_FILTER(src, stride)                                             \
337
2.44G
    (filter[0] * src[x - stride] +                                             \
338
2.44G
     filter[1] * src[x]          +                                             \
339
2.44G
     filter[2] * src[x + stride] +                                             \
340
2.44G
     filter[3] * src[x + 2 * stride])
341
342
static void FUNC(put_chroma_h)(int16_t *dst, const uint8_t *_src, const ptrdiff_t _src_stride,
343
    const int height, const int8_t *hf, const int8_t *vf, const int width)
344
1.31M
{
345
1.31M
    const pixel *src            = (const pixel *)_src;
346
1.31M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
1.31M
    const int8_t *filter        = hf;
348
349
11.7M
    for (int y = 0; y < height; y++) {
350
181M
        for (int x = 0; x < width; x++)
351
170M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
10.4M
        src += src_stride;
353
10.4M
        dst += MAX_PB_SIZE;
354
10.4M
    }
355
1.31M
}
dsp.c:put_chroma_h_9
Line
Count
Source
344
51.0k
{
345
51.0k
    const pixel *src            = (const pixel *)_src;
346
51.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
51.0k
    const int8_t *filter        = hf;
348
349
807k
    for (int y = 0; y < height; y++) {
350
11.4M
        for (int x = 0; x < width; x++)
351
10.7M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
756k
        src += src_stride;
353
756k
        dst += MAX_PB_SIZE;
354
756k
    }
355
51.0k
}
dsp.c:put_chroma_h_10
Line
Count
Source
344
404k
{
345
404k
    const pixel *src            = (const pixel *)_src;
346
404k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
404k
    const int8_t *filter        = hf;
348
349
2.94M
    for (int y = 0; y < height; y++) {
350
42.4M
        for (int x = 0; x < width; x++)
351
39.9M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
2.54M
        src += src_stride;
353
2.54M
        dst += MAX_PB_SIZE;
354
2.54M
    }
355
404k
}
dsp.c:put_chroma_h_12
Line
Count
Source
344
113k
{
345
113k
    const pixel *src            = (const pixel *)_src;
346
113k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
113k
    const int8_t *filter        = hf;
348
349
1.46M
    for (int y = 0; y < height; y++) {
350
29.7M
        for (int x = 0; x < width; x++)
351
28.4M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
1.35M
        src += src_stride;
353
1.35M
        dst += MAX_PB_SIZE;
354
1.35M
    }
355
113k
}
dsp.c:put_chroma_h_8
Line
Count
Source
344
114k
{
345
114k
    const pixel *src            = (const pixel *)_src;
346
114k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
114k
    const int8_t *filter        = hf;
348
349
1.03M
    for (int y = 0; y < height; y++) {
350
12.7M
        for (int x = 0; x < width; x++)
351
11.7M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
921k
        src += src_stride;
353
921k
        dst += MAX_PB_SIZE;
354
921k
    }
355
114k
}
dsp.c:put_chroma_h_12
Line
Count
Source
344
113k
{
345
113k
    const pixel *src            = (const pixel *)_src;
346
113k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
113k
    const int8_t *filter        = hf;
348
349
1.46M
    for (int y = 0; y < height; y++) {
350
29.7M
        for (int x = 0; x < width; x++)
351
28.4M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
1.35M
        src += src_stride;
353
1.35M
        dst += MAX_PB_SIZE;
354
1.35M
    }
355
113k
}
dsp.c:put_chroma_h_10
Line
Count
Source
344
404k
{
345
404k
    const pixel *src            = (const pixel *)_src;
346
404k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
404k
    const int8_t *filter        = hf;
348
349
2.94M
    for (int y = 0; y < height; y++) {
350
42.4M
        for (int x = 0; x < width; x++)
351
39.9M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
2.54M
        src += src_stride;
353
2.54M
        dst += MAX_PB_SIZE;
354
2.54M
    }
355
404k
}
dsp.c:put_chroma_h_8
Line
Count
Source
344
114k
{
345
114k
    const pixel *src            = (const pixel *)_src;
346
114k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
347
114k
    const int8_t *filter        = hf;
348
349
1.03M
    for (int y = 0; y < height; y++) {
350
12.7M
        for (int x = 0; x < width; x++)
351
11.7M
            dst[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
352
921k
        src += src_stride;
353
921k
        dst += MAX_PB_SIZE;
354
921k
    }
355
114k
}
356
357
static void FUNC(put_chroma_v)(int16_t *dst, const uint8_t *_src, const ptrdiff_t _src_stride,
358
    const int height, const int8_t *hf, const int8_t *vf, const int width)
359
1.47M
{
360
1.47M
    const pixel *src            = (const pixel *)_src;
361
1.47M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
1.47M
    const int8_t *filter        = vf;
363
364
13.7M
    for (int y = 0; y < height; y++) {
365
268M
        for (int x = 0; x < width; x++)
366
256M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
12.2M
        src += src_stride;
368
12.2M
        dst += MAX_PB_SIZE;
369
12.2M
    }
370
1.47M
}
dsp.c:put_chroma_v_9
Line
Count
Source
359
60.7k
{
360
60.7k
    const pixel *src            = (const pixel *)_src;
361
60.7k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
60.7k
    const int8_t *filter        = vf;
363
364
1.24M
    for (int y = 0; y < height; y++) {
365
19.8M
        for (int x = 0; x < width; x++)
366
18.6M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
1.18M
        src += src_stride;
368
1.18M
        dst += MAX_PB_SIZE;
369
1.18M
    }
370
60.7k
}
dsp.c:put_chroma_v_10
Line
Count
Source
359
524k
{
360
524k
    const pixel *src            = (const pixel *)_src;
361
524k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
524k
    const int8_t *filter        = vf;
363
364
3.98M
    for (int y = 0; y < height; y++) {
365
81.6M
        for (int x = 0; x < width; x++)
366
78.1M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
3.46M
        src += src_stride;
368
3.46M
        dst += MAX_PB_SIZE;
369
3.46M
    }
370
524k
}
dsp.c:put_chroma_v_12
Line
Count
Source
359
97.0k
{
360
97.0k
    const pixel *src            = (const pixel *)_src;
361
97.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
97.0k
    const int8_t *filter        = vf;
363
364
1.44M
    for (int y = 0; y < height; y++) {
365
32.0M
        for (int x = 0; x < width; x++)
366
30.7M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
1.34M
        src += src_stride;
368
1.34M
        dst += MAX_PB_SIZE;
369
1.34M
    }
370
97.0k
}
dsp.c:put_chroma_v_8
Line
Count
Source
359
85.6k
{
360
85.6k
    const pixel *src            = (const pixel *)_src;
361
85.6k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
85.6k
    const int8_t *filter        = vf;
363
364
835k
    for (int y = 0; y < height; y++) {
365
10.7M
        for (int x = 0; x < width; x++)
366
10.0M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
749k
        src += src_stride;
368
749k
        dst += MAX_PB_SIZE;
369
749k
    }
370
85.6k
}
dsp.c:put_chroma_v_12
Line
Count
Source
359
97.0k
{
360
97.0k
    const pixel *src            = (const pixel *)_src;
361
97.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
97.0k
    const int8_t *filter        = vf;
363
364
1.44M
    for (int y = 0; y < height; y++) {
365
32.0M
        for (int x = 0; x < width; x++)
366
30.7M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
1.34M
        src += src_stride;
368
1.34M
        dst += MAX_PB_SIZE;
369
1.34M
    }
370
97.0k
}
dsp.c:put_chroma_v_10
Line
Count
Source
359
524k
{
360
524k
    const pixel *src            = (const pixel *)_src;
361
524k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
524k
    const int8_t *filter        = vf;
363
364
3.98M
    for (int y = 0; y < height; y++) {
365
81.6M
        for (int x = 0; x < width; x++)
366
78.1M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
3.46M
        src += src_stride;
368
3.46M
        dst += MAX_PB_SIZE;
369
3.46M
    }
370
524k
}
dsp.c:put_chroma_v_8
Line
Count
Source
359
85.6k
{
360
85.6k
    const pixel *src            = (const pixel *)_src;
361
85.6k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
362
85.6k
    const int8_t *filter        = vf;
363
364
835k
    for (int y = 0; y < height; y++) {
365
10.7M
        for (int x = 0; x < width; x++)
366
10.0M
            dst[x] = CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8);
367
749k
        src += src_stride;
368
749k
        dst += MAX_PB_SIZE;
369
749k
    }
370
85.6k
}
371
372
static void FUNC(put_chroma_hv)(int16_t *dst, const uint8_t *_src, const ptrdiff_t _src_stride,
373
    const int height, const int8_t *hf, const int8_t *vf, const int width)
374
7.28M
{
375
7.28M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
7.28M
    int16_t *tmp                = tmp_array;
377
7.28M
    const pixel *src            = (const pixel *)_src;
378
7.28M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
7.28M
    const int8_t *filter        = hf;
380
381
7.28M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
75.2M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
842M
        for (int x = 0; x < width; x++)
385
774M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
67.9M
        src += src_stride;
387
67.9M
        tmp += MAX_PB_SIZE;
388
67.9M
    }
389
390
7.28M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
7.28M
    filter = vf;
392
393
53.4M
    for (int y = 0; y < height; y++) {
394
685M
        for (int x = 0; x < width; x++)
395
639M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
46.1M
        tmp += MAX_PB_SIZE;
397
46.1M
        dst += MAX_PB_SIZE;
398
46.1M
    }
399
7.28M
}
dsp.c:put_chroma_hv_9
Line
Count
Source
374
148k
{
375
148k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
148k
    int16_t *tmp                = tmp_array;
377
148k
    const pixel *src            = (const pixel *)_src;
378
148k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
148k
    const int8_t *filter        = hf;
380
381
148k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
3.42M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
51.0M
        for (int x = 0; x < width; x++)
385
47.7M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
3.28M
        src += src_stride;
387
3.28M
        tmp += MAX_PB_SIZE;
388
3.28M
    }
389
390
148k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
148k
    filter = vf;
392
393
2.98M
    for (int y = 0; y < height; y++) {
394
45.4M
        for (int x = 0; x < width; x++)
395
42.6M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
2.83M
        tmp += MAX_PB_SIZE;
397
2.83M
        dst += MAX_PB_SIZE;
398
2.83M
    }
399
148k
}
dsp.c:put_chroma_hv_10
Line
Count
Source
374
2.87M
{
375
2.87M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
2.87M
    int16_t *tmp                = tmp_array;
377
2.87M
    const pixel *src            = (const pixel *)_src;
378
2.87M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
2.87M
    const int8_t *filter        = hf;
380
381
2.87M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
26.2M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
245M
        for (int x = 0; x < width; x++)
385
221M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
23.3M
        src += src_stride;
387
23.3M
        tmp += MAX_PB_SIZE;
388
23.3M
    }
389
390
2.87M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
2.87M
    filter = vf;
392
393
17.6M
    for (int y = 0; y < height; y++) {
394
191M
        for (int x = 0; x < width; x++)
395
176M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
14.7M
        tmp += MAX_PB_SIZE;
397
14.7M
        dst += MAX_PB_SIZE;
398
14.7M
    }
399
2.87M
}
dsp.c:put_chroma_hv_12
Line
Count
Source
374
294k
{
375
294k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
294k
    int16_t *tmp                = tmp_array;
377
294k
    const pixel *src            = (const pixel *)_src;
378
294k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
294k
    const int8_t *filter        = hf;
380
381
294k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
5.04M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
103M
        for (int x = 0; x < width; x++)
385
98.8M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
4.75M
        src += src_stride;
387
4.75M
        tmp += MAX_PB_SIZE;
388
4.75M
    }
389
390
294k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
294k
    filter = vf;
392
393
4.16M
    for (int y = 0; y < height; y++) {
394
91.6M
        for (int x = 0; x < width; x++)
395
87.8M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
3.86M
        tmp += MAX_PB_SIZE;
397
3.86M
        dst += MAX_PB_SIZE;
398
3.86M
    }
399
294k
}
dsp.c:put_chroma_hv_8
Line
Count
Source
374
394k
{
375
394k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
394k
    int16_t *tmp                = tmp_array;
377
394k
    const pixel *src            = (const pixel *)_src;
378
394k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
394k
    const int8_t *filter        = hf;
380
381
394k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
4.61M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
47.0M
        for (int x = 0; x < width; x++)
385
42.8M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
4.22M
        src += src_stride;
387
4.22M
        tmp += MAX_PB_SIZE;
388
4.22M
    }
389
390
394k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
394k
    filter = vf;
392
393
3.43M
    for (int y = 0; y < height; y++) {
394
37.1M
        for (int x = 0; x < width; x++)
395
34.1M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
3.03M
        tmp += MAX_PB_SIZE;
397
3.03M
        dst += MAX_PB_SIZE;
398
3.03M
    }
399
394k
}
dsp.c:put_chroma_hv_12
Line
Count
Source
374
294k
{
375
294k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
294k
    int16_t *tmp                = tmp_array;
377
294k
    const pixel *src            = (const pixel *)_src;
378
294k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
294k
    const int8_t *filter        = hf;
380
381
294k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
5.04M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
103M
        for (int x = 0; x < width; x++)
385
98.8M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
4.75M
        src += src_stride;
387
4.75M
        tmp += MAX_PB_SIZE;
388
4.75M
    }
389
390
294k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
294k
    filter = vf;
392
393
4.16M
    for (int y = 0; y < height; y++) {
394
91.6M
        for (int x = 0; x < width; x++)
395
87.8M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
3.86M
        tmp += MAX_PB_SIZE;
397
3.86M
        dst += MAX_PB_SIZE;
398
3.86M
    }
399
294k
}
dsp.c:put_chroma_hv_10
Line
Count
Source
374
2.87M
{
375
2.87M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
2.87M
    int16_t *tmp                = tmp_array;
377
2.87M
    const pixel *src            = (const pixel *)_src;
378
2.87M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
2.87M
    const int8_t *filter        = hf;
380
381
2.87M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
26.2M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
245M
        for (int x = 0; x < width; x++)
385
221M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
23.3M
        src += src_stride;
387
23.3M
        tmp += MAX_PB_SIZE;
388
23.3M
    }
389
390
2.87M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
2.87M
    filter = vf;
392
393
17.6M
    for (int y = 0; y < height; y++) {
394
191M
        for (int x = 0; x < width; x++)
395
176M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
14.7M
        tmp += MAX_PB_SIZE;
397
14.7M
        dst += MAX_PB_SIZE;
398
14.7M
    }
399
2.87M
}
dsp.c:put_chroma_hv_8
Line
Count
Source
374
394k
{
375
394k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
376
394k
    int16_t *tmp                = tmp_array;
377
394k
    const pixel *src            = (const pixel *)_src;
378
394k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
379
394k
    const int8_t *filter        = hf;
380
381
394k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
382
383
4.61M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
384
47.0M
        for (int x = 0; x < width; x++)
385
42.8M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
386
4.22M
        src += src_stride;
387
4.22M
        tmp += MAX_PB_SIZE;
388
4.22M
    }
389
390
394k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
391
394k
    filter = vf;
392
393
3.43M
    for (int y = 0; y < height; y++) {
394
37.1M
        for (int x = 0; x < width; x++)
395
34.1M
            dst[x] = CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6;
396
3.03M
        tmp += MAX_PB_SIZE;
397
3.03M
        dst += MAX_PB_SIZE;
398
3.03M
    }
399
394k
}
400
401
static void FUNC(put_uni_chroma_h)(uint8_t *_dst, const ptrdiff_t _dst_stride,
402
    const uint8_t *_src, const ptrdiff_t _src_stride,
403
    const int height, const int8_t *hf, const int8_t *vf, const int width)
404
1.51M
{
405
1.51M
    const pixel *src            = (const pixel *)_src;
406
1.51M
    pixel *dst                  = (pixel *)_dst;
407
1.51M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
1.51M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
1.51M
    const int8_t *filter        = hf;
410
1.51M
    const int shift             = 14 - BIT_DEPTH;
411
1.51M
#if BIT_DEPTH < 14
412
1.51M
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
12.3M
    for (int y = 0; y < height; y++) {
418
148M
        for (int x = 0; x < width; x++)
419
137M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
10.7M
        src += src_stride;
421
10.7M
        dst += dst_stride;
422
10.7M
    }
423
1.51M
}
dsp.c:put_uni_chroma_h_9
Line
Count
Source
404
39.3k
{
405
39.3k
    const pixel *src            = (const pixel *)_src;
406
39.3k
    pixel *dst                  = (pixel *)_dst;
407
39.3k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
39.3k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
39.3k
    const int8_t *filter        = hf;
410
39.3k
    const int shift             = 14 - BIT_DEPTH;
411
39.3k
#if BIT_DEPTH < 14
412
39.3k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
426k
    for (int y = 0; y < height; y++) {
418
4.81M
        for (int x = 0; x < width; x++)
419
4.43M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
386k
        src += src_stride;
421
386k
        dst += dst_stride;
422
386k
    }
423
39.3k
}
dsp.c:put_uni_chroma_h_10
Line
Count
Source
404
329k
{
405
329k
    const pixel *src            = (const pixel *)_src;
406
329k
    pixel *dst                  = (pixel *)_dst;
407
329k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
329k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
329k
    const int8_t *filter        = hf;
410
329k
    const int shift             = 14 - BIT_DEPTH;
411
329k
#if BIT_DEPTH < 14
412
329k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
2.29M
    for (int y = 0; y < height; y++) {
418
22.2M
        for (int x = 0; x < width; x++)
419
20.2M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
1.96M
        src += src_stride;
421
1.96M
        dst += dst_stride;
422
1.96M
    }
423
329k
}
dsp.c:put_uni_chroma_h_12
Line
Count
Source
404
146k
{
405
146k
    const pixel *src            = (const pixel *)_src;
406
146k
    pixel *dst                  = (pixel *)_dst;
407
146k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
146k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
146k
    const int8_t *filter        = hf;
410
146k
    const int shift             = 14 - BIT_DEPTH;
411
146k
#if BIT_DEPTH < 14
412
146k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
1.82M
    for (int y = 0; y < height; y++) {
418
33.1M
        for (int x = 0; x < width; x++)
419
31.4M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
1.67M
        src += src_stride;
421
1.67M
        dst += dst_stride;
422
1.67M
    }
423
146k
}
dsp.c:put_uni_chroma_h_8
Line
Count
Source
404
264k
{
405
264k
    const pixel *src            = (const pixel *)_src;
406
264k
    pixel *dst                  = (pixel *)_dst;
407
264k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
264k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
264k
    const int8_t *filter        = hf;
410
264k
    const int shift             = 14 - BIT_DEPTH;
411
264k
#if BIT_DEPTH < 14
412
264k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
1.83M
    for (int y = 0; y < height; y++) {
418
16.4M
        for (int x = 0; x < width; x++)
419
14.8M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
1.56M
        src += src_stride;
421
1.56M
        dst += dst_stride;
422
1.56M
    }
423
264k
}
dsp.c:put_uni_chroma_h_12
Line
Count
Source
404
146k
{
405
146k
    const pixel *src            = (const pixel *)_src;
406
146k
    pixel *dst                  = (pixel *)_dst;
407
146k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
146k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
146k
    const int8_t *filter        = hf;
410
146k
    const int shift             = 14 - BIT_DEPTH;
411
146k
#if BIT_DEPTH < 14
412
146k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
1.82M
    for (int y = 0; y < height; y++) {
418
33.1M
        for (int x = 0; x < width; x++)
419
31.4M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
1.67M
        src += src_stride;
421
1.67M
        dst += dst_stride;
422
1.67M
    }
423
146k
}
dsp.c:put_uni_chroma_h_10
Line
Count
Source
404
329k
{
405
329k
    const pixel *src            = (const pixel *)_src;
406
329k
    pixel *dst                  = (pixel *)_dst;
407
329k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
329k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
329k
    const int8_t *filter        = hf;
410
329k
    const int shift             = 14 - BIT_DEPTH;
411
329k
#if BIT_DEPTH < 14
412
329k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
2.29M
    for (int y = 0; y < height; y++) {
418
22.2M
        for (int x = 0; x < width; x++)
419
20.2M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
1.96M
        src += src_stride;
421
1.96M
        dst += dst_stride;
422
1.96M
    }
423
329k
}
dsp.c:put_uni_chroma_h_8
Line
Count
Source
404
264k
{
405
264k
    const pixel *src            = (const pixel *)_src;
406
264k
    pixel *dst                  = (pixel *)_dst;
407
264k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
408
264k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
409
264k
    const int8_t *filter        = hf;
410
264k
    const int shift             = 14 - BIT_DEPTH;
411
264k
#if BIT_DEPTH < 14
412
264k
    const int offset            = 1 << (shift - 1);
413
#else
414
    const int offset            = 0;
415
#endif
416
417
1.83M
    for (int y = 0; y < height; y++) {
418
16.4M
        for (int x = 0; x < width; x++)
419
14.8M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
420
1.56M
        src += src_stride;
421
1.56M
        dst += dst_stride;
422
1.56M
    }
423
264k
}
424
425
static void FUNC(put_uni_chroma_v)(uint8_t *_dst, const ptrdiff_t _dst_stride,
426
    const uint8_t *_src, const ptrdiff_t _src_stride,
427
    const int height, const int8_t *hf, const int8_t *vf, const int width)
428
1.51M
{
429
1.51M
    const pixel *src            = (const pixel *)_src;
430
1.51M
    pixel *dst                  = (pixel *)_dst;
431
1.51M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
1.51M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
1.51M
    const int8_t *filter        = vf;
434
1.51M
    const int shift             = 14 - BIT_DEPTH;
435
1.51M
#if BIT_DEPTH < 14
436
1.51M
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
10.8M
    for (int y = 0; y < height; y++) {
442
106M
        for (int x = 0; x < width; x++)
443
97.0M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
9.35M
        src += src_stride;
445
9.35M
        dst += dst_stride;
446
9.35M
    }
447
1.51M
}
dsp.c:put_uni_chroma_v_9
Line
Count
Source
428
47.0k
{
429
47.0k
    const pixel *src            = (const pixel *)_src;
430
47.0k
    pixel *dst                  = (pixel *)_dst;
431
47.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
47.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
47.0k
    const int8_t *filter        = vf;
434
47.0k
    const int shift             = 14 - BIT_DEPTH;
435
47.0k
#if BIT_DEPTH < 14
436
47.0k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
388k
    for (int y = 0; y < height; y++) {
442
3.93M
        for (int x = 0; x < width; x++)
443
3.59M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
341k
        src += src_stride;
445
341k
        dst += dst_stride;
446
341k
    }
447
47.0k
}
dsp.c:put_uni_chroma_v_10
Line
Count
Source
428
381k
{
429
381k
    const pixel *src            = (const pixel *)_src;
430
381k
    pixel *dst                  = (pixel *)_dst;
431
381k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
381k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
381k
    const int8_t *filter        = vf;
434
381k
    const int shift             = 14 - BIT_DEPTH;
435
381k
#if BIT_DEPTH < 14
436
381k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
2.51M
    for (int y = 0; y < height; y++) {
442
22.4M
        for (int x = 0; x < width; x++)
443
20.3M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
2.13M
        src += src_stride;
445
2.13M
        dst += dst_stride;
446
2.13M
    }
447
381k
}
dsp.c:put_uni_chroma_v_12
Line
Count
Source
428
132k
{
429
132k
    const pixel *src            = (const pixel *)_src;
430
132k
    pixel *dst                  = (pixel *)_dst;
431
132k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
132k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
132k
    const int8_t *filter        = vf;
434
132k
    const int shift             = 14 - BIT_DEPTH;
435
132k
#if BIT_DEPTH < 14
436
132k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
1.33M
    for (int y = 0; y < height; y++) {
442
17.5M
        for (int x = 0; x < width; x++)
443
16.3M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
1.20M
        src += src_stride;
445
1.20M
        dst += dst_stride;
446
1.20M
    }
447
132k
}
dsp.c:put_uni_chroma_v_8
Line
Count
Source
428
218k
{
429
218k
    const pixel *src            = (const pixel *)_src;
430
218k
    pixel *dst                  = (pixel *)_dst;
431
218k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
218k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
218k
    const int8_t *filter        = vf;
434
218k
    const int shift             = 14 - BIT_DEPTH;
435
218k
#if BIT_DEPTH < 14
436
218k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
1.38M
    for (int y = 0; y < height; y++) {
442
11.1M
        for (int x = 0; x < width; x++)
443
10.0M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
1.16M
        src += src_stride;
445
1.16M
        dst += dst_stride;
446
1.16M
    }
447
218k
}
dsp.c:put_uni_chroma_v_12
Line
Count
Source
428
132k
{
429
132k
    const pixel *src            = (const pixel *)_src;
430
132k
    pixel *dst                  = (pixel *)_dst;
431
132k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
132k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
132k
    const int8_t *filter        = vf;
434
132k
    const int shift             = 14 - BIT_DEPTH;
435
132k
#if BIT_DEPTH < 14
436
132k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
1.33M
    for (int y = 0; y < height; y++) {
442
17.5M
        for (int x = 0; x < width; x++)
443
16.3M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
1.20M
        src += src_stride;
445
1.20M
        dst += dst_stride;
446
1.20M
    }
447
132k
}
dsp.c:put_uni_chroma_v_10
Line
Count
Source
428
381k
{
429
381k
    const pixel *src            = (const pixel *)_src;
430
381k
    pixel *dst                  = (pixel *)_dst;
431
381k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
381k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
381k
    const int8_t *filter        = vf;
434
381k
    const int shift             = 14 - BIT_DEPTH;
435
381k
#if BIT_DEPTH < 14
436
381k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
2.51M
    for (int y = 0; y < height; y++) {
442
22.4M
        for (int x = 0; x < width; x++)
443
20.3M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
2.13M
        src += src_stride;
445
2.13M
        dst += dst_stride;
446
2.13M
    }
447
381k
}
dsp.c:put_uni_chroma_v_8
Line
Count
Source
428
218k
{
429
218k
    const pixel *src            = (const pixel *)_src;
430
218k
    pixel *dst                  = (pixel *)_dst;
431
218k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
432
218k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
433
218k
    const int8_t *filter        = vf;
434
218k
    const int shift             = 14 - BIT_DEPTH;
435
218k
#if BIT_DEPTH < 14
436
218k
    const int offset            = 1 << (shift - 1);
437
#else
438
    const int offset            = 0;
439
#endif
440
441
1.38M
    for (int y = 0; y < height; y++) {
442
11.1M
        for (int x = 0; x < width; x++)
443
10.0M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) + offset) >> shift);
444
1.16M
        src += src_stride;
445
1.16M
        dst += dst_stride;
446
1.16M
    }
447
218k
}
448
449
static void FUNC(put_uni_chroma_hv)(uint8_t *_dst, const ptrdiff_t _dst_stride,
450
    const uint8_t *_src, const ptrdiff_t _src_stride,
451
    const int height, const int8_t *hf, const int8_t *vf, const int width)
452
6.87M
{
453
6.87M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
6.87M
    int16_t *tmp                = tmp_array;
455
6.87M
    const pixel *src            = (const pixel *)_src;
456
6.87M
    pixel *dst                  = (pixel *)_dst;
457
6.87M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
6.87M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
6.87M
    const int8_t *filter        = hf;
460
6.87M
    const int shift             = 14 - BIT_DEPTH;
461
6.87M
#if BIT_DEPTH < 14
462
6.87M
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
6.87M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
67.4M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
553M
        for (int x = 0; x < width; x++)
471
492M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
60.5M
        src += src_stride;
473
60.5M
        tmp += MAX_PB_SIZE;
474
60.5M
    }
475
476
6.87M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
6.87M
    filter = vf;
478
479
46.8M
    for (int y = 0; y < height; y++) {
480
415M
        for (int x = 0; x < width; x++)
481
375M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
39.9M
        tmp += MAX_PB_SIZE;
483
39.9M
        dst += dst_stride;
484
39.9M
    }
485
6.87M
}
dsp.c:put_uni_chroma_hv_9
Line
Count
Source
452
98.2k
{
453
98.2k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
98.2k
    int16_t *tmp                = tmp_array;
455
98.2k
    const pixel *src            = (const pixel *)_src;
456
98.2k
    pixel *dst                  = (pixel *)_dst;
457
98.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
98.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
98.2k
    const int8_t *filter        = hf;
460
98.2k
    const int shift             = 14 - BIT_DEPTH;
461
98.2k
#if BIT_DEPTH < 14
462
98.2k
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
98.2k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
1.21M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
11.4M
        for (int x = 0; x < width; x++)
471
10.3M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
1.12M
        src += src_stride;
473
1.12M
        tmp += MAX_PB_SIZE;
474
1.12M
    }
475
476
98.2k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
98.2k
    filter = vf;
478
479
924k
    for (int y = 0; y < height; y++) {
480
9.42M
        for (int x = 0; x < width; x++)
481
8.59M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
826k
        tmp += MAX_PB_SIZE;
483
826k
        dst += dst_stride;
484
826k
    }
485
98.2k
}
dsp.c:put_uni_chroma_hv_10
Line
Count
Source
452
2.01M
{
453
2.01M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
2.01M
    int16_t *tmp                = tmp_array;
455
2.01M
    const pixel *src            = (const pixel *)_src;
456
2.01M
    pixel *dst                  = (pixel *)_dst;
457
2.01M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
2.01M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
2.01M
    const int8_t *filter        = hf;
460
2.01M
    const int shift             = 14 - BIT_DEPTH;
461
2.01M
#if BIT_DEPTH < 14
462
2.01M
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
2.01M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
18.2M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
132M
        for (int x = 0; x < width; x++)
471
116M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
16.2M
        src += src_stride;
473
16.2M
        tmp += MAX_PB_SIZE;
474
16.2M
    }
475
476
2.01M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
2.01M
    filter = vf;
478
479
12.1M
    for (int y = 0; y < height; y++) {
480
94.0M
        for (int x = 0; x < width; x++)
481
83.8M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
10.1M
        tmp += MAX_PB_SIZE;
483
10.1M
        dst += dst_stride;
484
10.1M
    }
485
2.01M
}
dsp.c:put_uni_chroma_hv_12
Line
Count
Source
452
464k
{
453
464k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
464k
    int16_t *tmp                = tmp_array;
455
464k
    const pixel *src            = (const pixel *)_src;
456
464k
    pixel *dst                  = (pixel *)_dst;
457
464k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
464k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
464k
    const int8_t *filter        = hf;
460
464k
    const int shift             = 14 - BIT_DEPTH;
461
464k
#if BIT_DEPTH < 14
462
464k
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
464k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
6.25M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
76.2M
        for (int x = 0; x < width; x++)
471
70.4M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
5.79M
        src += src_stride;
473
5.79M
        tmp += MAX_PB_SIZE;
474
5.79M
    }
475
476
464k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
464k
    filter = vf;
478
479
4.86M
    for (int y = 0; y < height; y++) {
480
63.5M
        for (int x = 0; x < width; x++)
481
59.1M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
4.39M
        tmp += MAX_PB_SIZE;
483
4.39M
        dst += dst_stride;
484
4.39M
    }
485
464k
}
dsp.c:put_uni_chroma_hv_8
Line
Count
Source
452
913k
{
453
913k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
913k
    int16_t *tmp                = tmp_array;
455
913k
    const pixel *src            = (const pixel *)_src;
456
913k
    pixel *dst                  = (pixel *)_dst;
457
913k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
913k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
913k
    const int8_t *filter        = hf;
460
913k
    const int shift             = 14 - BIT_DEPTH;
461
913k
#if BIT_DEPTH < 14
462
913k
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
913k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
8.63M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
61.8M
        for (int x = 0; x < width; x++)
471
54.1M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
7.72M
        src += src_stride;
473
7.72M
        tmp += MAX_PB_SIZE;
474
7.72M
    }
475
476
913k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
913k
    filter = vf;
478
479
5.89M
    for (int y = 0; y < height; y++) {
480
45.1M
        for (int x = 0; x < width; x++)
481
40.1M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
4.97M
        tmp += MAX_PB_SIZE;
483
4.97M
        dst += dst_stride;
484
4.97M
    }
485
913k
}
dsp.c:put_uni_chroma_hv_12
Line
Count
Source
452
464k
{
453
464k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
464k
    int16_t *tmp                = tmp_array;
455
464k
    const pixel *src            = (const pixel *)_src;
456
464k
    pixel *dst                  = (pixel *)_dst;
457
464k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
464k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
464k
    const int8_t *filter        = hf;
460
464k
    const int shift             = 14 - BIT_DEPTH;
461
464k
#if BIT_DEPTH < 14
462
464k
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
464k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
6.25M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
76.2M
        for (int x = 0; x < width; x++)
471
70.4M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
5.79M
        src += src_stride;
473
5.79M
        tmp += MAX_PB_SIZE;
474
5.79M
    }
475
476
464k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
464k
    filter = vf;
478
479
4.86M
    for (int y = 0; y < height; y++) {
480
63.5M
        for (int x = 0; x < width; x++)
481
59.1M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
4.39M
        tmp += MAX_PB_SIZE;
483
4.39M
        dst += dst_stride;
484
4.39M
    }
485
464k
}
dsp.c:put_uni_chroma_hv_10
Line
Count
Source
452
2.01M
{
453
2.01M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
2.01M
    int16_t *tmp                = tmp_array;
455
2.01M
    const pixel *src            = (const pixel *)_src;
456
2.01M
    pixel *dst                  = (pixel *)_dst;
457
2.01M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
2.01M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
2.01M
    const int8_t *filter        = hf;
460
2.01M
    const int shift             = 14 - BIT_DEPTH;
461
2.01M
#if BIT_DEPTH < 14
462
2.01M
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
2.01M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
18.2M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
132M
        for (int x = 0; x < width; x++)
471
116M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
16.2M
        src += src_stride;
473
16.2M
        tmp += MAX_PB_SIZE;
474
16.2M
    }
475
476
2.01M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
2.01M
    filter = vf;
478
479
12.1M
    for (int y = 0; y < height; y++) {
480
94.0M
        for (int x = 0; x < width; x++)
481
83.8M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
10.1M
        tmp += MAX_PB_SIZE;
483
10.1M
        dst += dst_stride;
484
10.1M
    }
485
2.01M
}
dsp.c:put_uni_chroma_hv_8
Line
Count
Source
452
913k
{
453
913k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
454
913k
    int16_t *tmp                = tmp_array;
455
913k
    const pixel *src            = (const pixel *)_src;
456
913k
    pixel *dst                  = (pixel *)_dst;
457
913k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
458
913k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
459
913k
    const int8_t *filter        = hf;
460
913k
    const int shift             = 14 - BIT_DEPTH;
461
913k
#if BIT_DEPTH < 14
462
913k
    const int offset            = 1 << (shift - 1);
463
#else
464
    const int offset            = 0;
465
#endif
466
467
913k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
468
469
8.63M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
470
61.8M
        for (int x = 0; x < width; x++)
471
54.1M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
472
7.72M
        src += src_stride;
473
7.72M
        tmp += MAX_PB_SIZE;
474
7.72M
    }
475
476
913k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
477
913k
    filter = vf;
478
479
5.89M
    for (int y = 0; y < height; y++) {
480
45.1M
        for (int x = 0; x < width; x++)
481
40.1M
            dst[x] = av_clip_pixel(((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
482
4.97M
        tmp += MAX_PB_SIZE;
483
4.97M
        dst += dst_stride;
484
4.97M
    }
485
913k
}
486
487
static void FUNC(put_uni_chroma_w_h)(uint8_t *_dst, ptrdiff_t _dst_stride,
488
    const uint8_t *_src, ptrdiff_t _src_stride, int height, int denom, int wx, int ox,
489
    const int8_t *hf, const int8_t *vf, int width)
490
384k
{
491
384k
    const pixel *src            = (const pixel *)_src;
492
384k
    pixel *dst                  = (pixel *)_dst;
493
384k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
384k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
384k
    const int8_t *filter        = hf;
496
384k
    const int shift             = denom + 14 - BIT_DEPTH;
497
384k
#if BIT_DEPTH < 14
498
384k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
384k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
3.38M
    for (int y = 0; y < height; y++) {
505
36.1M
        for (int x = 0; x < width; x++) {
506
33.1M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
33.1M
        }
508
3.00M
        dst += dst_stride;
509
3.00M
        src += src_stride;
510
3.00M
    }
511
384k
}
dsp.c:put_uni_chroma_w_h_9
Line
Count
Source
490
25.8k
{
491
25.8k
    const pixel *src            = (const pixel *)_src;
492
25.8k
    pixel *dst                  = (pixel *)_dst;
493
25.8k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
25.8k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
25.8k
    const int8_t *filter        = hf;
496
25.8k
    const int shift             = denom + 14 - BIT_DEPTH;
497
25.8k
#if BIT_DEPTH < 14
498
25.8k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
25.8k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
428k
    for (int y = 0; y < height; y++) {
505
6.26M
        for (int x = 0; x < width; x++) {
506
5.85M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
5.85M
        }
508
402k
        dst += dst_stride;
509
402k
        src += src_stride;
510
402k
    }
511
25.8k
}
dsp.c:put_uni_chroma_w_h_10
Line
Count
Source
490
53.6k
{
491
53.6k
    const pixel *src            = (const pixel *)_src;
492
53.6k
    pixel *dst                  = (pixel *)_dst;
493
53.6k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
53.6k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
53.6k
    const int8_t *filter        = hf;
496
53.6k
    const int shift             = denom + 14 - BIT_DEPTH;
497
53.6k
#if BIT_DEPTH < 14
498
53.6k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
53.6k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
484k
    for (int y = 0; y < height; y++) {
505
3.92M
        for (int x = 0; x < width; x++) {
506
3.49M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
3.49M
        }
508
430k
        dst += dst_stride;
509
430k
        src += src_stride;
510
430k
    }
511
53.6k
}
dsp.c:put_uni_chroma_w_h_12
Line
Count
Source
490
61.4k
{
491
61.4k
    const pixel *src            = (const pixel *)_src;
492
61.4k
    pixel *dst                  = (pixel *)_dst;
493
61.4k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
61.4k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
61.4k
    const int8_t *filter        = hf;
496
61.4k
    const int shift             = denom + 14 - BIT_DEPTH;
497
61.4k
#if BIT_DEPTH < 14
498
61.4k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
61.4k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
596k
    for (int y = 0; y < height; y++) {
505
7.88M
        for (int x = 0; x < width; x++) {
506
7.35M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
7.35M
        }
508
535k
        dst += dst_stride;
509
535k
        src += src_stride;
510
535k
    }
511
61.4k
}
dsp.c:put_uni_chroma_w_h_8
Line
Count
Source
490
64.0k
{
491
64.0k
    const pixel *src            = (const pixel *)_src;
492
64.0k
    pixel *dst                  = (pixel *)_dst;
493
64.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
64.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
64.0k
    const int8_t *filter        = hf;
496
64.0k
    const int shift             = denom + 14 - BIT_DEPTH;
497
64.0k
#if BIT_DEPTH < 14
498
64.0k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
64.0k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
398k
    for (int y = 0; y < height; y++) {
505
3.12M
        for (int x = 0; x < width; x++) {
506
2.78M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
2.78M
        }
508
334k
        dst += dst_stride;
509
334k
        src += src_stride;
510
334k
    }
511
64.0k
}
dsp.c:put_uni_chroma_w_h_12
Line
Count
Source
490
61.4k
{
491
61.4k
    const pixel *src            = (const pixel *)_src;
492
61.4k
    pixel *dst                  = (pixel *)_dst;
493
61.4k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
61.4k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
61.4k
    const int8_t *filter        = hf;
496
61.4k
    const int shift             = denom + 14 - BIT_DEPTH;
497
61.4k
#if BIT_DEPTH < 14
498
61.4k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
61.4k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
596k
    for (int y = 0; y < height; y++) {
505
7.88M
        for (int x = 0; x < width; x++) {
506
7.35M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
7.35M
        }
508
535k
        dst += dst_stride;
509
535k
        src += src_stride;
510
535k
    }
511
61.4k
}
dsp.c:put_uni_chroma_w_h_10
Line
Count
Source
490
53.6k
{
491
53.6k
    const pixel *src            = (const pixel *)_src;
492
53.6k
    pixel *dst                  = (pixel *)_dst;
493
53.6k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
53.6k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
53.6k
    const int8_t *filter        = hf;
496
53.6k
    const int shift             = denom + 14 - BIT_DEPTH;
497
53.6k
#if BIT_DEPTH < 14
498
53.6k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
53.6k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
484k
    for (int y = 0; y < height; y++) {
505
3.92M
        for (int x = 0; x < width; x++) {
506
3.49M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
3.49M
        }
508
430k
        dst += dst_stride;
509
430k
        src += src_stride;
510
430k
    }
511
53.6k
}
dsp.c:put_uni_chroma_w_h_8
Line
Count
Source
490
64.0k
{
491
64.0k
    const pixel *src            = (const pixel *)_src;
492
64.0k
    pixel *dst                  = (pixel *)_dst;
493
64.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
494
64.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
495
64.0k
    const int8_t *filter        = hf;
496
64.0k
    const int shift             = denom + 14 - BIT_DEPTH;
497
64.0k
#if BIT_DEPTH < 14
498
64.0k
    const int offset            = 1 << (shift - 1);
499
#else
500
    const int offset            = 0;
501
#endif
502
503
64.0k
    ox     = ox * (1 << (BIT_DEPTH - 8));
504
398k
    for (int y = 0; y < height; y++) {
505
3.12M
        for (int x = 0; x < width; x++) {
506
2.78M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
507
2.78M
        }
508
334k
        dst += dst_stride;
509
334k
        src += src_stride;
510
334k
    }
511
64.0k
}
512
513
static void FUNC(put_uni_chroma_w_v)(uint8_t *_dst, const ptrdiff_t _dst_stride,
514
    const uint8_t *_src, const ptrdiff_t _src_stride, const int height,
515
    const int denom, const int wx, const int _ox, const int8_t *hf, const int8_t *vf,
516
    const int width)
517
331k
{
518
331k
    const pixel *src            = (const pixel *)_src;
519
331k
    pixel *dst                  = (pixel *)_dst;
520
331k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
331k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
331k
    const int8_t *filter        = vf;
523
331k
    const int shift             = denom + 14 - BIT_DEPTH;
524
331k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
331k
#if BIT_DEPTH < 14
526
331k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
3.06M
    for (int y = 0; y < height; y++) {
532
36.7M
        for (int x = 0; x < width; x++) {
533
34.0M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
34.0M
        }
535
2.72M
        dst += dst_stride;
536
2.72M
        src += src_stride;
537
2.72M
    }
538
331k
}
dsp.c:put_uni_chroma_w_v_9
Line
Count
Source
517
33.5k
{
518
33.5k
    const pixel *src            = (const pixel *)_src;
519
33.5k
    pixel *dst                  = (pixel *)_dst;
520
33.5k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
33.5k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
33.5k
    const int8_t *filter        = vf;
523
33.5k
    const int shift             = denom + 14 - BIT_DEPTH;
524
33.5k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
33.5k
#if BIT_DEPTH < 14
526
33.5k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
432k
    for (int y = 0; y < height; y++) {
532
6.11M
        for (int x = 0; x < width; x++) {
533
5.71M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
5.71M
        }
535
398k
        dst += dst_stride;
536
398k
        src += src_stride;
537
398k
    }
538
33.5k
}
dsp.c:put_uni_chroma_w_v_10
Line
Count
Source
517
52.0k
{
518
52.0k
    const pixel *src            = (const pixel *)_src;
519
52.0k
    pixel *dst                  = (pixel *)_dst;
520
52.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
52.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
52.0k
    const int8_t *filter        = vf;
523
52.0k
    const int shift             = denom + 14 - BIT_DEPTH;
524
52.0k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
52.0k
#if BIT_DEPTH < 14
526
52.0k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
476k
    for (int y = 0; y < height; y++) {
532
4.08M
        for (int x = 0; x < width; x++) {
533
3.65M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
3.65M
        }
535
424k
        dst += dst_stride;
536
424k
        src += src_stride;
537
424k
    }
538
52.0k
}
dsp.c:put_uni_chroma_w_v_12
Line
Count
Source
517
42.0k
{
518
42.0k
    const pixel *src            = (const pixel *)_src;
519
42.0k
    pixel *dst                  = (pixel *)_dst;
520
42.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
42.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
42.0k
    const int8_t *filter        = vf;
523
42.0k
    const int shift             = denom + 14 - BIT_DEPTH;
524
42.0k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
42.0k
#if BIT_DEPTH < 14
526
42.0k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
477k
    for (int y = 0; y < height; y++) {
532
8.27M
        for (int x = 0; x < width; x++) {
533
7.83M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
7.83M
        }
535
435k
        dst += dst_stride;
536
435k
        src += src_stride;
537
435k
    }
538
42.0k
}
dsp.c:put_uni_chroma_w_v_8
Line
Count
Source
517
54.9k
{
518
54.9k
    const pixel *src            = (const pixel *)_src;
519
54.9k
    pixel *dst                  = (pixel *)_dst;
520
54.9k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
54.9k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
54.9k
    const int8_t *filter        = vf;
523
54.9k
    const int shift             = denom + 14 - BIT_DEPTH;
524
54.9k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
54.9k
#if BIT_DEPTH < 14
526
54.9k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
360k
    for (int y = 0; y < height; y++) {
532
2.98M
        for (int x = 0; x < width; x++) {
533
2.68M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
2.68M
        }
535
305k
        dst += dst_stride;
536
305k
        src += src_stride;
537
305k
    }
538
54.9k
}
dsp.c:put_uni_chroma_w_v_12
Line
Count
Source
517
42.0k
{
518
42.0k
    const pixel *src            = (const pixel *)_src;
519
42.0k
    pixel *dst                  = (pixel *)_dst;
520
42.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
42.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
42.0k
    const int8_t *filter        = vf;
523
42.0k
    const int shift             = denom + 14 - BIT_DEPTH;
524
42.0k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
42.0k
#if BIT_DEPTH < 14
526
42.0k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
477k
    for (int y = 0; y < height; y++) {
532
8.27M
        for (int x = 0; x < width; x++) {
533
7.83M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
7.83M
        }
535
435k
        dst += dst_stride;
536
435k
        src += src_stride;
537
435k
    }
538
42.0k
}
dsp.c:put_uni_chroma_w_v_10
Line
Count
Source
517
52.0k
{
518
52.0k
    const pixel *src            = (const pixel *)_src;
519
52.0k
    pixel *dst                  = (pixel *)_dst;
520
52.0k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
52.0k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
52.0k
    const int8_t *filter        = vf;
523
52.0k
    const int shift             = denom + 14 - BIT_DEPTH;
524
52.0k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
52.0k
#if BIT_DEPTH < 14
526
52.0k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
476k
    for (int y = 0; y < height; y++) {
532
4.08M
        for (int x = 0; x < width; x++) {
533
3.65M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
3.65M
        }
535
424k
        dst += dst_stride;
536
424k
        src += src_stride;
537
424k
    }
538
52.0k
}
dsp.c:put_uni_chroma_w_v_8
Line
Count
Source
517
54.9k
{
518
54.9k
    const pixel *src            = (const pixel *)_src;
519
54.9k
    pixel *dst                  = (pixel *)_dst;
520
54.9k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
521
54.9k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
522
54.9k
    const int8_t *filter        = vf;
523
54.9k
    const int shift             = denom + 14 - BIT_DEPTH;
524
54.9k
    const int ox                = _ox * (1 << (BIT_DEPTH - 8));
525
54.9k
#if BIT_DEPTH < 14
526
54.9k
    int offset                  = 1 << (shift - 1);
527
#else
528
    int offset                  = 0;
529
#endif
530
531
360k
    for (int y = 0; y < height; y++) {
532
2.98M
        for (int x = 0; x < width; x++) {
533
2.68M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(src, src_stride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
534
2.68M
        }
535
305k
        dst += dst_stride;
536
305k
        src += src_stride;
537
305k
    }
538
54.9k
}
539
540
static void FUNC(put_uni_chroma_w_hv)(uint8_t *_dst, ptrdiff_t _dst_stride,
541
     const uint8_t *_src, ptrdiff_t _src_stride,  int height, int denom, int wx, int ox,
542
     const int8_t *hf, const int8_t *vf, int width)
543
1.10M
{
544
1.10M
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
1.10M
    int16_t *tmp                = tmp_array;
546
1.10M
    const pixel *src            = (const pixel *)_src;
547
1.10M
    pixel *dst                  = (pixel *)_dst;
548
1.10M
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
1.10M
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
1.10M
    const int8_t *filter        = hf;
551
1.10M
    const int shift             = denom + 14 - BIT_DEPTH;
552
1.10M
#if BIT_DEPTH < 14
553
1.10M
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
1.10M
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
12.8M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
122M
        for (int x = 0; x < width; x++)
562
110M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
11.7M
        src += src_stride;
564
11.7M
        tmp += MAX_PB_SIZE;
565
11.7M
    }
566
567
1.10M
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
1.10M
    filter = vf;
569
570
1.10M
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
9.50M
    for (int y = 0; y < height; y++) {
572
96.7M
        for (int x = 0; x < width; x++)
573
88.3M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
8.39M
        tmp += MAX_PB_SIZE;
575
8.39M
        dst += dst_stride;
576
8.39M
    }
577
1.10M
}
dsp.c:put_uni_chroma_w_hv_9
Line
Count
Source
543
59.2k
{
544
59.2k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
59.2k
    int16_t *tmp                = tmp_array;
546
59.2k
    const pixel *src            = (const pixel *)_src;
547
59.2k
    pixel *dst                  = (pixel *)_dst;
548
59.2k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
59.2k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
59.2k
    const int8_t *filter        = hf;
551
59.2k
    const int shift             = denom + 14 - BIT_DEPTH;
552
59.2k
#if BIT_DEPTH < 14
553
59.2k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
59.2k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
1.00M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
13.5M
        for (int x = 0; x < width; x++)
562
12.5M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
950k
        src += src_stride;
564
950k
        tmp += MAX_PB_SIZE;
565
950k
    }
566
567
59.2k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
59.2k
    filter = vf;
569
570
59.2k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
832k
    for (int y = 0; y < height; y++) {
572
11.7M
        for (int x = 0; x < width; x++)
573
10.9M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
772k
        tmp += MAX_PB_SIZE;
575
772k
        dst += dst_stride;
576
772k
    }
577
59.2k
}
dsp.c:put_uni_chroma_w_hv_10
Line
Count
Source
543
149k
{
544
149k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
149k
    int16_t *tmp                = tmp_array;
546
149k
    const pixel *src            = (const pixel *)_src;
547
149k
    pixel *dst                  = (pixel *)_dst;
548
149k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
149k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
149k
    const int8_t *filter        = hf;
551
149k
    const int shift             = denom + 14 - BIT_DEPTH;
552
149k
#if BIT_DEPTH < 14
553
149k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
149k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
1.85M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
16.9M
        for (int x = 0; x < width; x++)
562
15.2M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
1.70M
        src += src_stride;
564
1.70M
        tmp += MAX_PB_SIZE;
565
1.70M
    }
566
567
149k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
149k
    filter = vf;
569
570
149k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
1.40M
    for (int y = 0; y < height; y++) {
572
13.6M
        for (int x = 0; x < width; x++)
573
12.3M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
1.25M
        tmp += MAX_PB_SIZE;
575
1.25M
        dst += dst_stride;
576
1.25M
    }
577
149k
}
dsp.c:put_uni_chroma_w_hv_12
Line
Count
Source
543
168k
{
544
168k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
168k
    int16_t *tmp                = tmp_array;
546
168k
    const pixel *src            = (const pixel *)_src;
547
168k
    pixel *dst                  = (pixel *)_dst;
548
168k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
168k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
168k
    const int8_t *filter        = hf;
551
168k
    const int shift             = denom + 14 - BIT_DEPTH;
552
168k
#if BIT_DEPTH < 14
553
168k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
168k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
1.88M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
19.5M
        for (int x = 0; x < width; x++)
562
17.8M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
1.72M
        src += src_stride;
564
1.72M
        tmp += MAX_PB_SIZE;
565
1.72M
    }
566
567
168k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
168k
    filter = vf;
569
570
168k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
1.38M
    for (int y = 0; y < height; y++) {
572
15.7M
        for (int x = 0; x < width; x++)
573
14.4M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
1.21M
        tmp += MAX_PB_SIZE;
575
1.21M
        dst += dst_stride;
576
1.21M
    }
577
168k
}
dsp.c:put_uni_chroma_w_hv_8
Line
Count
Source
543
205k
{
544
205k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
205k
    int16_t *tmp                = tmp_array;
546
205k
    const pixel *src            = (const pixel *)_src;
547
205k
    pixel *dst                  = (pixel *)_dst;
548
205k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
205k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
205k
    const int8_t *filter        = hf;
551
205k
    const int shift             = denom + 14 - BIT_DEPTH;
552
205k
#if BIT_DEPTH < 14
553
205k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
205k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
2.16M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
17.7M
        for (int x = 0; x < width; x++)
562
15.7M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
1.95M
        src += src_stride;
564
1.95M
        tmp += MAX_PB_SIZE;
565
1.95M
    }
566
567
205k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
205k
    filter = vf;
569
570
205k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
1.54M
    for (int y = 0; y < height; y++) {
572
13.1M
        for (int x = 0; x < width; x++)
573
11.8M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
1.33M
        tmp += MAX_PB_SIZE;
575
1.33M
        dst += dst_stride;
576
1.33M
    }
577
205k
}
dsp.c:put_uni_chroma_w_hv_12
Line
Count
Source
543
168k
{
544
168k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
168k
    int16_t *tmp                = tmp_array;
546
168k
    const pixel *src            = (const pixel *)_src;
547
168k
    pixel *dst                  = (pixel *)_dst;
548
168k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
168k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
168k
    const int8_t *filter        = hf;
551
168k
    const int shift             = denom + 14 - BIT_DEPTH;
552
168k
#if BIT_DEPTH < 14
553
168k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
168k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
1.88M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
19.5M
        for (int x = 0; x < width; x++)
562
17.8M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
1.72M
        src += src_stride;
564
1.72M
        tmp += MAX_PB_SIZE;
565
1.72M
    }
566
567
168k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
168k
    filter = vf;
569
570
168k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
1.38M
    for (int y = 0; y < height; y++) {
572
15.7M
        for (int x = 0; x < width; x++)
573
14.4M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
1.21M
        tmp += MAX_PB_SIZE;
575
1.21M
        dst += dst_stride;
576
1.21M
    }
577
168k
}
dsp.c:put_uni_chroma_w_hv_10
Line
Count
Source
543
149k
{
544
149k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
149k
    int16_t *tmp                = tmp_array;
546
149k
    const pixel *src            = (const pixel *)_src;
547
149k
    pixel *dst                  = (pixel *)_dst;
548
149k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
149k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
149k
    const int8_t *filter        = hf;
551
149k
    const int shift             = denom + 14 - BIT_DEPTH;
552
149k
#if BIT_DEPTH < 14
553
149k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
149k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
1.85M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
16.9M
        for (int x = 0; x < width; x++)
562
15.2M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
1.70M
        src += src_stride;
564
1.70M
        tmp += MAX_PB_SIZE;
565
1.70M
    }
566
567
149k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
149k
    filter = vf;
569
570
149k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
1.40M
    for (int y = 0; y < height; y++) {
572
13.6M
        for (int x = 0; x < width; x++)
573
12.3M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
1.25M
        tmp += MAX_PB_SIZE;
575
1.25M
        dst += dst_stride;
576
1.25M
    }
577
149k
}
dsp.c:put_uni_chroma_w_hv_8
Line
Count
Source
543
205k
{
544
205k
    int16_t tmp_array[(MAX_PB_SIZE + CHROMA_EXTRA) * MAX_PB_SIZE];
545
205k
    int16_t *tmp                = tmp_array;
546
205k
    const pixel *src            = (const pixel *)_src;
547
205k
    pixel *dst                  = (pixel *)_dst;
548
205k
    const ptrdiff_t src_stride  = _src_stride / sizeof(pixel);
549
205k
    const ptrdiff_t dst_stride  = _dst_stride / sizeof(pixel);
550
205k
    const int8_t *filter        = hf;
551
205k
    const int shift             = denom + 14 - BIT_DEPTH;
552
205k
#if BIT_DEPTH < 14
553
205k
    const int offset            = 1 << (shift - 1);
554
#else
555
    const int offset            = 0;
556
#endif
557
558
205k
    src -= CHROMA_EXTRA_BEFORE * src_stride;
559
560
2.16M
    for (int y = 0; y < height + CHROMA_EXTRA; y++) {
561
17.7M
        for (int x = 0; x < width; x++)
562
15.7M
            tmp[x] = CHROMA_FILTER(src, 1) >> (BIT_DEPTH - 8);
563
1.95M
        src += src_stride;
564
1.95M
        tmp += MAX_PB_SIZE;
565
1.95M
    }
566
567
205k
    tmp    = tmp_array + CHROMA_EXTRA_BEFORE * MAX_PB_SIZE;
568
205k
    filter = vf;
569
570
205k
    ox     = ox * (1 << (BIT_DEPTH - 8));
571
1.54M
    for (int y = 0; y < height; y++) {
572
13.1M
        for (int x = 0; x < width; x++)
573
11.8M
            dst[x] = av_clip_pixel((((CHROMA_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
574
1.33M
        tmp += MAX_PB_SIZE;
575
1.33M
        dst += dst_stride;
576
1.33M
    }
577
205k
}