~ubuntu-branches/ubuntu/feisty/avidemux/feisty

#if 1

#define FELEM int16_t

#define FELEM2 int32_t

#define FELEM_MAX INT16_MAX

#define FELEM_MIN INT16_MIN

#else

#define FILTER_SHIFT 22

 

#define FELEM int32_t

#define FELEM2 int64_t

#define FELEM_MAX INT32_MAX

#define FELEM_MIN INT32_MIN

#endif

 

 

    FELEM *filter_bank;

    int phase_shift;

    int phase_mask;

    int linear;

void av_build_filter(FELEM *filter, double factor, int tap_count, int phase_count, int scale, int type){

            v = clip(lrintf(tab[i] * scale / norm + e), FELEM_MIN, FELEM_MAX);

AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff){

    double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);

    int phase_count= 1<<phase_shift;

    

    c->phase_shift= phase_shift;

    c->phase_mask= phase_count-1;

    c->linear= linear;

 

    c->filter_length= FFMAX(ceil(filter_size/factor), 1);

    c->filter_bank= av_mallocz(c->filter_length*(phase_count+1)*sizeof(FELEM));

    av_build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, 1);

    memcpy(&c->filter_bank[c->filter_length*phase_count+1], c->filter_bank, (c->filter_length-1)*sizeof(FELEM));

    c->filter_bank[c->filter_length*phase_count]= c->filter_bank[c->filter_length - 1];

    c->ideal_dst_incr= c->dst_incr= in_rate * phase_count;

    c->index= -phase_count*((c->filter_length-1)/2);

/**

 * Compensates samplerate/timestamp drift. The compensation is done by changing

 * the resampler parameters, so no audible clicks or similar distortions ocur

 * @param compensation_distance distance in output samples over which the compensation should be performed

 * @param sample_delta number of output samples which should be output less

 *

 * example: av_resample_compensate(c, 10, 500)

 * here instead of 510 samples only 500 samples would be output

 *

 * note, due to rounding the actual compensation might be slightly different, 

 * especially if the compensation_distance is large and the in_rate used during init is small

 */

    int compensation_distance= c->compensation_distance;

 

  if(compensation_distance == 0 && c->filter_length == 1 && c->phase_shift==0){

        int64_t index2= ((int64_t)index)<<32;

        int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr;

        dst_size= FFMIN(dst_size, (src_size-1-index) * (int64_t)c->src_incr / c->dst_incr);

        

        for(dst_index=0; dst_index < dst_size; dst_index++){

            dst[dst_index] = src[index2>>32];

            index2 += incr;

        }

        frac += dst_index * dst_incr_frac;

        index += dst_index * dst_incr;

        index += frac / c->src_incr;

        frac %= c->src_incr;

  }else{

        FELEM *filter= c->filter_bank + c->filter_length*(index & c->phase_mask);

        int sample_index= index >> c->phase_shift;

        FELEM2 val=0;

                

        }else if(c->linear){

            int sub_phase= (frac<<8) / c->src_incr;

                int64_t coeff= filter[i]*(256 - sub_phase) + filter[i + c->filter_length]*sub_phase;

            val= v>>8;

        }else{

                val += src[sample_index + i] * (FELEM2)filter[i];

 

        if(dst_index + 1 == compensation_distance){

            compensation_distance= 0;

            dst_incr_frac= c->ideal_dst_incr % c->src_incr;

            dst_incr=      c->ideal_dst_incr / c->src_incr;

        }

    }

  }

    *consumed= FFMAX(index, 0) >> c->phase_shift;

    if(index>=0) index &= c->phase_mask;

 

    if(compensation_distance){

        compensation_distance -= dst_index;

        assert(compensation_distance > 0);

    }

        c->dst_incr= dst_incr_frac + c->src_incr*dst_incr;

        c->compensation_distance= compensation_distance;