resample2.c 10.4 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 40
#define FELEM int16_t
#define FELEM2 int32_t
#define FELEM_MAX INT16_MAX
#define FELEM_MIN INT16_MIN
#else
41
#define FILTER_SHIFT 30
42 43 44 45 46 47 48 49

#define FELEM int32_t
#define FELEM2 int64_t
#define FELEM_MAX INT32_MAX
#define FELEM_MIN INT32_MIN
#endif


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

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

72 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
 * @param type 0->cubic, 1->blackman nuttall windowed sinc, 2->kaiser windowed sinc beta=16
 */
85
void av_build_filter(FELEM *filter, double factor, int tap_count, int phase_count, int scale, int type){
86 87 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;
            case 2:
                w = 2.0*x / (factor*tap_count*M_PI);
113
                y *= bessel(16*sqrt(FFMAX(1-w*w, 0)));
114 115 116 117 118 119 120 121 122
                break;
            }

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

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

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

174 175 176
    c->phase_shift= phase_shift;
    c->phase_mask= phase_count-1;
    c->linear= linear;
177

178
    c->filter_length= FFMAX((int)ceil(filter_size/factor), 1);
179 180 181 182
    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];
183 184

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

    return c;
}

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

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

/**
 * 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;
229
    int compensation_distance= c->compensation_distance;
230

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

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

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

        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++;
        }
278 279 280 281 282 283

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

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

307 308
    return dst_index;
}