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 75 76 77 78 79 80 81 82 83 84
    for(i=1; i<50; i++){
        t *= i;
        v += pow(x*x/4, i)/(t*t);
    }
    return v;
}

/**
 * builds a polyphase filterbank.
 * @param factor resampling factor
 * @param scale wanted sum of coefficients for each filter
85
 * @param type 0->cubic, 1->blackman nuttall windowed sinc, 2..16->kaiser windowed sinc beta=2..16
86
 */
87
void av_build_filter(FELEM *filter, double factor, int tap_count, int phase_count, int scale, int type){
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
    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;
113
            default:
114
                w = 2.0*x / (factor*tap_count*M_PI);
115
                y *= bessel(type*sqrt(FFMAX(1-w*w, 0)));
116 117 118 119 120 121 122 123 124
                break;
            }

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

        /* normalize so that an uniform color remains the same */
        for(i=0;i<tap_count;i++) {
125
            v = av_clip(lrintf(tab[i] * scale / norm), FELEM_MIN, FELEM_MAX);
126 127 128
            filter[ph * tap_count + i] = v;
        }
    }
129 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
#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
165 166 167 168 169 170
}

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

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

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

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

    return c;
}

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

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

/**
 * 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;
231
    int compensation_distance= c->compensation_distance;
232

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

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

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

        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++;
        }
280 281 282 283 284 285

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

291 292 293 294
    if(compensation_distance){
        compensation_distance -= dst_index;
        assert(compensation_distance > 0);
    }
295 296
    if(update_ctx){
        c->frac= frac;
Michael Niedermayer's avatar
Michael Niedermayer committed
297
        c->index= index;
298 299
        c->dst_incr= dst_incr_frac + c->src_incr*dst_incr;
        c->compensation_distance= compensation_distance;
300
    }
301
#if 0
302 303 304 305 306 307
    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
308

309 310
    return dst_index;
}