From 194bc59478751a951bd23eb55bf9cae467211be4 Mon Sep 17 00:00:00 2001 From: Michael Sevakis Date: Fri, 2 Sep 2011 16:29:26 +0000 Subject: [PATCH] Sanify dsp.c (re)sample buffer indirection. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30409 a1c6a512-1295-4272-9138-f99709370657 --- apps/dsp.c | 105 ++++++++++++++++++++++++++++++----------------------- 1 file changed, 60 insertions(+), 45 deletions(-) diff --git a/apps/dsp.c b/apps/dsp.c index 167c043427..3f1eb75200 100644 --- a/apps/dsp.c +++ b/apps/dsp.c @@ -45,8 +45,7 @@ #define WORD_FRACBITS 27 #define NATIVE_DEPTH 16 -/* If the small buffer size changes, check the assembly code! */ -#define SMALL_SAMPLE_BUF_COUNT 256 +#define SMALL_SAMPLE_BUF_COUNT 128 /* Per channel */ #define DEFAULT_GAIN 0x01000000 /* enums to index conversion properly with stereo mode and other settings */ @@ -242,25 +241,23 @@ static bool crossfeed_enabled; * of copying needed is minimized for that case. */ -#define RESAMPLE_RATIO 4 /* Enough for 11,025 Hz -> 44,100 Hz */ +#define RESAMPLE_RATIO 4 /* Enough for 11,025 Hz -> 44,100 Hz */ +#define SMALL_RESAMPLE_BUF_COUNT (SMALL_SAMPLE_BUF_COUNT * RESAMPLE_RATIO) +#define BIG_SAMPLE_BUF_COUNT SMALL_RESAMPLE_BUF_COUNT +#define BIG_RESAMPLE_BUF_COUNT (BIG_SAMPLE_BUF_COUNT * RESAMPLE_RATIO) -static int32_t small_sample_buf[SMALL_SAMPLE_BUF_COUNT] IBSS_ATTR; -static int32_t small_resample_buf[SMALL_SAMPLE_BUF_COUNT * RESAMPLE_RATIO] IBSS_ATTR; +static int32_t small_sample_buf[2][SMALL_SAMPLE_BUF_COUNT] IBSS_ATTR; +static int32_t small_resample_buf[2][SMALL_RESAMPLE_BUF_COUNT] IBSS_ATTR; #ifdef HAVE_PITCHSCREEN -static int32_t *big_sample_buf = NULL; -static int32_t *big_resample_buf = NULL; -static int big_sample_buf_count = -1; /* -1=unknown, 0=not available */ +static int32_t (* big_sample_buf)[BIG_SAMPLE_BUF_COUNT] = NULL; +static int32_t (* big_resample_buf)[BIG_RESAMPLE_BUF_COUNT] = NULL; #endif static int sample_buf_count = SMALL_SAMPLE_BUF_COUNT; -static int32_t *sample_buf = small_sample_buf; -static int32_t *resample_buf = small_resample_buf; - -#define SAMPLE_BUF_LEFT_CHANNEL 0 -#define SAMPLE_BUF_RIGHT_CHANNEL (sample_buf_count/2) -#define RESAMPLE_BUF_LEFT_CHANNEL 0 -#define RESAMPLE_BUF_RIGHT_CHANNEL (sample_buf_count/2 * RESAMPLE_RATIO) +static int32_t *sample_buf[2] = { small_sample_buf[0], small_sample_buf[1] }; +static int resample_buf_count = SMALL_RESAMPLE_BUF_COUNT; +static int32_t *resample_buf[2] = { small_resample_buf[0], small_resample_buf[1] }; /* compressor */ static struct compressor_menu c_menu; @@ -297,14 +294,19 @@ static void tdspeed_setup(struct dsp_config *dspc) { /* Assume timestretch will not be used */ dspc->tdspeed_active = false; - sample_buf = small_sample_buf; - resample_buf = small_resample_buf; + sample_buf[0] = small_sample_buf[0]; + sample_buf[1] = small_sample_buf[1]; + resample_buf[0] = small_resample_buf[0]; + resample_buf[1] = small_resample_buf[1]; sample_buf_count = SMALL_SAMPLE_BUF_COUNT; + resample_buf_count = SMALL_RESAMPLE_BUF_COUNT; - if(!dsp_timestretch_available()) + if (!dsp_timestretch_available()) return; /* Timestretch not enabled or buffer not allocated */ + if (dspc->tdspeed_percent == 0) dspc->tdspeed_percent = PITCH_SPEED_100; + if (!tdspeed_config( dspc->codec_frequency == 0 ? NATIVE_FREQUENCY : dspc->codec_frequency, dspc->stereo_mode != STEREO_MONO, @@ -313,9 +315,12 @@ static void tdspeed_setup(struct dsp_config *dspc) /* Timestretch is to be used */ dspc->tdspeed_active = true; - sample_buf = big_sample_buf; - sample_buf_count = big_sample_buf_count; - resample_buf = big_resample_buf; + sample_buf[0] = big_sample_buf[0]; + sample_buf[1] = big_sample_buf[1]; + resample_buf[0] = big_resample_buf[0]; + resample_buf[1] = big_resample_buf[1]; + sample_buf_count = BIG_SAMPLE_BUF_COUNT; + resample_buf_count = BIG_RESAMPLE_BUF_COUNT; } @@ -337,31 +342,41 @@ void dsp_timestretch_enable(bool enabled) { /* Hook to set up timestretch buffer on first call to settings_apply() */ static int handle; + if (enabled) { - if (big_sample_buf_count > 0) + if (big_sample_buf) return; /* already allocated and enabled */ + /* Set up timestretch buffers */ - big_sample_buf_count = SMALL_SAMPLE_BUF_COUNT * RESAMPLE_RATIO; - big_sample_buf = small_resample_buf; + big_sample_buf = &small_resample_buf[0]; + handle = core_alloc_ex("resample buf", - big_sample_buf_count * RESAMPLE_RATIO * sizeof(int32_t), &ops); - if (handle > 0) - { /* success, now setup tdspeed */ + 2 * BIG_RESAMPLE_BUF_COUNT * sizeof(int32_t), + &ops); + + enabled = handle > 0; + + if (enabled) + { + /* success, now setup tdspeed */ big_resample_buf = core_get_data(handle); + tdspeed_init(); tdspeed_setup(&AUDIO_DSP); } } - if (!enabled || (handle <= 0)) /* disable */ + + if (!enabled) { dsp_set_timestretch(PITCH_SPEED_100); tdspeed_finish(); + if (handle > 0) core_free(handle); + handle = 0; big_sample_buf = NULL; - big_sample_buf_count = 0; } } @@ -378,9 +393,9 @@ int32_t dsp_get_timestretch() bool dsp_timestretch_available() { - return (global_settings.timestretch_enabled && big_sample_buf_count > 0); + return (global_settings.timestretch_enabled && big_sample_buf); } -#endif +#endif /* HAVE_PITCHSCREEN */ /* Convert count samples to the internal format, if needed. Updates src * to point past the samples "consumed" and dst is set to point to the @@ -394,7 +409,7 @@ static void sample_input_lte_native_mono( { const int16_t *s = (int16_t *) src[0]; const int16_t * const send = s + count; - int32_t *d = dst[0] = dst[1] = &sample_buf[SAMPLE_BUF_LEFT_CHANNEL]; + int32_t *d = dst[0] = dst[1] = sample_buf[0]; int scale = WORD_SHIFT; while (s < send) @@ -411,8 +426,8 @@ static void sample_input_lte_native_i_stereo( { const int32_t *s = (int32_t *) src[0]; const int32_t * const send = s + count; - int32_t *dl = dst[0] = &sample_buf[SAMPLE_BUF_LEFT_CHANNEL]; - int32_t *dr = dst[1] = &sample_buf[SAMPLE_BUF_RIGHT_CHANNEL]; + int32_t *dl = dst[0] = sample_buf[0]; + int32_t *dr = dst[1] = sample_buf[1]; int scale = WORD_SHIFT; while (s < send) @@ -437,8 +452,8 @@ static void sample_input_lte_native_ni_stereo( const int16_t *sl = (int16_t *) src[0]; const int16_t *sr = (int16_t *) src[1]; const int16_t * const slend = sl + count; - int32_t *dl = dst[0] = &sample_buf[SAMPLE_BUF_LEFT_CHANNEL]; - int32_t *dr = dst[1] = &sample_buf[SAMPLE_BUF_RIGHT_CHANNEL]; + int32_t *dl = dst[0] = sample_buf[0]; + int32_t *dr = dst[1] = sample_buf[1]; int scale = WORD_SHIFT; while (sl < slend) @@ -465,8 +480,8 @@ static void sample_input_gt_native_i_stereo( { const int32_t *s = (int32_t *)src[0]; const int32_t * const send = s + 2*count; - int32_t *dl = dst[0] = &sample_buf[SAMPLE_BUF_LEFT_CHANNEL]; - int32_t *dr = dst[1] = &sample_buf[SAMPLE_BUF_RIGHT_CHANNEL]; + int32_t *dl = dst[0] = sample_buf[0]; + int32_t *dr = dst[1] = sample_buf[1]; while (s < send) { @@ -776,8 +791,8 @@ static inline int resample(struct dsp_config *dsp, int count, int32_t *src[]) { int32_t *dst[2] = { - &resample_buf[RESAMPLE_BUF_LEFT_CHANNEL], - &resample_buf[RESAMPLE_BUF_RIGHT_CHANNEL], + resample_buf[0], + resample_buf[1] }; count = dsp->resample(count, &dsp->data, (const int32_t **)src, dst); @@ -1254,7 +1269,7 @@ int dsp_process(struct dsp_config *dsp, char *dst, const char *src[], int count) will be preloaded to be used for the call if not. */ while (count > 0) { - int samples = MIN(sample_buf_count/2, count); + int samples = MIN(sample_buf_count, count); count -= samples; dsp->input_samples(samples, src, tmp); @@ -1271,7 +1286,7 @@ int dsp_process(struct dsp_config *dsp, char *dst, const char *src[], int count) t2[0] = tmp[0]+chunk_offset; t2[1] = tmp[1]+chunk_offset; - int chunk = MIN(sample_buf_count/2, samples); + int chunk = MIN(sample_buf_count, samples); chunk_offset += chunk; samples -= chunk; @@ -1341,12 +1356,12 @@ int dsp_output_count(struct dsp_config *dsp, int count) } /* Now we have the resampled sample count which must not exceed - * RESAMPLE_BUF_RIGHT_CHANNEL to avoid resample buffer overflow. One + * resample_buf_count to avoid resample buffer overflow. One * must call dsp_input_count() to get the correct input sample * count. */ - if (count > RESAMPLE_BUF_RIGHT_CHANNEL) - count = RESAMPLE_BUF_RIGHT_CHANNEL; + if (count > resample_buf_count) + count = resample_buf_count; return count; }