History

Reduce usage of flexible array fields

evpobr committed 6 years ago

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

Showing the changes to src (3 of 3 files). Show all

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
3131 bool dirty ;
3232 long in_count, in_used ;
3333 long out_count, out_gen ;
34− float last_value [] ;
34+ float *last_value ;
3535 } LINEAR_DATA ;
3636
3737 /*----------------------------------------------------------------------------------------
@@ -160,7 +160,8 @@ linear_get_description (int src_enum) · 122 unmodified lines
160160
161161 enum SRC_ERR
162162 linear_set_converter (SRC_STATE *state, int src_enum)
163−{ LINEAR_DATA *priv = NULL ;
163+{
164+ LINEAR_DATA *priv = NULL ;
164165
165166 if (src_enum != SRC_LINEAR)
166167 return SRC_ERR_BAD_CONVERTER ;
@@ -168,13 +169,24 @@ linear_set_converter (SRC_STATE *state, int src_enum) · 1 unmodified line
168169 linear_close (state) ;
169170
170171 if (state->private_data == NULL)
171− { priv = ZERO_ALLOC (LINEAR_DATA, sizeof (*priv) + state->channels * sizeof (float)) ;
172− state->private_data = priv ;
173− } ;
172+ {
173+ priv = ZERO_ALLOC (ZOH_DATA, sizeof (*priv)) ;
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+ }
174184
175185 if (priv == NULL)
176186 return SRC_ERR_MALLOC_FAILED ;
177187
188+ state->private_data = priv ;
189+
178190 priv->linear_magic_marker = LINEAR_MAGIC_MARKER ;
179191
180192 state->const_process = linear_vari_process ;
@@ -213,12 +225,18 @@ linear_copy (SRC_STATE *from, SRC_STATE *to) · 32 unmodified lines
213225
214226 LINEAR_DATA *to_priv = NULL ;
215227 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 ;
217230
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) ;
219236 return SRC_ERR_MALLOC_FAILED ;
237+ }
238+ memcpy (to_priv->last_value, from_priv->last_value, sizeof (float) * from->channels) ;
220239
221− memcpy (to_priv, from_priv, private_size) ;
222240 to->private_data = to_priv ;
223241
224242 return SRC_ERR_NO_ERROR ;
@@ -229,10 +247,15 @@ linear_close (SRC_STATE *state) · 4 unmodified lines
229247 {
230248 if (state)
231249 {
232− if (state->private_data)
250+ LINEAR_DATA *linear = (LINEAR_DATA *) state->private_data ;
251+ if (linear)
233252 {
234− free (state->private_data) ;
235− state->private_data = NULL ;
253+ if (linear->last_value)
254+ { free (linear->last_value) ;
255+ linear->last_value = NULL ;
256+ } ;
257+ free (linear) ;
258+ linear = NULL ;
236259 }
237260 }
238261 } /* linear_close */
src/src_sinc.c+25−9
@@ -53,8 +53,7 @@ typedef struct · 52 unmodified lines
5353 /* Sure hope noone does more than 128 channels at once. */
5454 double left_calc [128], right_calc [128] ;
5555
56− /* C99 struct flexible array. */
57− float buffer [] ;
56+ float *buffer ;
5857 } SINC_FILTER ;
5958
6059 static 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
220219 temp_filter.b_len *= state->channels ;
221220 temp_filter.b_len += 1 ; // There is a <= check against samples_in_hand requiring a buffer bigger than the calculation above
222221
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)
224223 return SRC_ERR_MALLOC_FAILED ;
225224
226225 *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+
227232 memset (&temp_filter, 0xEE, sizeof (temp_filter)) ;
228233
229234 state->private_data = filter ;
@@ -267,12 +272,18 @@ sinc_copy (SRC_STATE *from, SRC_STATE *to) · 37 unmodified lines
267272
268273 SINC_FILTER *to_filter = NULL ;
269274 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) ;
271275
272− if ((to_filter = ZERO_ALLOC (SINC_FILTER, private_length)) == NULL)
276+ if ((to_filter = ZERO_ALLOC (SINC_FILTER, sizeof (SINC_FILTER))) == NULL)
273277 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)) ;
274286
275− memcpy (to_filter, from_filter, private_length) ;
276287 to->private_data = to_filter ;
277288
278289 return SRC_ERR_NO_ERROR ;
@@ -1150,10 +1161,15 @@ sinc_close (SRC_STATE *state) · 871 unmodified lines
11501161 {
11511162 if (state)
11521163 {
1153− if (state->private_data)
1164+ SINC_FILTER *sinc = (SINC_FILTER *) state->private_data ;
1165+ if (sinc)
11541166 {
1155− free (state->private_data) ;
1156− state->private_data = NULL ;
1167+ if (sinc->buffer)
1168+ { free (sinc->buffer) ;
1169+ sinc->buffer = NULL ;
1170+ } ;
1171+ free (sinc) ;
1172+ sinc = NULL ;
11571173 }
11581174 }
11591175 } /* sinc_close */
src/src_zoh.c+35−12
@@ -29,7 +29,7 @@ typedef struct · 28 unmodified lines
2929 bool dirty ;
3030 long in_count, in_used ;
3131 long out_count, out_gen ;
32− float last_value [] ;
32+ float *last_value ;
3333 } ZOH_DATA ;
3434
3535 /*----------------------------------------------------------------------------------------
@@ -151,7 +151,8 @@ zoh_get_description (int src_enum) · 115 unmodified lines
151151
152152 enum SRC_ERR
153153 zoh_set_converter (SRC_STATE *state, int src_enum)
154−{ ZOH_DATA *priv = NULL ;
154+{
155+ ZOH_DATA *priv = NULL ;
155156
156157 if (src_enum != SRC_ZERO_ORDER_HOLD)
157158 return SRC_ERR_BAD_CONVERTER ;
@@ -159,13 +160,24 @@ zoh_set_converter (SRC_STATE *state, int src_enum) · 1 unmodified line
159160 zoh_close (state) ;
160161
161162 if (state->private_data == NULL)
162− { priv = ZERO_ALLOC (ZOH_DATA, sizeof (*priv) + state->channels * sizeof (float)) ;
163− state->private_data = priv ;
164− } ;
163+ {
164+ priv = ZERO_ALLOC (ZOH_DATA, sizeof (*priv)) ;
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+ }
165175
166176 if (priv == NULL)
167177 return SRC_ERR_MALLOC_FAILED ;
168178
179+ state->private_data = priv ;
180+
169181 priv->zoh_magic_marker = ZOH_MAGIC_MARKER ;
170182
171183 state->const_process = zoh_vari_process ;
@@ -191,7 +203,7 @@ zoh_reset (SRC_STATE *state) · 19 unmodified lines
191203 return ;
192204
193205 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) ;
195207
196208 return ;
197209 } /* zoh_reset */
@@ -204,12 +216,18 @@ zoh_copy (SRC_STATE *from, SRC_STATE *to) · 6 unmodified lines
204216
205217 ZOH_DATA *to_priv = NULL ;
206218 ZOH_DATA* from_priv = (ZOH_DATA*) from->private_data ;
207− size_t private_size = sizeof (*to_priv) + from->channels * sizeof (float) ;
208219
209− if ((to_priv = ZERO_ALLOC (ZOH_DATA, private_size)) == NULL)
220+ if ((to_priv = ZERO_ALLOC (ZOH_DATA, sizeof (ZOH_DATA))) == NULL)
210221 return SRC_ERR_MALLOC_FAILED ;
211222
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+
213231 to->private_data = to_priv ;
214232
215233 return SRC_ERR_NO_ERROR ;
@@ -220,10 +238,15 @@ zoh_close (SRC_STATE *state) · 4 unmodified lines
220238 {
221239 if (state)
222240 {
223− if (state->private_data)
241+ ZOH_DATA *zoh = (ZOH_DATA *) state->private_data ;
242+ if (zoh)
224243 {
225− free (state->private_data) ;
226− state->private_data = NULL ;
244+ if (zoh->last_value)
245+ { free (zoh->last_value) ;
246+ zoh->last_value = NULL ;
247+ } ;
248+ free (zoh) ;
249+ zoh = NULL ;
227250 }
228251 }
229252 } /* 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