/src/cmp_tool/test/fuzz/fuzz_data_producer.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (c) Meta Platforms, Inc. and affiliates. |
3 | | * All rights reserved. |
4 | | * |
5 | | * This source code is licensed under both the BSD-style license (found in the |
6 | | * LICENSE.BSD-3.Zstandard file in the 3rdparty_licenses directory) and the GPLv2 |
7 | | * (found in the LICENSE.GPL-2 file in the 3rdparty_licenses directory). |
8 | | * You may select, at your option, one of the above-listed licenses. |
9 | | */ |
10 | | |
11 | | /** |
12 | | * Modifications made by |
13 | | * @author Dominik Loidolt (dominik.loidolt@univie.ac.at) |
14 | | * @date 2024 |
15 | | * @see https://github.com/facebook/zstd/issues/1723 |
16 | | * |
17 | | * - Added function providing a cmp_par struct |
18 | | * |
19 | | * Modifications are also licensed under the same license for consistency |
20 | | * |
21 | | */ |
22 | | |
23 | | |
24 | | #include "fuzz_helpers.h" |
25 | | #include "fuzz_data_producer.h" |
26 | | #include <cmp_chunk.h> |
27 | | |
28 | | struct FUZZ_dataProducer_s { |
29 | | const uint8_t *data; |
30 | | size_t size; |
31 | | }; |
32 | | |
33 | | FUZZ_dataProducer_t *FUZZ_dataProducer_create(const uint8_t *data, size_t size) |
34 | 1.38k | { |
35 | 1.38k | FUZZ_dataProducer_t *producer = FUZZ_malloc(sizeof(FUZZ_dataProducer_t)); |
36 | | |
37 | 1.38k | producer->data = data; |
38 | 1.38k | producer->size = size; |
39 | 1.38k | return producer; |
40 | 1.38k | } |
41 | | |
42 | | void FUZZ_dataProducer_free(FUZZ_dataProducer_t *producer) |
43 | 1.38k | { |
44 | 1.38k | free(producer); |
45 | 1.38k | } |
46 | | |
47 | | uint32_t FUZZ_dataProducer_uint32Range(FUZZ_dataProducer_t *producer, uint32_t min, |
48 | | uint32_t max) |
49 | 89.7k | { |
50 | 89.7k | uint32_t range = max - min; |
51 | 89.7k | uint32_t rolling = range; |
52 | 89.7k | uint32_t result = 0; |
53 | | |
54 | 89.7k | FUZZ_ASSERT(min <= max); |
55 | | |
56 | 405k | while (rolling > 0 && producer->size > 0) { |
57 | 316k | uint8_t next = *(producer->data + producer->size - 1); |
58 | | |
59 | 316k | producer->size -= 1; |
60 | 316k | result = (result << 8) | next; |
61 | 316k | rolling >>= 8; |
62 | 316k | } |
63 | | |
64 | 89.7k | if (range == 0xffffffff) |
65 | 82.8k | return result; |
66 | | |
67 | 6.90k | return min + result % (range + 1); |
68 | 89.7k | } |
69 | | |
70 | | uint32_t FUZZ_dataProducer_uint32(FUZZ_dataProducer_t *producer) |
71 | 82.8k | { |
72 | 82.8k | return FUZZ_dataProducer_uint32Range(producer, 0, 0xffffffff); |
73 | 82.8k | } |
74 | | |
75 | | int32_t FUZZ_dataProducer_int32Range(FUZZ_dataProducer_t *producer, |
76 | | int32_t min, int32_t max) |
77 | 1.38k | { |
78 | 1.38k | FUZZ_ASSERT(min <= max); |
79 | | |
80 | 1.38k | if (min < 0) |
81 | 0 | return (int)FUZZ_dataProducer_uint32Range(producer, 0, max - min) + min; |
82 | | |
83 | 1.38k | return FUZZ_dataProducer_uint32Range(producer, min, max); |
84 | 1.38k | } |
85 | | |
86 | | size_t FUZZ_dataProducer_remainingBytes(FUZZ_dataProducer_t *producer) |
87 | 0 | { |
88 | 0 | return producer->size; |
89 | 0 | } |
90 | | |
91 | | void FUZZ_dataProducer_rollBack(FUZZ_dataProducer_t *producer, size_t remainingBytes) |
92 | 0 | { |
93 | 0 | FUZZ_ASSERT(remainingBytes >= producer->size); |
94 | 0 | producer->size = remainingBytes; |
95 | 0 | } |
96 | | |
97 | | int FUZZ_dataProducer_empty(FUZZ_dataProducer_t *producer) |
98 | 0 | { |
99 | 0 | return producer->size == 0; |
100 | 0 | } |
101 | | |
102 | | size_t FUZZ_dataProducer_contract(FUZZ_dataProducer_t *producer, size_t newSize) |
103 | 1.38k | { |
104 | 1.38k | size_t remaining; |
105 | | |
106 | 1.38k | newSize = newSize > producer->size ? producer->size : newSize; |
107 | 1.38k | remaining = producer->size - newSize; |
108 | 1.38k | producer->data = producer->data + remaining; |
109 | 1.38k | producer->size = newSize; |
110 | 1.38k | return remaining; |
111 | 1.38k | } |
112 | | |
113 | | size_t FUZZ_dataProducer_reserveDataPrefix(FUZZ_dataProducer_t *producer) |
114 | 1.38k | { |
115 | 1.38k | size_t producerSliceSize = FUZZ_dataProducer_uint32Range( |
116 | 1.38k | producer, 0, producer->size); |
117 | 1.38k | return FUZZ_dataProducer_contract(producer, producerSliceSize); |
118 | 1.38k | } |
119 | | |
120 | | void FUZZ_dataProducer_cmp_par(FUZZ_dataProducer_t *producer, struct cmp_par *cmp_par) |
121 | 2.76k | { |
122 | 2.76k | cmp_par->cmp_mode = (enum cmp_mode)FUZZ_dataProducer_uint32(producer); |
123 | 2.76k | cmp_par->model_value = FUZZ_dataProducer_uint32(producer); |
124 | 2.76k | cmp_par->lossy_par = FUZZ_dataProducer_uint32(producer); |
125 | | |
126 | 2.76k | cmp_par->nc_imagette = FUZZ_dataProducer_uint32(producer); |
127 | | |
128 | 2.76k | cmp_par->s_exp_flags = FUZZ_dataProducer_uint32(producer); |
129 | 2.76k | cmp_par->s_fx = FUZZ_dataProducer_uint32(producer); |
130 | 2.76k | cmp_par->s_ncob = FUZZ_dataProducer_uint32(producer); |
131 | 2.76k | cmp_par->s_efx = FUZZ_dataProducer_uint32(producer); |
132 | 2.76k | cmp_par->s_ecob = FUZZ_dataProducer_uint32(producer); |
133 | | |
134 | 2.76k | cmp_par->l_exp_flags = FUZZ_dataProducer_uint32(producer); |
135 | 2.76k | cmp_par->l_fx = FUZZ_dataProducer_uint32(producer); |
136 | 2.76k | cmp_par->l_ncob = FUZZ_dataProducer_uint32(producer); |
137 | 2.76k | cmp_par->l_efx = FUZZ_dataProducer_uint32(producer); |
138 | 2.76k | cmp_par->l_ecob = FUZZ_dataProducer_uint32(producer); |
139 | 2.76k | cmp_par->l_fx_cob_variance = FUZZ_dataProducer_uint32(producer); |
140 | | |
141 | 2.76k | cmp_par->saturated_imagette = FUZZ_dataProducer_uint32(producer); |
142 | | |
143 | 2.76k | cmp_par->nc_offset_mean = FUZZ_dataProducer_uint32(producer); |
144 | 2.76k | cmp_par->nc_offset_variance = FUZZ_dataProducer_uint32(producer); |
145 | 2.76k | cmp_par->nc_background_mean = FUZZ_dataProducer_uint32(producer); |
146 | 2.76k | cmp_par->nc_background_variance = FUZZ_dataProducer_uint32(producer); |
147 | 2.76k | cmp_par->nc_background_outlier_pixels = FUZZ_dataProducer_uint32(producer); |
148 | | |
149 | 2.76k | cmp_par->smearing_mean = FUZZ_dataProducer_uint32(producer); |
150 | 2.76k | cmp_par->smearing_variance_mean = FUZZ_dataProducer_uint32(producer); |
151 | 2.76k | cmp_par->smearing_outlier_pixels = FUZZ_dataProducer_uint32(producer); |
152 | | |
153 | 2.76k | cmp_par->fc_imagette = FUZZ_dataProducer_uint32(producer); |
154 | 2.76k | cmp_par->fc_offset_mean = FUZZ_dataProducer_uint32(producer); |
155 | 2.76k | cmp_par->fc_offset_variance = FUZZ_dataProducer_uint32(producer); |
156 | 2.76k | cmp_par->fc_background_mean = FUZZ_dataProducer_uint32(producer); |
157 | 2.76k | cmp_par->fc_background_variance = FUZZ_dataProducer_uint32(producer); |
158 | 2.76k | cmp_par->fc_background_outlier_pixels = FUZZ_dataProducer_uint32(producer); |
159 | 2.76k | } |