output.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003 Angel Ortega <angel@triptico.com>
   5
   6     output.c - Output Interface
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program 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
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <math.h>
  31
  32 #include "core.h"
  33 #include "output.h"
  34
  35
  36 /*******************
  37         Data
  38 ********************/
  39
  40 /* master output volume */
  41 float _master_volume=1.0;
  42
  43 /* output accounting */
  44 int _output_frames=0;
  45 int _output_clipped=0;
  46 float _output_lowest=0;
  47 float _output_highest=0;
  48
  49 /* optimal output volume */
  50 float _optimal_volume;
  51
  52
  53 /* the output drivers */
  54
  55 extern struct _output_driver _out_driver_oss;
  56 extern struct _output_driver _out_driver_sgi;
  57 extern struct _output_driver _out_driver_wav;
  58 extern struct _output_driver _out_driver_raw;
  59 extern struct _output_driver _out_driver_pipe;
  60 extern struct _output_driver _out_driver_esd;
  61
  62 static struct _output_driver _out_driver_eof=
  63 { NULL, NULL, NULL, NULL, NULL };
  64
  65 static struct _output_driver * _drivers[] = {
  66         &_out_driver_oss,
  67         &_out_driver_sgi,
  68         &_out_driver_wav,
  69         &_out_driver_raw,
  70         &_out_driver_pipe,
  71         &_out_driver_esd,
  72         &_out_driver_eof
  73 };
  74
  75 /* driver in use */
  76 static struct _output_driver * drv=NULL;
  77
  78
  79 /*******************
  80         Code
  81 ********************/
  82
  83 /**
  84  * output_open - Opens an output device.
  85  * @name: name of the driver
  86  * @filename: name of the file or device
  87  *
  88  * Opens an output device. @name contains the name of the driver
  89  * (i.e. "raw" or "wav"), @filename contains the (optional) name
  90  * of the output file or device (i.e. a filename for "raw" or
  91  * "wav" or "/dev/dsp" for a direct audio device like "oss").
  92  * @Name can be the special pseudo-driver "default"
  93  * to select the most appropriate (usually a platform-specific
  94  * direct output device, or "wav" if no supported one exists).
  95  * @filename can also be NULL; in that case, a driver dependent,
  96  * default value is used.
  97  *
  98  * Returns the number of channels accepted by the output
  99  * driver, than can be less than the global _n_channels (in that
 100  * case, output will be intermixed).
 101  */
 102 int output_open(char * name, char * filename)
 103 {
 104         int n;
 105
 106         if(drv != NULL)
 107                 return(-1);
 108
 109         /* if driver name is 'default', open the first usable driver
 110            (supposedly the best for the current platform) */
 111         if(strcmp(name, "default") == 0)
 112         {
 113                 for(n=0;;n++)
 114                 {
 115                         if(_drivers[n]->name == NULL)
 116                                 return(-2);
 117
 118                         if(_drivers[n]->open != NULL)
 119                         {
 120                                 drv=_drivers[n];
 121                                 break;
 122                         }
 123                 }
 124         }
 125         else
 126         {
 127                 for(n=0;;n++)
 128                 {
 129                         if(_drivers[n]->name == NULL)
 130                                 return(-2);
 131
 132                         if(strcmp(name, _drivers[n]->name) == 0)
 133                         {
 134                                 drv=_drivers[n];
 135                                 break;
 136                         }
 137                 }
 138         }
 139
 140         if(drv == NULL)
 141                 return(-2);
 142
 143         /* if filename is NULL, take the default one */
 144         if(filename == NULL)
 145                 filename=drv->default_file;
 146
 147         /* the output driver must acknowledge the requested
 148            number of channels or return the maximum supported */
 149         _n_channels = drv->open(filename);
 150
 151         /* unassign driver if opening fails */
 152         if(_n_channels <= 0)
 153                 drv=NULL;
 154
 155         /* reset accounting */
 156         _output_frames=_output_clipped=0;
 157         _output_lowest=_output_highest=0.0;
 158
 159         return(_n_channels);
 160 }
 161
 162
 163 void output_init_frame(float samples[])
 164 {
 165         int n;
 166
 167         for(n=0;n < CHANNELS;n++)
 168                 samples[n] = 0.0;
 169 }
 170
 171
 172 /**
 173  * output_write - Outputs a frame of samples.
 174  * @samples: the frame of samples
 175  *
 176  * Outputs a frame of samples. The output samples are
 177  * intermixed if needed, have the master volume applied and trimmed
 178  * before being sent to the output driver itself.
 179  *
 180  * If the maximum number of channels the output driver supports
 181  * is lower than the global _n_channels, they are sequentially intermixed
 182  * (for example, when outputting 4 channel data to a stereo device,
 183  * 0 and 2 channels will go to left and 1 and 3 to right).
 184  *
 185  * Returns a negative value in case of error, or 0 otherwise.
 186  */
 187 int output_write(float samples[])
 188 {
 189         int n,clip;
 190         float s[CHANNELS];
 191
 192         /* clean samples first */
 193         for(n=0;n < _n_channels;n++)
 194                 s[n]=0.0;
 195
 196         /* move samples, 'down-channeling' if needed */
 197         for(n=0;n < CHANNELS;n++)
 198                 s[n % _n_channels] += samples[n];
 199
 200         /* final corrections */
 201         for(n=clip=0;n < _n_channels;n++)
 202         {
 203                 /* store the lowest and highest
 204                    amplitude seen before master volume */
 205                 if(s[n] < _output_lowest)
 206                         _output_lowest=s[n];
 207
 208                 if(s[n] > _output_highest)
 209                         _output_highest=s[n];
 210
 211                 /* apply master volume */
 212                 s[n] *= _master_volume;
 213
 214                 /* clip samples to signed 16 bit boundaries */
 215                 if(s[n] < -32768)
 216                 {
 217                         s[n]=-32768;
 218                         clip++;
 219                 }
 220
 221                 if(s[n] > 32767)
 222                 {
 223                         s[n]=32767;
 224                         clip++;
 225                 }
 226         }
 227
 228         /* update accounting */
 229         _output_frames++;
 230
 231         if(clip)
 232                 _output_clipped++;
 233
 234         return(drv->write(s));
 235 }
 236
 237
 238 /**
 239  * output_close - Closes the output device.
 240  *
 241  * Closes the output driver.
 242  */
 243 int output_close(void)
 244 {
 245         int r;
 246
 247         r=drv->close();
 248         drv=NULL;
 249
 250         /* calculate optimal master volume for
 251            zero saturation */
 252         _output_lowest=fabs(_output_lowest);
 253
 254         _optimal_volume = _output_lowest > _output_highest ?
 255                 32768.0 / _output_lowest :
 256                 32767.0 / _output_highest;
 257
 258         return(r);
 259 }