Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * cached bitstream reader test | ||
3 | * copyright (c) 2022 Anton Khirnov <anton@khirnov.net> | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | #define ASSERT_LEVEL 2 | ||
23 | |||
24 | #include "libavutil/avassert.h" | ||
25 | #include "libavutil/lfg.h" | ||
26 | #include "libavutil/random_seed.h" | ||
27 | |||
28 | #include "libavcodec/bitstream.h" | ||
29 | #include "libavcodec/defs.h" | ||
30 | |||
31 | #ifdef BITSTREAM_LE | ||
32 | #define BITSTREAM_WRITER_LE | ||
33 | #endif | ||
34 | #include "libavcodec/put_bits.h" | ||
35 | |||
36 | #define SIZE 157 | ||
37 | |||
38 | enum Op { | ||
39 | OP_READ, | ||
40 | OP_READ_NZ, | ||
41 | OP_READ_BIT, | ||
42 | OP_READ_63, | ||
43 | OP_READ_64, | ||
44 | OP_READ_SIGNED, | ||
45 | OP_READ_SIGNED_NZ, | ||
46 | OP_APPLY_SIGN, | ||
47 | OP_ALIGN, | ||
48 | OP_NB, | ||
49 | }; | ||
50 | |||
51 | 2 | int main(int argc, char **argv) | |
52 | { | ||
53 | BitstreamContext bc; | ||
54 | PutBitContext pb; | ||
55 | AVLFG lfg; | ||
56 | |||
57 | uint8_t buf[SIZE + AV_INPUT_BUFFER_PADDING_SIZE]; | ||
58 | uint8_t dst[SIZE + AV_INPUT_BUFFER_PADDING_SIZE]; | ||
59 | |||
60 | uint32_t random_seed; | ||
61 | uint64_t val, val1; | ||
62 | int32_t sval, sval1; | ||
63 | unsigned count; | ||
64 | |||
65 | /* generate random input, using a given or random seed */ | ||
66 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (argc > 1) |
67 | ✗ | random_seed = strtoul(argv[1], NULL, 0); | |
68 | else | ||
69 | 2 | random_seed = av_get_random_seed(); | |
70 | |||
71 | 2 | fprintf(stderr, "Testing with LFG seed: %"PRIu32"\n", random_seed); | |
72 | 2 | av_lfg_init(&lfg, random_seed); | |
73 | |||
74 |
2/2✓ Branch 0 taken 314 times.
✓ Branch 1 taken 2 times.
|
316 | for (unsigned i = 0; i < SIZE; i++) |
75 | 314 | buf[i] = av_lfg_get(&lfg); | |
76 | |||
77 | 2 | bits_init8 (&bc, buf, SIZE); | |
78 | 2 | init_put_bits(&pb, dst, SIZE); | |
79 | |||
80 | /* use a random sequence of bitreading operations to transfer data | ||
81 | * from BitstreamContext to PutBitContext */ | ||
82 |
2/2✓ Branch 1 taken 144 times.
✓ Branch 2 taken 2 times.
|
146 | while (bits_left(&bc) > 0) { |
83 | 144 | enum Op op = av_lfg_get(&lfg) % OP_NB; | |
84 | |||
85 |
9/10✓ Branch 0 taken 18 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 22 times.
✓ Branch 5 taken 15 times.
✓ Branch 6 taken 16 times.
✓ Branch 7 taken 10 times.
✓ Branch 8 taken 19 times.
✗ Branch 9 not taken.
|
144 | switch (op) { |
86 | 18 | case OP_READ: | |
87 |
2/2✓ Branch 2 taken 3 times.
✓ Branch 3 taken 15 times.
|
18 | count = av_lfg_get(&lfg) % FFMIN(33, bits_left(&bc) + 1); |
88 | 18 | val1 = bits_peek(&bc, count); | |
89 | 18 | val = bits_read(&bc, count); | |
90 | |||
91 | 18 | fprintf(stderr, "%d read %u: %"PRIu64"\n", bits_tell(&bc) - count, count, val); | |
92 | |||
93 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | av_assert0(val == val1); |
94 | |||
95 | 18 | put_bits64(&pb, count, val); | |
96 | 18 | break; | |
97 | 13 | case OP_READ_NZ: | |
98 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 13 times.
|
13 | count = av_lfg_get(&lfg) % FFMIN(33, bits_left(&bc) + 1); |
99 | 13 | count = FFMAX(count, 1); | |
100 | 13 | val1 = bits_peek_nz(&bc, count); | |
101 | 13 | val = bits_read_nz(&bc, count); | |
102 | |||
103 | 13 | fprintf(stderr, "%d read_nz %u: %"PRIu64"\n", bits_tell(&bc) - count, count, val); | |
104 | |||
105 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | av_assert0(val == val1); |
106 | |||
107 | 13 | put_bits64(&pb, count, val); | |
108 | 13 | break; | |
109 | 15 | case OP_READ_BIT: | |
110 | 15 | val = bits_read_bit(&bc); | |
111 | |||
112 | 15 | fprintf(stderr, "%d read_bit: %"PRIu64"\n", bits_tell(&bc) - 1, val); | |
113 | |||
114 | 15 | put_bits(&pb, 1, val); | |
115 | 15 | break; | |
116 | 16 | case OP_READ_63: | |
117 |
2/2✓ Branch 2 taken 3 times.
✓ Branch 3 taken 13 times.
|
16 | count = av_lfg_get(&lfg) % FFMIN(64, bits_left(&bc) + 1); |
118 | 16 | val = bits_read_63(&bc, count); | |
119 | |||
120 | 16 | fprintf(stderr, "%d read_63 %u: %"PRIu64"\n", bits_tell(&bc) - count, count, val); | |
121 | |||
122 | 16 | put_bits64(&pb, count, val); | |
123 | 16 | break; | |
124 | 22 | case OP_READ_64: | |
125 |
2/2✓ Branch 2 taken 1 times.
✓ Branch 3 taken 21 times.
|
22 | count = av_lfg_get(&lfg) % FFMIN(65, bits_left(&bc) + 1); |
126 | 22 | val = bits_read_64(&bc, count); | |
127 | |||
128 | 22 | fprintf(stderr, "%d read_64 %u: %"PRIu64"\n", bits_tell(&bc) - count, count, val); | |
129 | |||
130 | 22 | put_bits64(&pb, count, val); | |
131 | 22 | break; | |
132 | 15 | case OP_READ_SIGNED: | |
133 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
|
15 | count = av_lfg_get(&lfg) % FFMIN(33, bits_left(&bc) + 1); |
134 | 15 | sval1 = bits_peek_signed(&bc, count); | |
135 | 15 | sval = bits_read_signed(&bc, count); | |
136 | |||
137 | 15 | fprintf(stderr, "%d read_signed %u: %"PRId32"\n", bits_tell(&bc) - count, count, sval); | |
138 | |||
139 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | av_assert0(sval == sval1); |
140 | |||
141 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | if (count == 32) put_bits32(&pb, sval); |
142 | 15 | else put_sbits(&pb, count, sval); | |
143 | 15 | break; | |
144 | 16 | case OP_READ_SIGNED_NZ: | |
145 |
2/2✓ Branch 2 taken 1 times.
✓ Branch 3 taken 15 times.
|
16 | count = av_lfg_get(&lfg) % FFMIN(33, bits_left(&bc) + 1); |
146 | 16 | count = FFMAX(count, 1); | |
147 | 16 | sval1 = bits_peek_signed_nz(&bc, count); | |
148 | 16 | sval = bits_read_signed_nz(&bc, count); | |
149 | |||
150 | 16 | fprintf(stderr, "%d read_signed_nz %u: %"PRId32"\n", bits_tell(&bc) - count, count, sval); | |
151 | |||
152 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
|
16 | av_assert0(sval == sval1); |
153 | |||
154 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 15 times.
|
16 | if (count == 32) put_bits32(&pb, sval); |
155 | 15 | else put_sbits(&pb, count, sval); | |
156 | 16 | break; | |
157 | 10 | case OP_ALIGN: | |
158 | 10 | count = (bits_tell(&bc) + 7) / 8 * 8 - bits_tell(&bc); | |
159 | |||
160 | 10 | fprintf(stderr, "%d align %u\n", bits_tell(&bc), count); | |
161 | |||
162 | 10 | put_bits(&pb, count, bits_peek(&bc, count)); | |
163 | 10 | bits_align(&bc); | |
164 | 10 | break; | |
165 | 19 | case OP_APPLY_SIGN: | |
166 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
|
19 | if (bits_left(&bc) < 2) |
167 | ✗ | continue; | |
168 | |||
169 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 19 times.
|
19 | count = av_lfg_get(&lfg) % FFMIN(32, bits_left(&bc)); |
170 | 19 | count = FFMAX(count, 1); | |
171 | |||
172 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
|
19 | if (!bits_peek(&bc, count)) |
173 | ✗ | continue; | |
174 | |||
175 | 19 | val = bits_read(&bc, count); | |
176 | 19 | sval = bits_apply_sign(&bc, val); | |
177 | |||
178 | 19 | fprintf(stderr, "%d apply_sign %u %"PRId32"\n", | |
179 | 19 | bits_tell(&bc) - count - 1, count, sval); | |
180 | |||
181 | 19 | put_bits64(&pb, count, FFABS(sval)); | |
182 | 19 | put_bits(&pb, 1, sval < 0); | |
183 | |||
184 | 19 | break; | |
185 | ✗ | default: | |
186 | ✗ | av_assert0(0); | |
187 | } | ||
188 | } | ||
189 | |||
190 | 2 | flush_put_bits(&pb); | |
191 | |||
192 |
2/2✓ Branch 0 taken 314 times.
✓ Branch 1 taken 2 times.
|
316 | for (unsigned i = 0; i < SIZE; i++) |
193 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 314 times.
|
314 | if (buf[i] != dst[i]) { |
194 | ✗ | fprintf(stderr, "Mismatch at byte %u: %hhu %hhu; seed %"PRIu32"\n", | |
195 | ✗ | i, buf[i], dst[i], random_seed); | |
196 | ✗ | return 1; | |
197 | } | ||
198 | |||
199 | 2 | return 0; | |
200 | } | ||
201 |