resample2.c 10.5 KB
Newer Older
1 2 3 4
/*
 * audio resampling
 * Copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 21
 *
 */
22

23 24 25 26 27 28 29 30
/**
 * @file resample2.c
 * audio resampling
 * @author Michael Niedermayer <michaelni@gmx.at>
 */

#include "avcodec.h"
#include "common.h"
31
#include "dsputil.h"
32

33
#ifndef CONFIG_RESAMPLE_HP
34 35
#define FILTER_SHIFT 15

36 37 38 39
#define FELEM int16_t
#define FELEM2 int32_t
#define FELEM_MAX INT16_MAX
#define FELEM_MIN INT16_MIN
40
#define WINDOW_TYPE 9
41
#else
42
#define FILTER_SHIFT 30
43 44 45 46 47

#define FELEM int32_t
#define FELEM2 int64_t
#define FELEM_MAX INT32_MAX
#define FELEM_MIN INT32_MIN
48
#define WINDOW_TYPE 12
49 50 51
#endif


52
typedef struct AVResampleContext{
53
    FELEM *filter_bank;
54 55 56 57 58 59 60
    int filter_length;
    int ideal_dst_incr;
    int dst_incr;
    int index;
    int frac;
    int src_incr;
    int compensation_distance;
61 62 63
    int phase_shift;
    int phase_mask;
    int linear;
64 65 66 67 68
}AVResampleContext;

/**
 * 0th order modified bessel function of the first kind.
 */
69
static double bessel(double x){
70 71 72
    double v=1;
    double t=1;
    int i;
73

74
    x= x*x/4;
75
    for(i=1; i<50; i++){
76 77
        t *= x/(i*i);
        v += t;
78 79 80 81 82 83 84 85
    }
    return v;
}

/**
 * builds a polyphase filterbank.
 * @param factor resampling factor
 * @param scale wanted sum of coefficients for each filter
86
 * @param type 0->cubic, 1->blackman nuttall windowed sinc, 2..16->kaiser windowed sinc beta=2..16
87
 */
88
void av_build_filter(FELEM *filter, double factor, int tap_count, int phase_count, int scale, int type){
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
    int ph, i, v;
    double x, y, w, tab[tap_count];
    const int center= (tap_count-1)/2;

    /* if upsampling, only need to interpolate, no filter */
    if (factor > 1.0)
        factor = 1.0;

    for(ph=0;ph<phase_count;ph++) {
        double norm = 0;
        for(i=0;i<tap_count;i++) {
            x = M_PI * ((double)(i - center) - (double)ph / phase_count) * factor;
            if (x == 0) y = 1.0;
            else        y = sin(x) / x;
            switch(type){
            case 0:{
                const float d= -0.5; //first order derivative = -0.5
                x = fabs(((double)(i - center) - (double)ph / phase_count) * factor);
                if(x<1.0) y= 1 - 3*x*x + 2*x*x*x + d*(            -x*x + x*x*x);
                else      y=                       d*(-4 + 8*x - 5*x*x + x*x*x);
                break;}
            case 1:
                w = 2.0*x / (factor*tap_count) + M_PI;
                y *= 0.3635819 - 0.4891775 * cos(w) + 0.1365995 * cos(2*w) - 0.0106411 * cos(3*w);
                break;
114
            default:
115
                w = 2.0*x / (factor*tap_count*M_PI);
116
                y *= bessel(type*sqrt(FFMAX(1-w*w, 0)));
117 118 119 120 121 122 123 124 125
                break;
            }

            tab[i] = y;
            norm += y;
        }

        /* normalize so that an uniform color remains the same */
        for(i=0;i<tap_count;i++) {
126
            v = av_clip(lrintf(tab[i] * scale / norm), FELEM_MIN, FELEM_MAX);
127 128 129
            filter[ph * tap_count + i] = v;
        }
    }
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
#if 0
    {
#define LEN 1024
        int j,k;
        double sine[LEN + tap_count];
        double filtered[LEN];
        double maxff=-2, minff=2, maxsf=-2, minsf=2;
        for(i=0; i<LEN; i++){
            double ss=0, sf=0, ff=0;
            for(j=0; j<LEN+tap_count; j++)
                sine[j]= cos(i*j*M_PI/LEN);
            for(j=0; j<LEN; j++){
                double sum=0;
                ph=0;
                for(k=0; k<tap_count; k++)
                    sum += filter[ph * tap_count + k] * sine[k+j];
                filtered[j]= sum / (1<<FILTER_SHIFT);
                ss+= sine[j + center] * sine[j + center];
                ff+= filtered[j] * filtered[j];
                sf+= sine[j + center] * filtered[j];
            }
            ss= sqrt(2*ss/LEN);
            ff= sqrt(2*ff/LEN);
            sf= 2*sf/LEN;
            maxff= FFMAX(maxff, ff);
            minff= FFMIN(minff, ff);
            maxsf= FFMAX(maxsf, sf);
            minsf= FFMIN(minsf, sf);
            if(i%11==0){
                av_log(NULL, AV_LOG_ERROR, "i:%4d ss:%f ff:%f-%f sf:%f-%f\n", i, ss, maxff, minff, maxsf, minsf);
                minff=minsf= 2;
                maxff=maxsf= -2;
            }
        }
    }
#endif
166 167 168 169 170 171
}

/**
 * initalizes a audio resampler.
 * note, if either rate is not a integer then simply scale both rates up so they are
 */
172
AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff){
173
    AVResampleContext *c= av_mallocz(sizeof(AVResampleContext));
174
    double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
175
    int phase_count= 1<<phase_shift;
176

177 178 179
    c->phase_shift= phase_shift;
    c->phase_mask= phase_count-1;
    c->linear= linear;
180

181
    c->filter_length= FFMAX((int)ceil(filter_size/factor), 1);
182
    c->filter_bank= av_mallocz(c->filter_length*(phase_count+1)*sizeof(FELEM));
183
    av_build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE);
184 185
    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];
186 187

    c->src_incr= out_rate;
188 189
    c->ideal_dst_incr= c->dst_incr= in_rate * phase_count;
    c->index= -phase_count*((c->filter_length-1)/2);
190 191 192 193 194 195 196 197 198

    return c;
}

void av_resample_close(AVResampleContext *c){
    av_freep(&c->filter_bank);
    av_freep(&c);
}

199 200 201 202 203 204 205 206 207
/**
 * 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
 *
208
 * note, due to rounding the actual compensation might be slightly different,
209 210
 * especially if the compensation_distance is large and the in_rate used during init is small
 */
211
void av_resample_compensate(AVResampleContext *c, int sample_delta, int compensation_distance){
212
//    sample_delta += (c->ideal_dst_incr - c->dst_incr)*(int64_t)c->compensation_distance / c->ideal_dst_incr;
213
    c->compensation_distance= compensation_distance;
214
    c->dst_incr = c->ideal_dst_incr - c->ideal_dst_incr * (int64_t)sample_delta / compensation_distance;
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
}

/**
 * resamples.
 * @param src an array of unconsumed samples
 * @param consumed the number of samples of src which have been consumed are returned here
 * @param src_size the number of unconsumed samples available
 * @param dst_size the amount of space in samples available in dst
 * @param update_ctx if this is 0 then the context wont be modified, that way several channels can be resampled with the same context
 * @return the number of samples written in dst or -1 if an error occured
 */
int av_resample(AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx){
    int dst_index, i;
    int index= c->index;
    int frac= c->frac;
    int dst_incr_frac= c->dst_incr % c->src_incr;
    int dst_incr=      c->dst_incr / c->src_incr;
232
    int compensation_distance= c->compensation_distance;
233

234
  if(compensation_distance == 0 && c->filter_length == 1 && c->phase_shift==0){
235 236 237
        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);
238

239
        for(dst_index=0; dst_index < dst_size; dst_index++){
240 241
            dst[dst_index] = src[index2>>32];
            index2 += incr;
242
        }
243 244 245 246
        frac += dst_index * dst_incr_frac;
        index += dst_index * dst_incr;
        index += frac / c->src_incr;
        frac %= c->src_incr;
247
  }else{
248
    for(dst_index=0; dst_index < dst_size; dst_index++){
249 250
        FELEM *filter= c->filter_bank + c->filter_length*(index & c->phase_mask);
        int sample_index= index >> c->phase_shift;
251
        FELEM2 val=0;
252

253 254
        if(sample_index < 0){
            for(i=0; i<c->filter_length; i++)
Diego Biurrun's avatar
Diego Biurrun committed
255
                val += src[FFABS(sample_index + i) % src_size] * filter[i];
256 257
        }else if(sample_index + c->filter_length > src_size){
            break;
258
        }else if(c->linear){
259
            int64_t v=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
260
            int sub_phase= (frac<<8) / c->src_incr;
261
            for(i=0; i<c->filter_length; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
262
                int64_t coeff= filter[i]*(256 - sub_phase) + filter[i + c->filter_length]*sub_phase;
263 264
                v += src[sample_index + i] * coeff;
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
265
            val= v>>8;
266
        }else{
267
            for(i=0; i<c->filter_length; i++){
268
                val += src[sample_index + i] * (FELEM2)filter[i];
269 270 271 272 273 274 275 276 277 278 279 280
            }
        }

        val = (val + (1<<(FILTER_SHIFT-1)))>>FILTER_SHIFT;
        dst[dst_index] = (unsigned)(val + 32768) > 65535 ? (val>>31) ^ 32767 : val;

        frac += dst_incr_frac;
        index += dst_incr;
        if(frac >= c->src_incr){
            frac -= c->src_incr;
            index++;
        }
281 282 283 284 285 286

        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;
        }
287
    }
288
  }
289
    *consumed= FFMAX(index, 0) >> c->phase_shift;
290
    if(index>=0) index &= c->phase_mask;
Michael Niedermayer's avatar
Michael Niedermayer committed
291

292 293 294 295
    if(compensation_distance){
        compensation_distance -= dst_index;
        assert(compensation_distance > 0);
    }
296 297
    if(update_ctx){
        c->frac= frac;
Michael Niedermayer's avatar
Michael Niedermayer committed
298
        c->index= index;
299 300
        c->dst_incr= dst_incr_frac + c->src_incr*dst_incr;
        c->compensation_distance= compensation_distance;
301
    }
302
#if 0
303 304 305 306 307 308
    if(update_ctx && !c->compensation_distance){
#undef rand
        av_resample_compensate(c, rand() % (8000*2) - 8000, 8000*2);
av_log(NULL, AV_LOG_DEBUG, "%d %d %d\n", c->dst_incr, c->ideal_dst_incr, c->compensation_distance);
    }
#endif
309

310 311
    return dst_index;
}