Lines Matching +full:convert +full:- +full:channels
2 ** Copyright (c) 2002-2021, Erik de Castro Lopo <erikd@mega-nerd.com>
5 ** This code is released under 2-clause BSD license. Please see the
44 typedef int _CHECK_SHIFT_BITS[2 * (SHIFT_BITS < sizeof (increment_t) * 8 - 1) - 1]; /* sanity check…
70 /* Sure hope noone does more than 128 channels at once. */
82 static SRC_ERROR prepare_data (SINC_FILTER *filter, int channels, SRC_DATA *data, int half_filter_c…
150 { return ((x) & ((((increment_t) 1) << SHIFT_BITS) - 1)) ; in fp_fraction_part()
161 return (divident + (divisor - 1)) / divisor ; in int_div_ceil()
164 /*----------------------------------------------------------------------------------------
209 sinc_filter_new (int converter_type, int channels) in sinc_filter_new() argument
214 assert (channels > 0 && channels <= MAX_CHANNELS) ; in sinc_filter_new()
219 priv->sinc_magic_marker = SINC_MAGIC_MARKER ; in sinc_filter_new()
224 priv->coeffs = fastest_coeffs.coeffs ; in sinc_filter_new()
225 priv->coeff_half_len = ARRAY_LEN (fastest_coeffs.coeffs) - 2 ; in sinc_filter_new()
226 priv->index_inc = fastest_coeffs.increment ; in sinc_filter_new()
231 priv->coeffs = slow_mid_qual_coeffs.coeffs ; in sinc_filter_new()
232 priv->coeff_half_len = ARRAY_LEN (slow_mid_qual_coeffs.coeffs) - 2 ; in sinc_filter_new()
233 priv->index_inc = slow_mid_qual_coeffs.increment ; in sinc_filter_new()
238 priv->coeffs = slow_high_qual_coeffs.coeffs ; in sinc_filter_new()
239 priv->coeff_half_len = ARRAY_LEN (slow_high_qual_coeffs.coeffs) - 2 ; in sinc_filter_new()
240 priv->index_inc = slow_high_qual_coeffs.increment ; in sinc_filter_new()
245 …priv->b_len = 3 * (int) lrint ((priv->coeff_half_len + 2.0) / priv->index_inc * SRC_MAX_RATIO + 1)… in sinc_filter_new()
246 priv->b_len = MAX (priv->b_len, 4096) ; in sinc_filter_new()
247 priv->b_len *= channels ; in sinc_filter_new()
248 …priv->b_len += 1 ; // There is a <= check against samples_in_hand requiring a buffer bigger than t… in sinc_filter_new()
251 priv->buffer = (float *) calloc (priv->b_len + channels, sizeof (float)) ; in sinc_filter_new()
252 if (!priv->buffer) in sinc_filter_new()
263 sinc_state_new (int converter_type, int channels, SRC_ERROR *error) in sinc_state_new() argument
268 assert (channels > 0) ; in sinc_state_new()
271 if (channels > MAX_CHANNELS) in sinc_state_new()
284 state->channels = channels ; in sinc_state_new()
285 state->mode = SRC_MODE_PROCESS ; in sinc_state_new()
287 if (state->channels == 1) in sinc_state_new()
288 state->vt = &sinc_mono_state_vt ; in sinc_state_new()
289 else if (state->channels == 2) in sinc_state_new()
290 state->vt = &sinc_stereo_state_vt ; in sinc_state_new()
291 else if (state->channels == 4) in sinc_state_new()
292 state->vt = &sinc_quad_state_vt ; in sinc_state_new()
293 else if (state->channels == 6) in sinc_state_new()
294 state->vt = &sinc_hex_state_vt ; in sinc_state_new()
296 state->vt = &sinc_multichan_state_vt ; in sinc_state_new()
298 state->private_data = sinc_filter_new (converter_type, state->channels) ; in sinc_state_new()
299 if (!state->private_data) in sinc_state_new()
317 filter = (SINC_FILTER*) state->private_data ; in sinc_reset()
321 filter->b_current = filter->b_end = 0 ; in sinc_reset()
322 filter->b_real_end = -1 ; in sinc_reset()
324 filter->src_ratio = filter->input_index = 0.0 ; in sinc_reset()
326 memset (filter->buffer, 0, filter->b_len * sizeof (filter->buffer [0])) ; in sinc_reset()
329 memset (filter->buffer + filter->b_len, 0xAA, state->channels * sizeof (filter->buffer [0])) ; in sinc_reset()
337 if (state->private_data == NULL) in sinc_copy()
346 SINC_FILTER* from_filter = (SINC_FILTER*) state->private_data ; in sinc_copy()
354 to_filter->buffer = (float *) malloc (sizeof (float) * (from_filter->b_len + state->channels)) ; in sinc_copy()
355 if (!to_filter->buffer) in sinc_copy()
361 …memcpy (to_filter->buffer, from_filter->buffer, sizeof (float) * (from_filter->b_len + state->chan… in sinc_copy()
363 to->private_data = to_filter ; in sinc_copy()
378 /* Convert input parameters into fixed point. */ in calc_output_single()
379 max_filter_index = int_to_fp (filter->coeff_half_len) ; in calc_output_single()
383 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_single()
385 data_index = filter->b_current - coeff_count ; in calc_output_single()
387 if (data_index < 0) /* Avoid underflow access to filter->buffer. */ in calc_output_single()
388 { int steps = -data_index ; in calc_output_single()
391 filter_index -= increment * steps ; in calc_output_single()
398 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_single()
399 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_single()
400 assert (data_index >= 0 && data_index < filter->b_len) ; in calc_output_single()
401 assert (data_index < filter->b_end) ; in calc_output_single()
402 left += icoeff * filter->buffer [data_index] ; in calc_output_single()
404 filter_index -= increment ; in calc_output_single()
409 filter_index = increment - start_filter_index ; in calc_output_single()
410 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_single()
412 data_index = filter->b_current + 1 + coeff_count ; in calc_output_single()
418 assert (indx < filter->coeff_half_len + 2) ; in calc_output_single()
419 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_single()
420 assert (data_index >= 0 && data_index < filter->b_len) ; in calc_output_single()
421 assert (data_index < filter->b_end) ; in calc_output_single()
422 right += icoeff * filter->buffer [data_index] ; in calc_output_single()
424 filter_index -= increment ; in calc_output_single()
425 data_index = data_index - 1 ; in calc_output_single()
439 if (state->private_data == NULL) in sinc_mono_vari_process()
442 filter = (SINC_FILTER*) state->private_data ; in sinc_mono_vari_process()
445 if (sizeof (filter->buffer [0]) != sizeof (data->data_in [0])) in sinc_mono_vari_process()
448 filter->in_count = data->input_frames * state->channels ; in sinc_mono_vari_process()
449 filter->out_count = data->output_frames * state->channels ; in sinc_mono_vari_process()
450 filter->in_used = filter->out_gen = 0 ; in sinc_mono_vari_process()
452 src_ratio = state->last_ratio ; in sinc_mono_vari_process()
458 count = (filter->coeff_half_len + 2.0) / filter->index_inc ; in sinc_mono_vari_process()
459 if (MIN (state->last_ratio, data->src_ratio) < 1.0) in sinc_mono_vari_process()
460 count /= MIN (state->last_ratio, data->src_ratio) ; in sinc_mono_vari_process()
463 half_filter_chan_len = state->channels * (int) (lrint (count) + 1) ; in sinc_mono_vari_process()
465 input_index = state->last_position ; in sinc_mono_vari_process()
468 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_mono_vari_process()
471 terminate = 1.0 / src_ratio + 1e-20 ; in sinc_mono_vari_process()
474 while (filter->out_gen < filter->out_count) in sinc_mono_vari_process()
477 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_mono_vari_process()
480 { if ((state->error = prepare_data (filter, state->channels, data, half_filter_chan_len)) != 0) in sinc_mono_vari_process()
481 return state->error ; in sinc_mono_vari_process()
483 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_mono_vari_process()
489 if (filter->b_real_end >= 0) in sinc_mono_vari_process()
490 { if (filter->b_current + input_index + terminate > filter->b_real_end) in sinc_mono_vari_process()
494 if (filter->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > 1e-10) in sinc_mono_vari_process()
495 …src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->… in sinc_mono_vari_process()
497 float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ; in sinc_mono_vari_process()
502 data->data_out [filter->out_gen] = (float) ((float_increment / filter->index_inc) * in sinc_mono_vari_process()
504 filter->out_gen ++ ; in sinc_mono_vari_process()
510 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_mono_vari_process()
514 state->last_position = input_index ; in sinc_mono_vari_process()
517 state->last_ratio = src_ratio ; in sinc_mono_vari_process()
519 data->input_frames_used = filter->in_used / state->channels ; in sinc_mono_vari_process()
520 data->output_frames_gen = filter->out_gen / state->channels ; in sinc_mono_vari_process()
526 calc_output_stereo (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_fil… in calc_output_stereo() argument
531 /* Convert input parameters into fixed point. */ in calc_output_stereo()
532 max_filter_index = int_to_fp (filter->coeff_half_len) ; in calc_output_stereo()
536 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_stereo()
538 data_index = filter->b_current - channels * coeff_count ; in calc_output_stereo()
540 if (data_index < 0) /* Avoid underflow access to filter->buffer. */ in calc_output_stereo()
541 { int steps = int_div_ceil (-data_index, 2) ; in calc_output_stereo()
544 filter_index -= increment * steps ; in calc_output_stereo()
551 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_stereo()
552 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_stereo()
553 assert (data_index >= 0 && data_index + 1 < filter->b_len) ; in calc_output_stereo()
554 assert (data_index + 1 < filter->b_end) ; in calc_output_stereo()
556 left [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_stereo()
558 filter_index -= increment ; in calc_output_stereo()
563 filter_index = increment - start_filter_index ; in calc_output_stereo()
564 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_stereo()
566 data_index = filter->b_current + channels * (1 + coeff_count) ; in calc_output_stereo()
572 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_stereo()
573 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_stereo()
574 assert (data_index >= 0 && data_index + 1 < filter->b_len) ; in calc_output_stereo()
575 assert (data_index + 1 < filter->b_end) ; in calc_output_stereo()
577 right [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_stereo()
579 filter_index -= increment ; in calc_output_stereo()
580 data_index = data_index - 2 ; in calc_output_stereo()
595 if (state->private_data == NULL) in sinc_stereo_vari_process()
598 filter = (SINC_FILTER*) state->private_data ; in sinc_stereo_vari_process()
601 if (sizeof (filter->buffer [0]) != sizeof (data->data_in [0])) in sinc_stereo_vari_process()
604 filter->in_count = data->input_frames * state->channels ; in sinc_stereo_vari_process()
605 filter->out_count = data->output_frames * state->channels ; in sinc_stereo_vari_process()
606 filter->in_used = filter->out_gen = 0 ; in sinc_stereo_vari_process()
608 src_ratio = state->last_ratio ; in sinc_stereo_vari_process()
614 count = (filter->coeff_half_len + 2.0) / filter->index_inc ; in sinc_stereo_vari_process()
615 if (MIN (state->last_ratio, data->src_ratio) < 1.0) in sinc_stereo_vari_process()
616 count /= MIN (state->last_ratio, data->src_ratio) ; in sinc_stereo_vari_process()
619 half_filter_chan_len = state->channels * (int) (lrint (count) + 1) ; in sinc_stereo_vari_process()
621 input_index = state->last_position ; in sinc_stereo_vari_process()
624 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_stereo_vari_process()
627 terminate = 1.0 / src_ratio + 1e-20 ; in sinc_stereo_vari_process()
630 while (filter->out_gen < filter->out_count) in sinc_stereo_vari_process()
633 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_stereo_vari_process()
636 { if ((state->error = prepare_data (filter, state->channels, data, half_filter_chan_len)) != 0) in sinc_stereo_vari_process()
637 return state->error ; in sinc_stereo_vari_process()
639 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_stereo_vari_process()
645 if (filter->b_real_end >= 0) in sinc_stereo_vari_process()
646 { if (filter->b_current + input_index + terminate >= filter->b_real_end) in sinc_stereo_vari_process()
650 if (filter->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > 1e-10) in sinc_stereo_vari_process()
651 …src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->… in sinc_stereo_vari_process()
653 float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ; in sinc_stereo_vari_process()
658 …ut_stereo (filter, state->channels, increment, start_filter_index, float_increment / filter->index… in sinc_stereo_vari_process()
659 filter->out_gen += 2 ; in sinc_stereo_vari_process()
665 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_stereo_vari_process()
669 state->last_position = input_index ; in sinc_stereo_vari_process()
672 state->last_ratio = src_ratio ; in sinc_stereo_vari_process()
674 data->input_frames_used = filter->in_used / state->channels ; in sinc_stereo_vari_process()
675 data->output_frames_gen = filter->out_gen / state->channels ; in sinc_stereo_vari_process()
681 calc_output_quad (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filte… in calc_output_quad() argument
686 /* Convert input parameters into fixed point. */ in calc_output_quad()
687 max_filter_index = int_to_fp (filter->coeff_half_len) ; in calc_output_quad()
691 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_quad()
693 data_index = filter->b_current - channels * coeff_count ; in calc_output_quad()
695 if (data_index < 0) /* Avoid underflow access to filter->buffer. */ in calc_output_quad()
696 { int steps = int_div_ceil (-data_index, 4) ; in calc_output_quad()
699 filter_index -= increment * steps ; in calc_output_quad()
706 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_quad()
707 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_quad()
708 assert (data_index >= 0 && data_index + 3 < filter->b_len) ; in calc_output_quad()
709 assert (data_index + 3 < filter->b_end) ; in calc_output_quad()
711 left [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_quad()
713 filter_index -= increment ; in calc_output_quad()
718 filter_index = increment - start_filter_index ; in calc_output_quad()
719 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_quad()
721 data_index = filter->b_current + channels * (1 + coeff_count) ; in calc_output_quad()
727 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_quad()
728 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_quad()
729 assert (data_index >= 0 && data_index + 3 < filter->b_len) ; in calc_output_quad()
730 assert (data_index + 3 < filter->b_end) ; in calc_output_quad()
732 right [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_quad()
735 filter_index -= increment ; in calc_output_quad()
736 data_index = data_index - 4 ; in calc_output_quad()
751 if (state->private_data == NULL) in sinc_quad_vari_process()
754 filter = (SINC_FILTER*) state->private_data ; in sinc_quad_vari_process()
757 if (sizeof (filter->buffer [0]) != sizeof (data->data_in [0])) in sinc_quad_vari_process()
760 filter->in_count = data->input_frames * state->channels ; in sinc_quad_vari_process()
761 filter->out_count = data->output_frames * state->channels ; in sinc_quad_vari_process()
762 filter->in_used = filter->out_gen = 0 ; in sinc_quad_vari_process()
764 src_ratio = state->last_ratio ; in sinc_quad_vari_process()
770 count = (filter->coeff_half_len + 2.0) / filter->index_inc ; in sinc_quad_vari_process()
771 if (MIN (state->last_ratio, data->src_ratio) < 1.0) in sinc_quad_vari_process()
772 count /= MIN (state->last_ratio, data->src_ratio) ; in sinc_quad_vari_process()
775 half_filter_chan_len = state->channels * (int) (lrint (count) + 1) ; in sinc_quad_vari_process()
777 input_index = state->last_position ; in sinc_quad_vari_process()
780 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_quad_vari_process()
783 terminate = 1.0 / src_ratio + 1e-20 ; in sinc_quad_vari_process()
786 while (filter->out_gen < filter->out_count) in sinc_quad_vari_process()
789 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_quad_vari_process()
792 { if ((state->error = prepare_data (filter, state->channels, data, half_filter_chan_len)) != 0) in sinc_quad_vari_process()
793 return state->error ; in sinc_quad_vari_process()
795 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_quad_vari_process()
801 if (filter->b_real_end >= 0) in sinc_quad_vari_process()
802 { if (filter->b_current + input_index + terminate >= filter->b_real_end) in sinc_quad_vari_process()
806 if (filter->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > 1e-10) in sinc_quad_vari_process()
807 …src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->… in sinc_quad_vari_process()
809 float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ; in sinc_quad_vari_process()
814 …tput_quad (filter, state->channels, increment, start_filter_index, float_increment / filter->index… in sinc_quad_vari_process()
815 filter->out_gen += 4 ; in sinc_quad_vari_process()
821 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_quad_vari_process()
825 state->last_position = input_index ; in sinc_quad_vari_process()
828 state->last_ratio = src_ratio ; in sinc_quad_vari_process()
830 data->input_frames_used = filter->in_used / state->channels ; in sinc_quad_vari_process()
831 data->output_frames_gen = filter->out_gen / state->channels ; in sinc_quad_vari_process()
837 calc_output_hex (SINC_FILTER *filter, int channels, increment_t increment, increment_t start_filter… in calc_output_hex() argument
842 /* Convert input parameters into fixed point. */ in calc_output_hex()
843 max_filter_index = int_to_fp (filter->coeff_half_len) ; in calc_output_hex()
847 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_hex()
849 data_index = filter->b_current - channels * coeff_count ; in calc_output_hex()
851 if (data_index < 0) /* Avoid underflow access to filter->buffer. */ in calc_output_hex()
852 { int steps = int_div_ceil (-data_index, 6) ; in calc_output_hex()
855 filter_index -= increment * steps ; in calc_output_hex()
862 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_hex()
863 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_hex()
864 assert (data_index >= 0 && data_index + 5 < filter->b_len) ; in calc_output_hex()
865 assert (data_index + 5 < filter->b_end) ; in calc_output_hex()
867 left [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_hex()
869 filter_index -= increment ; in calc_output_hex()
874 filter_index = increment - start_filter_index ; in calc_output_hex()
875 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_hex()
877 data_index = filter->b_current + channels * (1 + coeff_count) ; in calc_output_hex()
883 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_hex()
884 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_hex()
885 assert (data_index >= 0 && data_index + 5 < filter->b_len) ; in calc_output_hex()
886 assert (data_index + 5 < filter->b_end) ; in calc_output_hex()
888 right [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_hex()
890 filter_index -= increment ; in calc_output_hex()
891 data_index = data_index - 6 ; in calc_output_hex()
906 if (state->private_data == NULL) in sinc_hex_vari_process()
909 filter = (SINC_FILTER*) state->private_data ; in sinc_hex_vari_process()
912 if (sizeof (filter->buffer [0]) != sizeof (data->data_in [0])) in sinc_hex_vari_process()
915 filter->in_count = data->input_frames * state->channels ; in sinc_hex_vari_process()
916 filter->out_count = data->output_frames * state->channels ; in sinc_hex_vari_process()
917 filter->in_used = filter->out_gen = 0 ; in sinc_hex_vari_process()
919 src_ratio = state->last_ratio ; in sinc_hex_vari_process()
925 count = (filter->coeff_half_len + 2.0) / filter->index_inc ; in sinc_hex_vari_process()
926 if (MIN (state->last_ratio, data->src_ratio) < 1.0) in sinc_hex_vari_process()
927 count /= MIN (state->last_ratio, data->src_ratio) ; in sinc_hex_vari_process()
930 half_filter_chan_len = state->channels * (int) (lrint (count) + 1) ; in sinc_hex_vari_process()
932 input_index = state->last_position ; in sinc_hex_vari_process()
935 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_hex_vari_process()
938 terminate = 1.0 / src_ratio + 1e-20 ; in sinc_hex_vari_process()
941 while (filter->out_gen < filter->out_count) in sinc_hex_vari_process()
944 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_hex_vari_process()
947 { if ((state->error = prepare_data (filter, state->channels, data, half_filter_chan_len)) != 0) in sinc_hex_vari_process()
948 return state->error ; in sinc_hex_vari_process()
950 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_hex_vari_process()
956 if (filter->b_real_end >= 0) in sinc_hex_vari_process()
957 { if (filter->b_current + input_index + terminate >= filter->b_real_end) in sinc_hex_vari_process()
961 if (filter->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > 1e-10) in sinc_hex_vari_process()
962 …src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->… in sinc_hex_vari_process()
964 float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ; in sinc_hex_vari_process()
969 …utput_hex (filter, state->channels, increment, start_filter_index, float_increment / filter->index… in sinc_hex_vari_process()
970 filter->out_gen += 6 ; in sinc_hex_vari_process()
976 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_hex_vari_process()
980 state->last_position = input_index ; in sinc_hex_vari_process()
983 state->last_ratio = src_ratio ; in sinc_hex_vari_process()
985 data->input_frames_used = filter->in_used / state->channels ; in sinc_hex_vari_process()
986 data->output_frames_gen = filter->out_gen / state->channels ; in sinc_hex_vari_process()
992 …TER *filter, increment_t increment, increment_t start_filter_index, int channels, double scale, fl… in calc_output_multi() argument
999 left = filter->left_calc ; in calc_output_multi()
1000 right = filter->right_calc ; in calc_output_multi()
1002 /* Convert input parameters into fixed point. */ in calc_output_multi()
1003 max_filter_index = int_to_fp (filter->coeff_half_len) ; in calc_output_multi()
1007 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_multi()
1009 data_index = filter->b_current - channels * coeff_count ; in calc_output_multi()
1011 if (data_index < 0) /* Avoid underflow access to filter->buffer. */ in calc_output_multi()
1012 { int steps = int_div_ceil (-data_index, channels) ; in calc_output_multi()
1015 filter_index -= increment * steps ; in calc_output_multi()
1016 data_index += steps * channels ; in calc_output_multi()
1019 memset (left, 0, sizeof (left [0]) * channels) ; in calc_output_multi()
1024 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_multi()
1025 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_multi()
1027 assert (data_index >= 0 && data_index + channels - 1 < filter->b_len) ; in calc_output_multi()
1028 assert (data_index + channels - 1 < filter->b_end) ; in calc_output_multi()
1029 for (int ch = 0; ch < channels; ch++) in calc_output_multi()
1030 left [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_multi()
1032 filter_index -= increment ; in calc_output_multi()
1033 data_index = data_index + channels ; in calc_output_multi()
1037 filter_index = increment - start_filter_index ; in calc_output_multi()
1038 coeff_count = (max_filter_index - filter_index) / increment ; in calc_output_multi()
1040 data_index = filter->b_current + channels * (1 + coeff_count) ; in calc_output_multi()
1042 memset (right, 0, sizeof (right [0]) * channels) ; in calc_output_multi()
1046 assert (indx >= 0 && indx + 1 < filter->coeff_half_len + 2) ; in calc_output_multi()
1047 icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; in calc_output_multi()
1048 assert (data_index >= 0 && data_index + channels - 1 < filter->b_len) ; in calc_output_multi()
1049 assert (data_index + channels - 1 < filter->b_end) ; in calc_output_multi()
1050 for (int ch = 0; ch < channels; ch++) in calc_output_multi()
1051 right [ch] += icoeff * filter->buffer [data_index + ch] ; in calc_output_multi()
1053 filter_index -= increment ; in calc_output_multi()
1054 data_index = data_index - channels ; in calc_output_multi()
1058 for(int ch = 0; ch < channels; ch++) in calc_output_multi()
1071 if (state->private_data == NULL) in sinc_multichan_vari_process()
1074 filter = (SINC_FILTER*) state->private_data ; in sinc_multichan_vari_process()
1077 if (sizeof (filter->buffer [0]) != sizeof (data->data_in [0])) in sinc_multichan_vari_process()
1080 filter->in_count = data->input_frames * state->channels ; in sinc_multichan_vari_process()
1081 filter->out_count = data->output_frames * state->channels ; in sinc_multichan_vari_process()
1082 filter->in_used = filter->out_gen = 0 ; in sinc_multichan_vari_process()
1084 src_ratio = state->last_ratio ; in sinc_multichan_vari_process()
1090 count = (filter->coeff_half_len + 2.0) / filter->index_inc ; in sinc_multichan_vari_process()
1091 if (MIN (state->last_ratio, data->src_ratio) < 1.0) in sinc_multichan_vari_process()
1092 count /= MIN (state->last_ratio, data->src_ratio) ; in sinc_multichan_vari_process()
1095 half_filter_chan_len = state->channels * (int) (lrint (count) + 1) ; in sinc_multichan_vari_process()
1097 input_index = state->last_position ; in sinc_multichan_vari_process()
1100 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_multichan_vari_process()
1103 terminate = 1.0 / src_ratio + 1e-20 ; in sinc_multichan_vari_process()
1106 while (filter->out_gen < filter->out_count) in sinc_multichan_vari_process()
1109 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_multichan_vari_process()
1112 { if ((state->error = prepare_data (filter, state->channels, data, half_filter_chan_len)) != 0) in sinc_multichan_vari_process()
1113 return state->error ; in sinc_multichan_vari_process()
1115 samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ; in sinc_multichan_vari_process()
1121 if (filter->b_real_end >= 0) in sinc_multichan_vari_process()
1122 { if (filter->b_current + input_index + terminate >= filter->b_real_end) in sinc_multichan_vari_process()
1126 if (filter->out_count > 0 && fabs (state->last_ratio - data->src_ratio) > 1e-10) in sinc_multichan_vari_process()
1127 …src_ratio = state->last_ratio + filter->out_gen * (data->src_ratio - state->last_ratio) / filter->… in sinc_multichan_vari_process()
1129 float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ; in sinc_multichan_vari_process()
1134 …er, increment, start_filter_index, state->channels, float_increment / filter->index_inc, data->dat… in sinc_multichan_vari_process()
1135 filter->out_gen += state->channels ; in sinc_multichan_vari_process()
1141 …filter->b_current = (filter->b_current + state->channels * lrint (input_index - rem)) % filter->b_… in sinc_multichan_vari_process()
1145 state->last_position = input_index ; in sinc_multichan_vari_process()
1148 state->last_ratio = src_ratio ; in sinc_multichan_vari_process()
1150 data->input_frames_used = filter->in_used / state->channels ; in sinc_multichan_vari_process()
1151 data->output_frames_gen = filter->out_gen / state->channels ; in sinc_multichan_vari_process()
1156 /*----------------------------------------------------------------------------------------
1160 prepare_data (SINC_FILTER *filter, int channels, SRC_DATA *data, int half_filter_chan_len) in prepare_data() argument
1163 if (filter->b_real_end >= 0) in prepare_data()
1166 if (data->data_in == NULL) in prepare_data()
1169 if (filter->b_current == 0) in prepare_data()
1173 len = filter->b_len - 2 * half_filter_chan_len ; in prepare_data()
1175 filter->b_current = filter->b_end = half_filter_chan_len ; in prepare_data()
1177 else if (filter->b_end + half_filter_chan_len + channels < filter->b_len) in prepare_data()
1179 len = MAX (filter->b_len - filter->b_current - half_filter_chan_len, 0) ; in prepare_data()
1183 len = filter->b_end - filter->b_current ; in prepare_data()
1184 memmove (filter->buffer, filter->buffer + filter->b_current - half_filter_chan_len, in prepare_data()
1185 (half_filter_chan_len + len) * sizeof (filter->buffer [0])) ; in prepare_data()
1187 filter->b_current = half_filter_chan_len ; in prepare_data()
1188 filter->b_end = filter->b_current + len ; in prepare_data()
1191 len = MAX (filter->b_len - filter->b_current - half_filter_chan_len, 0) ; in prepare_data()
1194 len = MIN ((int) (filter->in_count - filter->in_used), len) ; in prepare_data()
1195 len -= (len % channels) ; in prepare_data()
1197 if (len < 0 || filter->b_end + len > filter->b_len) in prepare_data()
1200 memcpy (filter->buffer + filter->b_end, data->data_in + filter->in_used, in prepare_data()
1201 len * sizeof (filter->buffer [0])) ; in prepare_data()
1203 filter->b_end += len ; in prepare_data()
1204 filter->in_used += len ; in prepare_data()
1206 if (filter->in_used == filter->in_count && in prepare_data()
1207 filter->b_end - filter->b_current < 2 * half_filter_chan_len && data->end_of_input) in prepare_data()
1212 if (filter->b_len - filter->b_end < half_filter_chan_len + 5) in prepare_data()
1214 len = filter->b_end - filter->b_current ; in prepare_data()
1215 memmove (filter->buffer, filter->buffer + filter->b_current - half_filter_chan_len, in prepare_data()
1216 (half_filter_chan_len + len) * sizeof (filter->buffer [0])) ; in prepare_data()
1218 filter->b_current = half_filter_chan_len ; in prepare_data()
1219 filter->b_end = filter->b_current + len ; in prepare_data()
1222 filter->b_real_end = filter->b_end ; in prepare_data()
1225 if (len < 0 || filter->b_end + len > filter->b_len) in prepare_data()
1226 len = filter->b_len - filter->b_end ; in prepare_data()
1228 memset (filter->buffer + filter->b_end, 0, len * sizeof (filter->buffer [0])) ; in prepare_data()
1229 filter->b_end += len ; in prepare_data()
1240 SINC_FILTER *sinc = (SINC_FILTER *) state->private_data ; in sinc_close()
1243 if (sinc->buffer) in sinc_close()
1245 free (sinc->buffer) ; in sinc_close()
1246 sinc->buffer = NULL ; in sinc_close()