Rename SRC_PRIVATE_tag to SRC_STATE_tag, now SRC_STATE is typedef of exsiting struct.
Showing the changes to src/src_linear.c (1 of 5 files). Show all
Unified · Split
| @@ -14,9 +14,9 @@ · 13 unmodified lines | ||
| 14 | 14 | #include "src_config.h" |
| 15 | 15 | #include "common.h" |
| 16 | 16 | |
| 17 | −static int linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) ; | |
| 18 | −static void linear_reset (SRC_PRIVATE *psrc) ; | |
| 19 | −static int linear_copy (SRC_PRIVATE *from, SRC_PRIVATE *to) ; | |
| 17 | +static int linear_vari_process (SRC_STATE *state, SRC_DATA *data) ; | |
| 18 | +static void linear_reset (SRC_STATE *state) ; | |
| 19 | +static int linear_copy (SRC_STATE *from, SRC_STATE *to) ; | |
| 20 | 20 | |
| 21 | 21 | /*======================================================================================== |
| 22 | 22 | */ |
| @@ -38,7 +38,7 @@ typedef struct · 15 unmodified lines | ||
| 38 | 38 | */ |
| 39 | 39 | |
| 40 | 40 | static int |
| 41 | −linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) | |
| 41 | +linear_vari_process (SRC_STATE *state, SRC_DATA *data) | |
| 42 | 42 | { LINEAR_DATA *priv ; |
| 43 | 43 | double src_ratio, input_index, rem ; |
| 44 | 44 | int ch ; |
| @@ -46,10 +46,10 @@ linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) · 1 unmodified line | ||
| 46 | 46 | if (data->input_frames <= 0) |
| 47 | 47 | return SRC_ERR_NO_ERROR ; |
| 48 | 48 | |
| 49 | − if (psrc->private_data == NULL) | |
| 49 | + if (state->private_data == NULL) | |
| 50 | 50 | return SRC_ERR_NO_PRIVATE ; |
| 51 | 51 | |
| 52 | − priv = (LINEAR_DATA*) psrc->private_data ; | |
| 52 | + priv = (LINEAR_DATA*) state->private_data ; | |
| 53 | 53 | |
| 54 | 54 | if (priv->reset) |
| 55 | 55 | { /* If we have just been reset, set the last_value data. */ |
| @@ -62,12 +62,12 @@ linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) · 6 unmodified lines | ||
| 62 | 62 | priv->out_count = data->output_frames * priv->channels ; |
| 63 | 63 | priv->in_used = priv->out_gen = 0 ; |
| 64 | 64 | |
| 65 | − src_ratio = psrc->last_ratio ; | |
| 65 | + src_ratio = state->last_ratio ; | |
| 66 | 66 | |
| 67 | 67 | if (is_bad_src_ratio (src_ratio)) |
| 68 | 68 | return SRC_ERR_BAD_INTERNAL_STATE ; |
| 69 | 69 | |
| 70 | − input_index = psrc->last_position ; | |
| 70 | + input_index = state->last_position ; | |
| 71 | 71 | |
| 72 | 72 | /* Calculate samples before first sample in input array. */ |
| 73 | 73 | while (input_index < 1.0 && priv->out_gen < priv->out_count) |
| @@ -75,8 +75,8 @@ linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) · 1 unmodified line | ||
| 75 | 75 | if (priv->in_used + priv->channels * (1.0 + input_index) >= priv->in_count) |
| 76 | 76 | break ; |
| 77 | 77 | |
| 78 | − if (priv->out_count > 0 && fabs (psrc->last_ratio - data->src_ratio) > SRC_MIN_RATIO_DIFF) | |
| 79 | − src_ratio = psrc->last_ratio + priv->out_gen * (data->src_ratio - psrc->last_ratio) / priv->out_count ; | |
| 78 | + if (priv->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > SRC_MIN_RATIO_DIFF) | |
| 79 | + src_ratio = state->last_ratio + priv->out_gen * (data->src_ratio - state->last_ratio) / priv->out_count ; | |
| 80 | 80 | |
| 81 | 81 | for (ch = 0 ; ch < priv->channels ; ch++) |
| 82 | 82 | { data->data_out [priv->out_gen] = (float) (priv->last_value [ch] + input_index * |
| @@ -95,8 +95,8 @@ linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) · 12 unmodified lines | ||
| 95 | 95 | /* Main processing loop. */ |
| 96 | 96 | while (priv->out_gen < priv->out_count && priv->in_used + priv->channels * input_index < priv->in_count) |
| 97 | 97 | { |
| 98 | − if (priv->out_count > 0 && fabs (psrc->last_ratio - data->src_ratio) > SRC_MIN_RATIO_DIFF) | |
| 99 | − src_ratio = psrc->last_ratio + priv->out_gen * (data->src_ratio - psrc->last_ratio) / priv->out_count ; | |
| 98 | + if (priv->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > SRC_MIN_RATIO_DIFF) | |
| 99 | + src_ratio = state->last_ratio + priv->out_gen * (data->src_ratio - state->last_ratio) / priv->out_count ; | |
| 100 | 100 | |
| 101 | 101 | if (SRC_DEBUG && priv->in_used < priv->channels && input_index < 1.0) |
| 102 | 102 | { printf ("Whoops!!!! in_used : %ld channels : %d input_index : %f\n", priv->in_used, priv->channels, input_index) ; |
| @@ -122,14 +122,14 @@ linear_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) · 19 unmodified lines | ||
| 122 | 122 | priv->in_used = priv->in_count ; |
| 123 | 123 | } ; |
| 124 | 124 | |
| 125 | − psrc->last_position = input_index ; | |
| 125 | + state->last_position = input_index ; | |
| 126 | 126 | |
| 127 | 127 | if (priv->in_used > 0) |
| 128 | 128 | for (ch = 0 ; ch < priv->channels ; ch++) |
| 129 | 129 | priv->last_value [ch] = data->data_in [priv->in_used - priv->channels + ch] ; |
| 130 | 130 | |
| 131 | 131 | /* Save current ratio rather then target ratio. */ |
| 132 | − psrc->last_ratio = src_ratio ; | |
| 132 | + state->last_ratio = src_ratio ; | |
| 133 | 133 | |
| 134 | 134 | data->input_frames_used = priv->in_used / priv->channels ; |
| 135 | 135 | data->output_frames_gen = priv->out_gen / priv->channels ; |
| @@ -159,34 +159,34 @@ linear_get_description (int src_enum) · 23 unmodified lines | ||
| 159 | 159 | } /* linear_get_descrition */ |
| 160 | 160 | |
| 161 | 161 | int |
| 162 | −linear_set_converter (SRC_PRIVATE *psrc, int src_enum) | |
| 162 | +linear_set_converter (SRC_STATE *state, int src_enum) | |
| 163 | 163 | { LINEAR_DATA *priv = NULL ; |
| 164 | 164 | |
| 165 | 165 | if (src_enum != SRC_LINEAR) |
| 166 | 166 | return SRC_ERR_BAD_CONVERTER ; |
| 167 | 167 | |
| 168 | − if (psrc->private_data != NULL) | |
| 169 | − { free (psrc->private_data) ; | |
| 170 | − psrc->private_data = NULL ; | |
| 168 | + if (state->private_data != NULL) | |
| 169 | + { free (state->private_data) ; | |
| 170 | + state->private_data = NULL ; | |
| 171 | 171 | } ; |
| 172 | 172 | |
| 173 | − if (psrc->private_data == NULL) | |
| 174 | − { priv = ZERO_ALLOC (LINEAR_DATA, sizeof (*priv) + psrc->channels * sizeof (float)) ; | |
| 175 | − psrc->private_data = priv ; | |
| 173 | + if (state->private_data == NULL) | |
| 174 | + { priv = ZERO_ALLOC (LINEAR_DATA, sizeof (*priv) + state->channels * sizeof (float)) ; | |
| 175 | + state->private_data = priv ; | |
| 176 | 176 | } ; |
| 177 | 177 | |
| 178 | 178 | if (priv == NULL) |
| 179 | 179 | return SRC_ERR_MALLOC_FAILED ; |
| 180 | 180 | |
| 181 | 181 | priv->linear_magic_marker = LINEAR_MAGIC_MARKER ; |
| 182 | − priv->channels = psrc->channels ; | |
| 182 | + priv->channels = state->channels ; | |
| 183 | 183 | |
| 184 | − psrc->const_process = linear_vari_process ; | |
| 185 | − psrc->vari_process = linear_vari_process ; | |
| 186 | − psrc->reset = linear_reset ; | |
| 187 | − psrc->copy = linear_copy ; | |
| 184 | + state->const_process = linear_vari_process ; | |
| 185 | + state->vari_process = linear_vari_process ; | |
| 186 | + state->reset = linear_reset ; | |
| 187 | + state->copy = linear_copy ; | |
| 188 | 188 | |
| 189 | − linear_reset (psrc) ; | |
| 189 | + linear_reset (state) ; | |
| 190 | 190 | |
| 191 | 191 | return SRC_ERR_NO_ERROR ; |
| 192 | 192 | } /* linear_set_converter */ |
| @@ -195,14 +195,14 @@ linear_set_converter (SRC_PRIVATE *psrc, int src_enum) · 2 unmodified lines | ||
| 195 | 195 | */ |
| 196 | 196 | |
| 197 | 197 | static void |
| 198 | −linear_reset (SRC_PRIVATE *psrc) | |
| 198 | +linear_reset (SRC_STATE *state) | |
| 199 | 199 | { LINEAR_DATA *priv = NULL ; |
| 200 | 200 | |
| 201 | − priv = (LINEAR_DATA*) psrc->private_data ; | |
| 201 | + priv = (LINEAR_DATA*) state->private_data ; | |
| 202 | 202 | if (priv == NULL) |
| 203 | 203 | return ; |
| 204 | 204 | |
| 205 | − priv->channels = psrc->channels ; | |
| 205 | + priv->channels = state->channels ; | |
| 206 | 206 | priv->reset = 1 ; |
| 207 | 207 | memset (priv->last_value, 0, sizeof (priv->last_value [0]) * priv->channels) ; |
| 208 | 208 | |
| @@ -210,7 +210,7 @@ linear_reset (SRC_PRIVATE *psrc) · 1 unmodified line | ||
| 210 | 210 | } /* linear_reset */ |
| 211 | 211 | |
| 212 | 212 | static int |
| 213 | −linear_copy (SRC_PRIVATE *from, SRC_PRIVATE *to) | |
| 213 | +linear_copy (SRC_STATE *from, SRC_STATE *to) | |
| 214 | 214 | { |
| 215 | 215 | if (from->private_data == NULL) |
| 216 | 216 | return SRC_ERR_NO_PRIVATE ; |