History

Reduce usage of flexible array fields

evpobr committed 6 years ago

Commit 36dfd681 parent 8a83ad33 files · +94 −32Browse files

Unified · Split

3 files
  1. src/src_linear.c +34 −11
  2. src/src_sinc.c +25 −9
  3. src/src_zoh.c +35 −12
src/src_linear.c+34−11
@@ -31,7 +31,7 @@ typedef struct · 30 unmodified lines
31 bool dirty ;31 bool dirty ;
32 long in_count, in_used ;32 long in_count, in_used ;
33 long out_count, out_gen ;33 long out_count, out_gen ;
34 float last_value [] ;34 float *last_value ;
35} LINEAR_DATA ;35} LINEAR_DATA ;
36 36
37/*----------------------------------------------------------------------------------------37/*----------------------------------------------------------------------------------------
@@ -160,7 +160,8 @@ linear_get_description (int src_enum) · 122 unmodified lines
160 160
161enum SRC_ERR161enum SRC_ERR
162linear_set_converter (SRC_STATE *state, int src_enum)162linear_set_converter (SRC_STATE *state, int src_enum)
163{ LINEAR_DATA *priv = NULL ;163{
164 LINEAR_DATA *priv = NULL ;
164 165
165 if (src_enum != SRC_LINEAR)166 if (src_enum != SRC_LINEAR)
166 return SRC_ERR_BAD_CONVERTER ;167 return SRC_ERR_BAD_CONVERTER ;
@@ -168,13 +169,24 @@ linear_set_converter (SRC_STATE *state, int src_enum) · 1 unmodified line
168 linear_close (state) ;169 linear_close (state) ;
169 170
170 if (state->private_data == NULL)171 if (state->private_data == NULL)
171 { priv = ZERO_ALLOC (LINEAR_DATA, sizeof (*priv) + state->channels * sizeof (float)) ;172 {
172 state->private_data = priv ;173 priv = ZERO_ALLOC (ZOH_DATA, sizeof (*priv)) ;
173 } ;174 if (priv)
175 {
176 priv->last_value = calloc (state->channels, sizeof (float)) ;
177 if (!priv->last_value)
178 {
179 free (priv) ;
180 priv = NULL ;
181 }
182 }
183 }
174 184
175 if (priv == NULL)185 if (priv == NULL)
176 return SRC_ERR_MALLOC_FAILED ;186 return SRC_ERR_MALLOC_FAILED ;
177 187
188 state->private_data = priv ;
189
178 priv->linear_magic_marker = LINEAR_MAGIC_MARKER ;190 priv->linear_magic_marker = LINEAR_MAGIC_MARKER ;
179 191
180 state->const_process = linear_vari_process ;192 state->const_process = linear_vari_process ;
@@ -213,12 +225,18 @@ linear_copy (SRC_STATE *from, SRC_STATE *to) · 32 unmodified lines
213 225
214 LINEAR_DATA *to_priv = NULL ;226 LINEAR_DATA *to_priv = NULL ;
215 LINEAR_DATA* from_priv = (LINEAR_DATA*) from->private_data ;227 LINEAR_DATA* from_priv = (LINEAR_DATA*) from->private_data ;
216 size_t private_size = sizeof (*to_priv) + from->channels * sizeof (float) ;228 if ((to_priv = ZERO_ALLOC (LINEAR_DATA, sizeof (LINEAR_DATA))) == NULL)
229 return SRC_ERR_MALLOC_FAILED ;
217 230
218 if ((to_priv = ZERO_ALLOC (LINEAR_DATA, private_size)) == NULL)231 memcpy (to_priv, from_priv, sizeof (LINEAR_DATA)) ;
232 to_priv->last_value = malloc (sizeof (float) * from->channels) ;
233 if (!to_priv->last_value)
234 {
235 free (to_priv) ;
219 return SRC_ERR_MALLOC_FAILED ;236 return SRC_ERR_MALLOC_FAILED ;
237 }
238 memcpy (to_priv->last_value, from_priv->last_value, sizeof (float) * from->channels) ;
220 239
221 memcpy (to_priv, from_priv, private_size) ;
222 to->private_data = to_priv ;240 to->private_data = to_priv ;
223 241
224 return SRC_ERR_NO_ERROR ;242 return SRC_ERR_NO_ERROR ;
@@ -229,10 +247,15 @@ linear_close (SRC_STATE *state) · 4 unmodified lines
229{247{
230 if (state)248 if (state)
231 {249 {
232 if (state->private_data)250 LINEAR_DATA *linear = (LINEAR_DATA *) state->private_data ;
251 if (linear)
233 {252 {
234 free (state->private_data) ;253 if (linear->last_value)
235 state->private_data = NULL ;254 { free (linear->last_value) ;
255 linear->last_value = NULL ;
256 } ;
257 free (linear) ;
258 linear = NULL ;
236 }259 }
237 }260 }
238} /* linear_close */261} /* linear_close */
src/src_sinc.c+25−9
@@ -53,8 +53,7 @@ typedef struct · 52 unmodified lines
53 /* Sure hope noone does more than 128 channels at once. */53 /* Sure hope noone does more than 128 channels at once. */
54 double left_calc [128], right_calc [128] ;54 double left_calc [128], right_calc [128] ;
55 55
56 /* C99 struct flexible array. */56 float *buffer ;
57 float buffer [] ;
58} SINC_FILTER ;57} SINC_FILTER ;
59 58
60static enum SRC_ERR sinc_multichan_vari_process (SRC_STATE *state, SRC_DATA *data) ;59static enum SRC_ERR sinc_multichan_vari_process (SRC_STATE *state, SRC_DATA *data) ;
@@ -220,10 +219,16 @@ sinc_set_converter (SRC_STATE *state, int src_enum) · 159 unmodified lines
220 temp_filter.b_len *= state->channels ;219 temp_filter.b_len *= state->channels ;
221 temp_filter.b_len += 1 ; // There is a <= check against samples_in_hand requiring a buffer bigger than the calculation above220 temp_filter.b_len += 1 ; // There is a <= check against samples_in_hand requiring a buffer bigger than the calculation above
222 221
223 if ((filter = ZERO_ALLOC (SINC_FILTER, sizeof (SINC_FILTER) + sizeof (filter->buffer [0]) * (temp_filter.b_len + state->channels))) == NULL)222 if ((filter = ZERO_ALLOC (SINC_FILTER, sizeof (SINC_FILTER))) == NULL)
224 return SRC_ERR_MALLOC_FAILED ;223 return SRC_ERR_MALLOC_FAILED ;
225 224
226 *filter = temp_filter ;225 *filter = temp_filter ;
226 filter->buffer = calloc (temp_filter.b_len + state->channels, sizeof (float)) ;
227 if (!filter->buffer)
228 { free (filter) ;
229 return SRC_ERR_MALLOC_FAILED ;
230 } ;
231
227 memset (&temp_filter, 0xEE, sizeof (temp_filter)) ;232 memset (&temp_filter, 0xEE, sizeof (temp_filter)) ;
228 233
229 state->private_data = filter ;234 state->private_data = filter ;
@@ -267,12 +272,18 @@ sinc_copy (SRC_STATE *from, SRC_STATE *to) · 37 unmodified lines
267 272
268 SINC_FILTER *to_filter = NULL ;273 SINC_FILTER *to_filter = NULL ;
269 SINC_FILTER* from_filter = (SINC_FILTER*) from->private_data ;274 SINC_FILTER* from_filter = (SINC_FILTER*) from->private_data ;
270 size_t private_length = sizeof (SINC_FILTER) + sizeof (from_filter->buffer [0]) * (from_filter->b_len + from->channels) ;
271 275
272 if ((to_filter = ZERO_ALLOC (SINC_FILTER, private_length)) == NULL)276 if ((to_filter = ZERO_ALLOC (SINC_FILTER, sizeof (SINC_FILTER))) == NULL)
273 return SRC_ERR_MALLOC_FAILED ;277 return SRC_ERR_MALLOC_FAILED ;
278 memcpy (to_filter, from_filter, sizeof (SINC_FILTER)) ;
279 to_filter->buffer = malloc (sizeof (float) * (from_filter->b_len + from->channels)) ;
280 if (!to_filter->buffer)
281 {
282 free (to_filter) ;
283 return SRC_ERR_MALLOC_FAILED ;
284 }
285 memcpy (to_filter->buffer, from_filter->buffer, sizeof (float) * (from_filter->b_len + from->channels)) ;
274 286
275 memcpy (to_filter, from_filter, private_length) ;
276 to->private_data = to_filter ;287 to->private_data = to_filter ;
277 288
278 return SRC_ERR_NO_ERROR ;289 return SRC_ERR_NO_ERROR ;
@@ -1150,10 +1161,15 @@ sinc_close (SRC_STATE *state) · 871 unmodified lines
1150{1161{
1151 if (state)1162 if (state)
1152 {1163 {
1153 if (state->private_data)1164 SINC_FILTER *sinc = (SINC_FILTER *) state->private_data ;
1165 if (sinc)
1154 {1166 {
1155 free (state->private_data) ;1167 if (sinc->buffer)
1156 state->private_data = NULL ;1168 { free (sinc->buffer) ;
1169 sinc->buffer = NULL ;
1170 } ;
1171 free (sinc) ;
1172 sinc = NULL ;
1157 }1173 }
1158 }1174 }
1159} /* sinc_close */1175} /* sinc_close */
src/src_zoh.c+35−12
@@ -29,7 +29,7 @@ typedef struct · 28 unmodified lines
29 bool dirty ;29 bool dirty ;
30 long in_count, in_used ;30 long in_count, in_used ;
31 long out_count, out_gen ;31 long out_count, out_gen ;
32 float last_value [] ;32 float *last_value ;
33} ZOH_DATA ;33} ZOH_DATA ;
34 34
35/*----------------------------------------------------------------------------------------35/*----------------------------------------------------------------------------------------
@@ -151,7 +151,8 @@ zoh_get_description (int src_enum) · 115 unmodified lines
151 151
152enum SRC_ERR152enum SRC_ERR
153zoh_set_converter (SRC_STATE *state, int src_enum)153zoh_set_converter (SRC_STATE *state, int src_enum)
154{ ZOH_DATA *priv = NULL ;154{
155 ZOH_DATA *priv = NULL ;
155 156
156 if (src_enum != SRC_ZERO_ORDER_HOLD)157 if (src_enum != SRC_ZERO_ORDER_HOLD)
157 return SRC_ERR_BAD_CONVERTER ;158 return SRC_ERR_BAD_CONVERTER ;
@@ -159,13 +160,24 @@ zoh_set_converter (SRC_STATE *state, int src_enum) · 1 unmodified line
159 zoh_close (state) ;160 zoh_close (state) ;
160 161
161 if (state->private_data == NULL)162 if (state->private_data == NULL)
162 { priv = ZERO_ALLOC (ZOH_DATA, sizeof (*priv) + state->channels * sizeof (float)) ;163 {
163 state->private_data = priv ;164 priv = ZERO_ALLOC (ZOH_DATA, sizeof (*priv)) ;
164 } ;165 if (priv)
166 {
167 priv->last_value = calloc (state->channels, sizeof (float)) ;
168 if (!priv->last_value)
169 {
170 free (priv) ;
171 priv = NULL ;
172 }
173 }
174 }
165 175
166 if (priv == NULL)176 if (priv == NULL)
167 return SRC_ERR_MALLOC_FAILED ;177 return SRC_ERR_MALLOC_FAILED ;
168 178
179 state->private_data = priv ;
180
169 priv->zoh_magic_marker = ZOH_MAGIC_MARKER ;181 priv->zoh_magic_marker = ZOH_MAGIC_MARKER ;
170 182
171 state->const_process = zoh_vari_process ;183 state->const_process = zoh_vari_process ;
@@ -191,7 +203,7 @@ zoh_reset (SRC_STATE *state) · 19 unmodified lines
191 return ;203 return ;
192 204
193 priv->dirty = false ;205 priv->dirty = false ;
194 memset (priv->last_value, 0, sizeof (priv->last_value [0]) * state->channels) ;206 memset (priv->last_value, 0, sizeof (float) * state->channels) ;
195 207
196 return ;208 return ;
197} /* zoh_reset */209} /* zoh_reset */
@@ -204,12 +216,18 @@ zoh_copy (SRC_STATE *from, SRC_STATE *to) · 6 unmodified lines
204 216
205 ZOH_DATA *to_priv = NULL ;217 ZOH_DATA *to_priv = NULL ;
206 ZOH_DATA* from_priv = (ZOH_DATA*) from->private_data ;218 ZOH_DATA* from_priv = (ZOH_DATA*) from->private_data ;
207 size_t private_size = sizeof (*to_priv) + from->channels * sizeof (float) ;
208 219
209 if ((to_priv = ZERO_ALLOC (ZOH_DATA, private_size)) == NULL)220 if ((to_priv = ZERO_ALLOC (ZOH_DATA, sizeof (ZOH_DATA))) == NULL)
210 return SRC_ERR_MALLOC_FAILED ;221 return SRC_ERR_MALLOC_FAILED ;
211 222
212 memcpy (to_priv, from_priv, private_size) ;223 memcpy (to_priv, from_priv, sizeof (ZOH_DATA)) ;
224 to_priv->last_value = malloc (sizeof (float) * from->channels) ;
225 if (!to_priv->last_value)
226 { free (to_priv) ;
227 return SRC_ERR_MALLOC_FAILED ;
228 } ;
229 memcpy (to_priv->last_value, from_priv->last_value, sizeof (float) * from->channels) ;
230
213 to->private_data = to_priv ;231 to->private_data = to_priv ;
214 232
215 return SRC_ERR_NO_ERROR ;233 return SRC_ERR_NO_ERROR ;
@@ -220,10 +238,15 @@ zoh_close (SRC_STATE *state) · 4 unmodified lines
220{238{
221 if (state)239 if (state)
222 {240 {
223 if (state->private_data)241 ZOH_DATA *zoh = (ZOH_DATA *) state->private_data ;
242 if (zoh)
224 {243 {
225 free (state->private_data) ;244 if (zoh->last_value)
226 state->private_data = NULL ;245 { free (zoh->last_value) ;
246 zoh->last_value = NULL ;
247 } ;
248 free (zoh) ;
249 zoh = NULL ;
227 }250 }
228 }251 }
229} /* zoh_close */252} /* zoh_close */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t