2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
14 #include "test/av1_txfm_test.h"
15 #include "test/util.h"
16 #include "av1/common/av1_inv_txfm1d.h"
17 #include "av1/encoder/av1_fwd_txfm1d.h"
19 typedef TX_SIZE TxSize
;
21 using libaom_test::ACMRandom
;
22 using libaom_test::input_base
;
25 const int txfm_type_num
= 2;
26 const int txfm_size_ls
[] = { 4, 8, 16, 32, 64 };
28 const TxfmFunc fwd_txfm_func_ls
[][txfm_type_num
] = {
29 { av1_fdct4
, av1_fadst4
}, { av1_fdct8
, av1_fadst8
},
30 { av1_fdct16
, av1_fadst16
}, { av1_fdct32
, nullptr },
31 { av1_fdct64
, nullptr },
34 const TxfmFunc inv_txfm_func_ls
[][txfm_type_num
] = {
35 { av1_idct4
, av1_iadst4
}, { av1_idct8
, av1_iadst8
},
36 { av1_idct16
, av1_iadst16
}, { av1_idct32
, nullptr },
37 { av1_idct64
, nullptr },
40 // the maximum stage number of fwd/inv 1d dct/adst txfm is 12
41 const int8_t cos_bit
= 13;
42 const int8_t range_bit
[12] = { 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20 };
44 void reference_idct_1d_int(const int32_t *in
, int32_t *out
, int size
) {
46 for (int i
= 0; i
< size
; ++i
) input
[i
] = in
[i
];
49 libaom_test::reference_idct_1d(input
, output
, size
);
51 for (int i
= 0; i
< size
; ++i
) {
52 ASSERT_GE(output
[i
], INT32_MIN
);
53 ASSERT_LE(output
[i
], INT32_MAX
);
54 out
[i
] = static_cast<int32_t>(round(output
[i
]));
58 void random_matrix(int32_t *dst
, int len
, ACMRandom
*rnd
) {
60 const int maxVal
= (1 << (bits
- 1)) - 1;
61 const int minVal
= -(1 << (bits
- 1));
62 for (int i
= 0; i
< len
; ++i
) {
63 if (rnd
->Rand8() % 10)
64 dst
[i
] = minVal
+ rnd
->Rand16() % (1 << bits
);
66 dst
[i
] = rnd
->Rand8() % 2 ? minVal
: maxVal
;
70 TEST(av1_inv_txfm1d
, InvAccuracyCheck
) {
71 ACMRandom
rnd(ACMRandom::DeterministicSeed());
72 const int count_test_block
= 20000;
73 const int max_error
[] = { 6, 10, 19, 31, 40 };
74 ASSERT_EQ(NELEMENTS(max_error
), TX_SIZES
);
75 ASSERT_EQ(NELEMENTS(inv_txfm_func_ls
), TX_SIZES
);
76 for (int i
= 0; i
< count_test_block
; ++i
) {
77 // choose a random transform to test
78 const TxSize tx_size
= static_cast<TxSize
>(rnd
.Rand8() % TX_SIZES
);
79 const int txfm_size
= txfm_size_ls
[tx_size
];
80 const TxfmFunc inv_txfm_func
= inv_txfm_func_ls
[tx_size
][0];
83 random_matrix(input
, txfm_size
, &rnd
);
85 // 64x64 transform assumes last 32 values are zero.
86 memset(input
+ 32, 0, 32 * sizeof(input
[0]));
88 int32_t ref_output
[64];
89 memset(ref_output
, 0, sizeof(ref_output
));
90 reference_idct_1d_int(input
, ref_output
, txfm_size
);
93 memset(output
, 0, sizeof(output
));
94 inv_txfm_func(input
, output
, cos_bit
, range_bit
);
96 for (int ni
= 0; ni
< txfm_size
; ++ni
) {
97 EXPECT_LE(abs(output
[ni
] - ref_output
[ni
]), max_error
[tx_size
])
98 << "tx_size = " << tx_size
<< ", ni = " << ni
99 << ", output[ni] = " << output
[ni
]
100 << ", ref_output[ni] = " << ref_output
[ni
];
105 static INLINE
int get_max_bit(int x
) {
114 TEST(av1_inv_txfm1d
, get_max_bit
) {
115 int max_bit
= get_max_bit(8);
116 EXPECT_EQ(max_bit
, 3);
119 TEST(av1_inv_txfm1d
, round_trip
) {
120 ACMRandom
rnd(ACMRandom::DeterministicSeed());
121 for (int si
= 0; si
< NELEMENTS(fwd_txfm_func_ls
); ++si
) {
122 int txfm_size
= txfm_size_ls
[si
];
124 for (int ti
= 0; ti
< txfm_type_num
; ++ti
) {
125 TxfmFunc fwd_txfm_func
= fwd_txfm_func_ls
[si
][ti
];
126 TxfmFunc inv_txfm_func
= inv_txfm_func_ls
[si
][ti
];
129 if (!fwd_txfm_func
) continue;
131 const int count_test_block
= 5000;
132 for (int i
= 0; i
< count_test_block
; ++i
) {
135 int32_t round_trip_output
[64];
137 ASSERT_LE(txfm_size
, NELEMENTS(input
));
139 for (int ni
= 0; ni
< txfm_size
; ++ni
) {
140 input
[ni
] = rnd
.Rand16() % input_base
- rnd
.Rand16() % input_base
;
143 fwd_txfm_func(input
, output
, cos_bit
, range_bit
);
144 inv_txfm_func(output
, round_trip_output
, cos_bit
, range_bit
);
146 for (int ni
= 0; ni
< txfm_size
; ++ni
) {
148 abs(input
[ni
] - round_shift(round_trip_output
[ni
],
149 get_max_bit(txfm_size
) - 1));
150 EXPECT_LE(node_err
, max_error
);