libaf/af_pan.c

   1 /*=============================================================================
   2 //
   3 //  This software has been released under the terms of the GNU General Public
   4 //  license. See http://www.gnu.org/copyleft/gpl.html for details.
   5 //
   6 //  Copyright 2002 Anders Johansson ajh@atri.curtin.edu.au
   7 //
   8 //=============================================================================
   9 */
  10
  11 /* */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15
  16 #include <inttypes.h>
  17 #include <math.h>
  18 #include <limits.h>
  19
  20 #include "af.h"
  21
  22 // Data for specific instances of this filter
  23 typedef struct af_pan_s
  24 {
  25   int nch; // Number of output channels; zero means same as input
  26   float level[AF_NCH][AF_NCH];  // Gain level for each channel
  27 }af_pan_t;
  28
  29 // Initialization and runtime control
  30 static int control(struct af_instance_s* af, int cmd, void* arg)
  31 {
  32   af_pan_t* s = af->setup;
  33
  34   switch(cmd){
  35   case AF_CONTROL_REINIT:
  36     // Sanity check
  37     if(!arg) return AF_ERROR;
  38
  39     af->data->rate   = ((af_data_t*)arg)->rate;
  40     af->data->format = AF_FORMAT_FLOAT_NE;
  41     af->data->bps    = 4;
  42     af->data->nch    = s->nch ? s->nch: ((af_data_t*)arg)->nch;
  43     af->mul.n        = af->data->nch;
  44     af->mul.d        = ((af_data_t*)arg)->nch;
  45     af_frac_cancel(&af->mul);
  46
  47     if((af->data->format != ((af_data_t*)arg)->format) ||
  48        (af->data->bps != ((af_data_t*)arg)->bps)){
  49       ((af_data_t*)arg)->format = af->data->format;
  50       ((af_data_t*)arg)->bps = af->data->bps;
  51       return AF_FALSE;
  52     }
  53     return AF_OK;
  54   case AF_CONTROL_COMMAND_LINE:{
  55     int   nch = 0;
  56     int   n = 0;
  57     char* cp = NULL;
  58     int   j,k;
  59     // Read number of outputs
  60     sscanf((char*)arg,"%i%n", &nch,&n);
  61     if(AF_OK != control(af,AF_CONTROL_PAN_NOUT | AF_CONTROL_SET, &nch))
  62       return AF_ERROR;
  63
  64     // Read pan values
  65     cp = &((char*)arg)[n];
  66     j = 0; k = 0;
  67     while((*cp == ':') && (k < AF_NCH)){
  68       sscanf(cp, ":%f%n" , &s->level[j][k], &n);
  69       af_msg(AF_MSG_VERBOSE,"[pan] Pan level from channel %i to"
  70              " channel %i = %f\n",k,j,s->level[j][k]);
  71       cp =&cp[n];
  72       j++;
  73       if(j>=nch){
  74         j = 0;
  75         k++;
  76       }
  77     }
  78     return AF_OK;
  79   }
  80   case AF_CONTROL_PAN_LEVEL | AF_CONTROL_SET:{
  81     int    i;
  82     int    ch = ((af_control_ext_t*)arg)->ch;
  83     float* level = ((af_control_ext_t*)arg)->arg;
  84     if (ch >= AF_NCH)
  85       return AF_FALSE;
  86     for(i=0;i<AF_NCH;i++)
  87       s->level[ch][i] = level[i];
  88     return AF_OK;
  89   }
  90   case AF_CONTROL_PAN_LEVEL | AF_CONTROL_GET:{
  91     int    i;
  92     int ch = ((af_control_ext_t*)arg)->ch;
  93     float* level = ((af_control_ext_t*)arg)->arg;
  94     if (ch >= AF_NCH)
  95       return AF_FALSE;
  96     for(i=0;i<AF_NCH;i++)
  97       level[i] = s->level[ch][i];
  98     return AF_OK;
  99   }
 100   case AF_CONTROL_PAN_NOUT | AF_CONTROL_SET:
 101     // Reinit must be called after this function has been called
 102
 103     // Sanity check
 104     if(((int*)arg)[0] <= 0 || ((int*)arg)[0] > AF_NCH){
 105       af_msg(AF_MSG_ERROR,"[pan] The number of output channels must be"
 106              " between 1 and %i. Current value is %i\n",AF_NCH,((int*)arg)[0]);
 107       return AF_ERROR;
 108     }
 109     s->nch=((int*)arg)[0];
 110     return AF_OK;
 111   case AF_CONTROL_PAN_NOUT | AF_CONTROL_GET:
 112     *(int*)arg = af->data->nch;
 113     return AF_OK;
 114   case AF_CONTROL_PAN_BALANCE | AF_CONTROL_SET:{
 115     float val = *(float*)arg;
 116     if (s->nch)
 117       return AF_ERROR;
 118     if (af->data->nch >= 2) {
 119       s->level[0][0] = min(1.f, 1.f - val);
 120       s->level[0][1] = max(0.f, val);
 121       s->level[1][0] = max(0.f, -val);
 122       s->level[1][1] = min(1.f, 1.f + val);
 123     }
 124     return AF_OK;
 125   }
 126   case AF_CONTROL_PAN_BALANCE | AF_CONTROL_GET:
 127     if (s->nch)
 128       return AF_ERROR;
 129     *(float*)arg = s->level[0][1] - s->level[1][0];
 130     return AF_OK;
 131   }
 132   return AF_UNKNOWN;
 133 }
 134
 135 // Deallocate memory
 136 static void uninit(struct af_instance_s* af)
 137 {
 138   if(af->data)
 139     free(af->data->audio);
 140   free(af->data);
 141   if(af->setup)
 142     free(af->setup);
 143 }
 144
 145 // Filter data through filter
 146 static af_data_t* play(struct af_instance_s* af, af_data_t* data)
 147 {
 148   af_data_t*    c    = data;            // Current working data
 149   af_data_t*    l    = af->data;        // Local data
 150   af_pan_t*     s    = af->setup;       // Setup for this instance
 151   float*        in   = c->audio;        // Input audio data
 152   float*        out  = NULL;            // Output audio data
 153   float*        end  = in+c->len/4;     // End of loop
 154   int           nchi = c->nch;          // Number of input channels
 155   int           ncho = l->nch;          // Number of output channels
 156   register int  j,k;
 157
 158   if(AF_OK != RESIZE_LOCAL_BUFFER(af,data))
 159     return NULL;
 160
 161   out = l->audio;
 162   // Execute panning
 163   // FIXME: Too slow
 164   while(in < end){
 165     for(j=0;j<ncho;j++){
 166       register float  x   = 0.0;
 167       register float* tin = in;
 168       for(k=0;k<nchi;k++)
 169         x += tin[k] * s->level[j][k];
 170       out[j] = x;
 171     }
 172     out+= ncho;
 173     in+= nchi;
 174   }
 175
 176   // Set output data
 177   c->audio = l->audio;
 178   c->len   = (c->len*af->mul.n)/af->mul.d;
 179   c->nch   = l->nch;
 180
 181   return c;
 182 }
 183
 184 // Allocate memory and set function pointers
 185 static int af_open(af_instance_t* af){
 186   af->control=control;
 187   af->uninit=uninit;
 188   af->play=play;
 189   af->mul.n=1;
 190   af->mul.d=1;
 191   af->data=calloc(1,sizeof(af_data_t));
 192   af->setup=calloc(1,sizeof(af_pan_t));
 193   if(af->data == NULL || af->setup == NULL)
 194     return AF_ERROR;
 195   return AF_OK;
 196 }
 197
 198 // Description of this filter
 199 af_info_t af_info_pan = {
 200     "Panning audio filter",
 201     "pan",
 202     "Anders",
 203     "",
 204     AF_FLAGS_REENTRANT,
 205     af_open
 206 };