ncnn

1
// Tencent is pleased to support the open source community by making ncnn available.
2
//
3
// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
4
//
5
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
6
// in compliance with the License. You may obtain a copy of the License at
7
//
8
// https://opensource.org/licenses/BSD-3-Clause
9
//
10
// Unless required by applicable law or agreed to in writing, software distributed
11
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
13
// specific language governing permissions and limitations under the License.
14

15
#include "mat.h"
16
#include "prng.h"
17

18
#include <string.h>
19

20
static struct prng_rand_t g_prng_rand_state;
21
#define SRAND(seed) prng_srand(seed, &g_prng_rand_state)
22
#define RAND()      prng_rand(&g_prng_rand_state)
23

24
static ncnn::Mat RandomMat(int w, int h, int elempack)
25
{
26
    ncnn::Mat m(w, h, (size_t)elempack, elempack);
27

28
    unsigned char* p = m;
29
    for (int i = 0; i < w * h * elempack; i++)
30
    {
31
        p[i] = RAND() % 256;
32
    }
33

34
    return m;
35
}
36

37
static int test_mat_pixel_rotate_c1(int w, int h)
38
{
39
    ncnn::Mat a0 = RandomMat(w, h, 1);
40

41
    ncnn::Mat a1(w, h, (size_t)1u, 1);
42
    ncnn::Mat a2(w, h, (size_t)1u, 1);
43
    ncnn::Mat a3(w, h, (size_t)1u, 1);
44
    ncnn::Mat a4(w, h, (size_t)1u, 1);
45
    ncnn::Mat a5(h, w, (size_t)1u, 1);
46
    ncnn::Mat a6(w, h, (size_t)1u, 1);
47
    ncnn::Mat a7(h, w, (size_t)1u, 1);
48
    ncnn::Mat a8(w, h, (size_t)1u, 1);
49

50
    ncnn::kanna_rotate_c1(a0, w, h, a1, w, h, 1);
51
    ncnn::kanna_rotate_c1(a1, w, h, a2, w, h, 2);
52
    ncnn::kanna_rotate_c1(a2, w, h, a3, w, h, 3);
53
    ncnn::kanna_rotate_c1(a3, w, h, a4, w, h, 4);
54
    ncnn::kanna_rotate_c1(a4, w, h, a5, h, w, 5);
55
    ncnn::kanna_rotate_c1(a5, h, w, a6, w, h, 6);
56
    ncnn::kanna_rotate_c1(a6, w, h, a7, h, w, 7);
57
    ncnn::kanna_rotate_c1(a7, h, w, a8, w, h, 8);
58

59
    if (memcmp(a0, a8, w * h * 1) != 0)
60
    {
61
        fprintf(stderr, "test_mat_pixel_rotate_c1 failed w=%d h=%d\n", w, h);
62
        return -1;
63
    }
64

65
    return 0;
66
}
67

68
static int test_mat_pixel_rotate_c2(int w, int h)
69
{
70
    ncnn::Mat a0 = RandomMat(w, h, 2);
71

72
    ncnn::Mat a1(w, h, (size_t)2u, 2);
73
    ncnn::Mat a2(w, h, (size_t)2u, 2);
74
    ncnn::Mat a3(w, h, (size_t)2u, 2);
75
    ncnn::Mat a4(w, h, (size_t)2u, 2);
76
    ncnn::Mat a5(h, w, (size_t)2u, 2);
77
    ncnn::Mat a6(w, h, (size_t)2u, 2);
78
    ncnn::Mat a7(h, w, (size_t)2u, 2);
79
    ncnn::Mat a8(w, h, (size_t)2u, 2);
80

81
    ncnn::kanna_rotate_c2(a0, w, h, a1, w, h, 1);
82
    ncnn::kanna_rotate_c2(a1, w, h, a2, w, h, 2);
83
    ncnn::kanna_rotate_c2(a2, w, h, a3, w, h, 3);
84
    ncnn::kanna_rotate_c2(a3, w, h, a4, w, h, 4);
85
    ncnn::kanna_rotate_c2(a4, w, h, a5, h, w, 5);
86
    ncnn::kanna_rotate_c2(a5, h, w, a6, w, h, 6);
87
    ncnn::kanna_rotate_c2(a6, w, h, a7, h, w, 7);
88
    ncnn::kanna_rotate_c2(a7, h, w, a8, w, h, 8);
89

90
    if (memcmp(a0, a8, w * h * 2) != 0)
91
    {
92
        fprintf(stderr, "test_mat_pixel_rotate_c2 failed w=%d h=%d\n", w, h);
93
        return -1;
94
    }
95

96
    return 0;
97
}
98

99
static int test_mat_pixel_rotate_c3(int w, int h)
100
{
101
    ncnn::Mat a0 = RandomMat(w, h, 3);
102

103
    ncnn::Mat a1(w, h, (size_t)3u, 3);
104
    ncnn::Mat a2(w, h, (size_t)3u, 3);
105
    ncnn::Mat a3(w, h, (size_t)3u, 3);
106
    ncnn::Mat a4(w, h, (size_t)3u, 3);
107
    ncnn::Mat a5(h, w, (size_t)3u, 3);
108
    ncnn::Mat a6(w, h, (size_t)3u, 3);
109
    ncnn::Mat a7(h, w, (size_t)3u, 3);
110
    ncnn::Mat a8(w, h, (size_t)3u, 3);
111

112
    ncnn::kanna_rotate_c3(a0, w, h, a1, w, h, 1);
113
    ncnn::kanna_rotate_c3(a1, w, h, a2, w, h, 2);
114
    ncnn::kanna_rotate_c3(a2, w, h, a3, w, h, 3);
115
    ncnn::kanna_rotate_c3(a3, w, h, a4, w, h, 4);
116
    ncnn::kanna_rotate_c3(a4, w, h, a5, h, w, 5);
117
    ncnn::kanna_rotate_c3(a5, h, w, a6, w, h, 6);
118
    ncnn::kanna_rotate_c3(a6, w, h, a7, h, w, 7);
119
    ncnn::kanna_rotate_c3(a7, h, w, a8, w, h, 8);
120

121
    if (memcmp(a0, a8, w * h * 3) != 0)
122
    {
123
        fprintf(stderr, "test_mat_pixel_rotate_c3 failed w=%d h=%d\n", w, h);
124
        return -1;
125
    }
126

127
    return 0;
128
}
129

130
static int test_mat_pixel_rotate_c4(int w, int h)
131
{
132
    ncnn::Mat a0 = RandomMat(w, h, 4);
133

134
    ncnn::Mat a1(w, h, (size_t)4u, 4);
135
    ncnn::Mat a2(w, h, (size_t)4u, 4);
136
    ncnn::Mat a3(w, h, (size_t)4u, 4);
137
    ncnn::Mat a4(w, h, (size_t)4u, 4);
138
    ncnn::Mat a5(h, w, (size_t)4u, 4);
139
    ncnn::Mat a6(w, h, (size_t)4u, 4);
140
    ncnn::Mat a7(h, w, (size_t)4u, 4);
141
    ncnn::Mat a8(w, h, (size_t)4u, 4);
142

143
    ncnn::kanna_rotate_c4(a0, w, h, a1, w, h, 1);
144
    ncnn::kanna_rotate_c4(a1, w, h, a2, w, h, 2);
145
    ncnn::kanna_rotate_c4(a2, w, h, a3, w, h, 3);
146
    ncnn::kanna_rotate_c4(a3, w, h, a4, w, h, 4);
147
    ncnn::kanna_rotate_c4(a4, w, h, a5, h, w, 5);
148
    ncnn::kanna_rotate_c4(a5, h, w, a6, w, h, 6);
149
    ncnn::kanna_rotate_c4(a6, w, h, a7, h, w, 7);
150
    ncnn::kanna_rotate_c4(a7, h, w, a8, w, h, 8);
151

152
    if (memcmp(a0, a8, w * h * 4) != 0)
153
    {
154
        fprintf(stderr, "test_mat_pixel_rotate_c4 failed w=%d h=%d\n", w, h);
155
        return -1;
156
    }
157

158
    return 0;
159
}
160

161
static int test_mat_pixel_rotate_0()
162
{
163
    return 0
164
           || test_mat_pixel_rotate_c1(6, 7)
165
           || test_mat_pixel_rotate_c2(6, 7)
166
           || test_mat_pixel_rotate_c3(6, 7)
167
           || test_mat_pixel_rotate_c4(6, 7)
168
           || test_mat_pixel_rotate_c1(12, 16)
169
           || test_mat_pixel_rotate_c2(12, 16)
170
           || test_mat_pixel_rotate_c3(12, 16)
171
           || test_mat_pixel_rotate_c4(12, 16)
172
           || test_mat_pixel_rotate_c1(22, 33)
173
           || test_mat_pixel_rotate_c2(22, 33)
174
           || test_mat_pixel_rotate_c3(22, 33)
175
           || test_mat_pixel_rotate_c4(22, 33);
176
}
177

178
static int test_mat_pixel_rotate_yuv420sp(int w, int h)
179
{
180
    ncnn::Mat a0 = RandomMat(w, h * 3 / 2, 1);
181

182
    ncnn::Mat a1(w, h * 3 / 2, (size_t)1u, 1);
183
    ncnn::Mat a2(w, h * 3 / 2, (size_t)1u, 1);
184
    ncnn::Mat a3(w, h * 3 / 2, (size_t)1u, 1);
185
    ncnn::Mat a4(w, h * 3 / 2, (size_t)1u, 1);
186
    ncnn::Mat a5(h, w * 3 / 2, (size_t)1u, 1);
187
    ncnn::Mat a6(w, h * 3 / 2, (size_t)1u, 1);
188
    ncnn::Mat a7(h, w * 3 / 2, (size_t)1u, 1);
189
    ncnn::Mat a8(w, h * 3 / 2, (size_t)1u, 1);
190

191
    ncnn::kanna_rotate_yuv420sp(a0, w, h, a1, w, h, 1);
192
    ncnn::kanna_rotate_yuv420sp(a1, w, h, a2, w, h, 2);
193
    ncnn::kanna_rotate_yuv420sp(a2, w, h, a3, w, h, 3);
194
    ncnn::kanna_rotate_yuv420sp(a3, w, h, a4, w, h, 4);
195
    ncnn::kanna_rotate_yuv420sp(a4, w, h, a5, h, w, 5);
196
    ncnn::kanna_rotate_yuv420sp(a5, h, w, a6, w, h, 6);
197
    ncnn::kanna_rotate_yuv420sp(a6, w, h, a7, h, w, 7);
198
    ncnn::kanna_rotate_yuv420sp(a7, h, w, a8, w, h, 8);
199

200
    if (memcmp(a0, a8, w * h * 3 / 2) != 0)
201
    {
202
        fprintf(stderr, "test_mat_pixel_rotate_yuv420sp failed w=%d h=%d\n", w, h);
203
        return -1;
204
    }
205

206
    return 0;
207
}
208

209
static int test_mat_pixel_rotate_1()
210
{
211
    return 0
212
           || test_mat_pixel_rotate_yuv420sp(6, 4)
213
           || test_mat_pixel_rotate_yuv420sp(12, 16)
214
           || test_mat_pixel_rotate_yuv420sp(22, 34);
215
}
216

217
int main()
218
{
219
    SRAND(7767517);
220

221
    return 0
222
           || test_mat_pixel_rotate_0()
223
           || test_mat_pixel_rotate_1();
224
}
225