libaf/af_resample.c

   1 /*
   2  * This audio filter changes the sample rate.
   3  *
   4  * Copyright (C) 2002 Anders Johansson ajh@atri.curtin.edu.au
   5  *
   6  * This file is part of MPlayer.
   7  *
   8  * MPlayer is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * MPlayer is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <inttypes.h>
  26
  27 #include "libavutil/common.h"
  28 #include "libavutil/mathematics.h"
  29 #include "af.h"
  30 #include "dsp.h"
  31
  32 /* Below definition selects the length of each poly phase component.
  33    Valid definitions are L8 and L16, where the number denotes the
  34    length of the filter. This definition affects the computational
  35    complexity (see play()), the performance (see filter.h) and the
  36    memory usage. The filterlength is choosen to 8 if the machine is
  37    slow and to 16 if the machine is fast and has MMX.
  38 */
  39
  40 #if !HAVE_MMX // This machine is slow
  41 #define L8
  42 #else
  43 #define L16
  44 #endif
  45
  46 #include "af_resample_template.c"
  47
  48 // Filtering types
  49 #define RSMP_LIN        (0<<0)  // Linear interpolation
  50 #define RSMP_INT        (1<<0)  // 16 bit integer
  51 #define RSMP_FLOAT      (2<<0)  // 32 bit floating point
  52 #define RSMP_MASK       (3<<0)
  53
  54 // Defines for sloppy or exact resampling
  55 #define FREQ_SLOPPY     (0<<2)
  56 #define FREQ_EXACT      (1<<2)
  57 #define FREQ_MASK       (1<<2)
  58
  59 // Accuracy for linear interpolation
  60 #define STEPACCURACY 32
  61
  62 // local data
  63 typedef struct af_resample_s
  64 {
  65   void*         w;      // Current filter weights
  66   void**        xq;     // Circular buffers
  67   uint32_t      xi;     // Index for circular buffers
  68   uint32_t      wi;     // Index for w
  69   uint32_t      i;      // Number of new samples to put in x queue
  70   uint32_t      dn;     // Down sampling factor
  71   uint32_t      up;     // Up sampling factor
  72   uint64_t      step;   // Step size for linear interpolation
  73   uint64_t      pt;     // Pointer remainder for linear interpolation
  74   int           setup;  // Setup parameters cmdline or through postcreate
  75 } af_resample_t;
  76
  77 // Fast linear interpolation resample with modest audio quality
  78 static int linint(af_data_t* c,af_data_t* l, af_resample_t* s)
  79 {
  80   uint32_t      len   = 0;              // Number of input samples
  81   uint32_t      nch   = l->nch;         // Words pre transfer
  82   uint64_t      step  = s->step;
  83   int16_t*      in16  = ((int16_t*)c->audio);
  84   int16_t*      out16 = ((int16_t*)l->audio);
  85   int32_t*      in32  = ((int32_t*)c->audio);
  86   int32_t*      out32 = ((int32_t*)l->audio);
  87   uint64_t      end   = ((((uint64_t)c->len)/2LL)<<STEPACCURACY);
  88   uint64_t      pt    = s->pt;
  89   uint16_t      tmp;
  90
  91   switch (nch){
  92   case 1:
  93     while(pt < end){
  94       out16[len++]=in16[pt>>STEPACCURACY];
  95       pt+=step;
  96     }
  97     s->pt=pt & ((1LL<<STEPACCURACY)-1);
  98     break;
  99   case 2:
 100     end/=2;
 101     while(pt < end){
 102       out32[len++]=in32[pt>>STEPACCURACY];
 103       pt+=step;
 104     }
 105     len=(len<<1);
 106     s->pt=pt & ((1LL<<STEPACCURACY)-1);
 107     break;
 108   default:
 109     end /=nch;
 110     while(pt < end){
 111       tmp=nch;
 112       do {
 113         tmp--;
 114         out16[len+tmp]=in16[tmp+(pt>>STEPACCURACY)*nch];
 115       } while (tmp);
 116       len+=nch;
 117       pt+=step;
 118     }
 119     s->pt=pt & ((1LL<<STEPACCURACY)-1);
 120   }
 121   return len;
 122 }
 123
 124 /* Determine resampling type and format */
 125 static int set_types(struct af_instance_s* af, af_data_t* data)
 126 {
 127   af_resample_t* s = af->setup;
 128   int rv = AF_OK;
 129   float rd = 0;
 130
 131   // Make sure this filter isn't redundant
 132   if((af->data->rate == data->rate) || (af->data->rate == 0))
 133     return AF_DETACH;
 134   /* If sloppy and small resampling difference (2%) */
 135   rd = abs((float)af->data->rate - (float)data->rate)/(float)data->rate;
 136   if((((s->setup & FREQ_MASK) == FREQ_SLOPPY) && (rd < 0.02) &&
 137       (data->format != (AF_FORMAT_FLOAT_NE))) ||
 138      ((s->setup & RSMP_MASK) == RSMP_LIN)){
 139     s->setup = (s->setup & ~RSMP_MASK) | RSMP_LIN;
 140     af->data->format = AF_FORMAT_S16_NE;
 141     af->data->bps    = 2;
 142     af_msg(AF_MSG_VERBOSE,"[resample] Using linear interpolation. \n");
 143   }
 144   else{
 145     /* If the input format is float or if float is explicitly selected
 146        use float, otherwise use int */
 147     if((data->format == (AF_FORMAT_FLOAT_NE)) ||
 148        ((s->setup & RSMP_MASK) == RSMP_FLOAT)){
 149       s->setup = (s->setup & ~RSMP_MASK) | RSMP_FLOAT;
 150       af->data->format = AF_FORMAT_FLOAT_NE;
 151       af->data->bps    = 4;
 152     }
 153     else{
 154       s->setup = (s->setup & ~RSMP_MASK) | RSMP_INT;
 155       af->data->format = AF_FORMAT_S16_NE;
 156       af->data->bps    = 2;
 157     }
 158     af_msg(AF_MSG_VERBOSE,"[resample] Using %s processing and %s frequecy"
 159            " conversion.\n",
 160            ((s->setup & RSMP_MASK) == RSMP_FLOAT)?"floating point":"integer",
 161            ((s->setup & FREQ_MASK) == FREQ_SLOPPY)?"inexact":"exact");
 162   }
 163
 164   if(af->data->format != data->format || af->data->bps != data->bps)
 165     rv = AF_FALSE;
 166   data->format = af->data->format;
 167   data->bps = af->data->bps;
 168   af->data->nch = data->nch;
 169   return rv;
 170 }
 171
 172 // Initialization and runtime control
 173 static int control(struct af_instance_s* af, int cmd, void* arg)
 174 {
 175   switch(cmd){
 176   case AF_CONTROL_REINIT:{
 177     af_resample_t* s   = (af_resample_t*)af->setup;
 178     af_data_t*     n   = (af_data_t*)arg; // New configureation
 179     int            i,d = 0;
 180     int            rv  = AF_OK;
 181
 182     // Free space for circular bufers
 183     if(s->xq){
 184       for(i=1;i<af->data->nch;i++)
 185         if(s->xq[i])
 186           free(s->xq[i]);
 187       free(s->xq);
 188       s->xq = NULL;
 189     }
 190
 191     if(AF_DETACH == (rv = set_types(af,n)))
 192       return AF_DETACH;
 193
 194     // If linear interpolation
 195     if((s->setup & RSMP_MASK) == RSMP_LIN){
 196       s->pt=0LL;
 197       s->step=((uint64_t)n->rate<<STEPACCURACY)/(uint64_t)af->data->rate+1LL;
 198       af_msg(AF_MSG_DEBUG0,"[resample] Linear interpolation step: 0x%016"PRIX64".\n",
 199              s->step);
 200       af->mul = (double)af->data->rate / n->rate;
 201       return rv;
 202     }
 203
 204     // Calculate up and down sampling factors
 205     d=av_gcd(af->data->rate,n->rate);
 206
 207     // If sloppy resampling is enabled limit the upsampling factor
 208     if(((s->setup & FREQ_MASK) == FREQ_SLOPPY) && (af->data->rate/d > 5000)){
 209       int up=af->data->rate/2;
 210       int dn=n->rate/2;
 211       int m=2;
 212       while(af->data->rate/(d*m) > 5000){
 213         d=av_gcd(up,dn);
 214         up/=2; dn/=2; m*=2;
 215       }
 216       d*=m;
 217     }
 218
 219     // Create space for circular bufers
 220     s->xq = malloc(n->nch*sizeof(void*));
 221     for(i=0;i<n->nch;i++)
 222       s->xq[i] = malloc(2*L*af->data->bps);
 223     s->xi = 0;
 224
 225     // Check if the the design needs to be redone
 226     if(s->up != af->data->rate/d || s->dn != n->rate/d){
 227       float* w;
 228       float* wt;
 229       float fc;
 230       int j;
 231       s->up = af->data->rate/d;
 232       s->dn = n->rate/d;
 233       s->wi = 0;
 234       s->i = 0;
 235
 236       // Calculate cuttof frequency for filter
 237       fc = 1/(float)(max(s->up,s->dn));
 238       // Allocate space for polyphase filter bank and protptype filter
 239       w = malloc(sizeof(float) * s->up *L);
 240       if(NULL != s->w)
 241         free(s->w);
 242       s->w = malloc(L*s->up*af->data->bps);
 243
 244       // Design prototype filter type using Kaiser window with beta = 10
 245       if(NULL == w || NULL == s->w ||
 246          -1 == af_filter_design_fir(s->up*L, w, &fc, LP|KAISER , 10.0)){
 247         af_msg(AF_MSG_ERROR,"[resample] Unable to design prototype filter.\n");
 248         return AF_ERROR;
 249       }
 250       // Copy data from prototype to polyphase filter
 251       wt=w;
 252       for(j=0;j<L;j++){//Columns
 253         for(i=0;i<s->up;i++){//Rows
 254           if((s->setup & RSMP_MASK) == RSMP_INT){
 255             float t=(float)s->up*32767.0*(*wt);
 256             ((int16_t*)s->w)[i*L+j] = (int16_t)((t>=0.0)?(t+0.5):(t-0.5));
 257           }
 258           else
 259             ((float*)s->w)[i*L+j] = (float)s->up*(*wt);
 260           wt++;
 261         }
 262       }
 263       free(w);
 264       af_msg(AF_MSG_VERBOSE,"[resample] New filter designed up: %i "
 265              "down: %i\n", s->up, s->dn);
 266     }
 267
 268     // Set multiplier and delay
 269     af->delay = 0; // not set correctly, but shouldn't be too large anyway
 270     af->mul = (double)s->up / s->dn;
 271     return rv;
 272   }
 273   case AF_CONTROL_COMMAND_LINE:{
 274     af_resample_t* s   = (af_resample_t*)af->setup;
 275     int rate=0;
 276     int type=RSMP_INT;
 277     int sloppy=1;
 278     sscanf((char*)arg,"%i:%i:%i", &rate, &sloppy, &type);
 279     s->setup = (sloppy?FREQ_SLOPPY:FREQ_EXACT) |
 280       (clamp(type,RSMP_LIN,RSMP_FLOAT));
 281     return af->control(af,AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET, &rate);
 282   }
 283   case AF_CONTROL_POST_CREATE:
 284     if((((af_cfg_t*)arg)->force & AF_INIT_FORMAT_MASK) == AF_INIT_FLOAT)
 285       ((af_resample_t*)af->setup)->setup = RSMP_FLOAT;
 286     return AF_OK;
 287   case AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET:
 288     // Reinit must be called after this function has been called
 289
 290     // Sanity check
 291     if(((int*)arg)[0] < 8000 || ((int*)arg)[0] > 192000){
 292       af_msg(AF_MSG_ERROR,"[resample] The output sample frequency "
 293              "must be between 8kHz and 192kHz. Current value is %i \n",
 294              ((int*)arg)[0]);
 295       return AF_ERROR;
 296     }
 297
 298     af->data->rate=((int*)arg)[0];
 299     af_msg(AF_MSG_VERBOSE,"[resample] Changing sample rate "
 300            "to %iHz\n",af->data->rate);
 301     return AF_OK;
 302   }
 303   return AF_UNKNOWN;
 304 }
 305
 306 // Deallocate memory
 307 static void uninit(struct af_instance_s* af)
 308 {
 309   if(af->data)
 310     free(af->data->audio);
 311   free(af->data);
 312 }
 313
 314 // Filter data through filter
 315 static af_data_t* play(struct af_instance_s* af, af_data_t* data)
 316 {
 317   int            len = 0;        // Length of output data
 318   af_data_t*     c   = data;     // Current working data
 319   af_data_t*     l   = af->data; // Local data
 320   af_resample_t* s   = (af_resample_t*)af->setup;
 321
 322   if(AF_OK != RESIZE_LOCAL_BUFFER(af,data))
 323     return NULL;
 324
 325   // Run resampling
 326   switch(s->setup & RSMP_MASK){
 327   case(RSMP_INT):
 328 # define FORMAT_I 1
 329     if(s->up>s->dn){
 330 #     define UP
 331 #     include "af_resample_template.c"
 332 #     undef UP
 333     }
 334     else{
 335 #     define DN
 336 #     include "af_resample_template.c"
 337 #     undef DN
 338     }
 339     break;
 340   case(RSMP_FLOAT):
 341 # undef FORMAT_I
 342 # define FORMAT_F 1
 343     if(s->up>s->dn){
 344 #     define UP
 345 #     include "af_resample_template.c"
 346 #     undef UP
 347     }
 348     else{
 349 #     define DN
 350 #     include "af_resample_template.c"
 351 #     undef DN
 352     }
 353     break;
 354   case(RSMP_LIN):
 355     len = linint(c, l, s);
 356     break;
 357   }
 358
 359   // Set output data
 360   c->audio = l->audio;
 361   c->len   = len*l->bps;
 362   c->rate  = l->rate;
 363
 364   return c;
 365 }
 366
 367 // Allocate memory and set function pointers
 368 static int af_open(af_instance_t* af){
 369   af->control=control;
 370   af->uninit=uninit;
 371   af->play=play;
 372   af->mul=1;
 373   af->data=calloc(1,sizeof(af_data_t));
 374   af->setup=calloc(1,sizeof(af_resample_t));
 375   if(af->data == NULL || af->setup == NULL)
 376     return AF_ERROR;
 377   ((af_resample_t*)af->setup)->setup = RSMP_INT | FREQ_SLOPPY;
 378   return AF_OK;
 379 }
 380
 381 // Description of this plugin
 382 af_info_t af_info_resample = {
 383   "Sample frequency conversion",
 384   "resample",
 385   "Anders",
 386   "",
 387   AF_FLAGS_REENTRANT,
 388   af_open
 389 };
 390