dsp->input_samples(samples, src, tmp);

#ifdef HAVE_PITCHSCREEN
         if (dsp->tdspeed_active)
             samples = tdspeed_doit(tmp, samples);
#endif
          
         int chunk_offset = 0;
         while (samples > 0)
         {
             int32_t *t2[2];
             t2[0] = tmp[0]+chunk_offset;
             t2[1] = tmp[1]+chunk_offset;

             int chunk = MIN(sample_buf_count, samples);
             chunk_offset += chunk;
             samples -= chunk;

             if (dsp->apply_gain)
                 dsp->apply_gain(chunk, &dsp->data, t2);

             if (dsp->resample && (chunk = resample(dsp, chunk, t2)) <= 0)
                 break; /* I'm pretty sure we're downsampling here */

             if (dsp->apply_crossfeed)
                 dsp->apply_crossfeed(chunk, t2);

             if (dsp->eq_process)
                 dsp->eq_process(chunk, t2);

#ifdef HAVE_SW_TONE_CONTROLS
             if ((bass | treble) != 0)
                 eq_filter(t2, &dsp->tone_filter, chunk,
                       dsp->data.num_channels, FILTER_BISHELF_SHIFT);
#endif

             if (dsp->channels_process)
                 dsp->channels_process(chunk, t2);
              
             if (dsp->compressor_process)
                 dsp->compressor_process(chunk, t2);

             dsp->output_samples(chunk, &dsp->data, (const int32_t **)t2, (int16_t *)dst);

/* convert count 16-bit noninterleaved stereo to 32-bit noninterleaved */
static void sample_input_lte_native_ni_stereo(
     int count, const char *src[], int32_t *dst[])
{
     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[0];
     int32_t *dr = dst[1] = sample_buf[1];
     int scale = WORD_SHIFT;

     while (sl < slend)
     {
         *dl++ = *sl++ << scale;
         *dr++ = *sr++ << scale;
     }

     src[0] = (char *)sl;
     src[1] = (char *)sr;
}

/* write stereo internal format to output format */
static void sample_output_stereo(int count, struct dsp_data *data,
                    const int32_t *src[], int16_t *dst)
{
     const int32_t *s0 = src[0];
     const int32_t *s1 = src[1];
     const int scale = data->output_scale;
     const int dc_bias = 1 << (scale - 1);

     while (count-- > 0)
     {
         *dst++ = clip_sample_16((*s0++ + dc_bias) >> scale);
         *dst++ = clip_sample_16((*s1++ + dc_bias) >> scale);
     }
}

/* Clip sample to signed 16 bit range */
static inline int32_t clip_sample_16(int32_t sample)
{
     if ((int16_t)sample != sample)
         sample = 0x7fff ^ (sample >> 31);
     return sample;
}

/* Combine all gains to a global gain. */
static void set_gain(struct dsp_config *dsp)
{
     /* gains are in S7.24 format */
     dsp->data.gain = DEFAULT_GAIN;

     /* Replay gain not relevant to voice */
     if (dsp == &AUDIO_DSP && replaygain)
     {
         dsp->data.gain = replaygain;
     }

     if (dsp->eq_process && eq_precut)
     {
         dsp->data.gain = fp_mul(dsp->data.gain, eq_precut, 24);
     }

#ifdef HAVE_SW_VOLUME_CONTROL
     if (global_settings.volume < SW_VOLUME_MAX ||
         global_settings.volume > SW_VOLUME_MIN)
     {
         int vol_gain = get_replaygain_int(global_settings.volume * 100);
         dsp->data.gain = (long) (((int64_t) dsp->data.gain * vol_gain) >> 24);
     }
#endif

     if (dsp->data.gain == DEFAULT_GAIN)
     {
         dsp->data.gain = 0;
     }
     else
     {
         dsp->data.gain >>= 1;   /* convert gain to S8.23 format */
     }

     dsp->apply_gain = dsp->data.gain != 0 ? dsp_apply_gain : NULL;
}