ss_output.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2005 Angel Ortega <angel@triptico.com>
   5
   6     ss_output.c - Softsynth 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 <stdlib.h>
  30 #include <unistd.h>
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #include "ss_core.h"
  35 #include "ss_output.h"
  36
  37
  38 /*******************
  39         Data
  40 ********************/
  41
  42 /* master output volume */
  43 float ss_master_volume=1.0;
  44
  45 /* output accounting */
  46 int ss_output_frames=0;
  47 int ss_output_clipped=0;
  48 float ss_output_lowest=0;
  49 float ss_output_highest=0;
  50
  51 /* optimal output volume */
  52 float ss_optimal_volume;
  53
  54 /* output filehandle */
  55 static int ss_of;
  56
  57 /*******************
  58         Code
  59 ********************/
  60
  61 int ss_outdev(char * drv, char * file, int freq, int n_channels);
  62
  63 /**
  64  * ss_output_open - Opens an output device.
  65  * @name: name of the driver
  66  * @filename: name of the file or device
  67  *
  68  * Opens an output device. @name contains the name of the driver
  69  * (i.e. "raw" or "wav"), @filename contains the (optional) name
  70  * of the output file or device (i.e. a filename for "raw" or
  71  * "wav" or "/dev/dsp" for a direct audio device like "oss").
  72  * @Name can be the special pseudo-driver "default"
  73  * to select the most appropriate (usually a platform-specific
  74  * direct output device, or "wav" if no one exists).
  75  * @filename can also be NULL; in that case, a driver dependent,
  76  * default value is used.
  77  *
  78  * The _n_channels global variable can be changed on output if
  79  * the driver doesn't support so much channels.
  80  *
  81  * Returns a negative number in case of error, or zero otherwise.
  82  */
  83 int ss_output_open(char * drvname, char * filename)
  84 {
  85         if(strcmp(drvname, "default") == 0)
  86                 drvname=NULL;
  87
  88         /* reset accounting */
  89         ss_output_frames=ss_output_clipped=0;
  90         ss_output_lowest=ss_output_highest=0.0;
  91
  92         ss_of=ss_outdev(drvname, filename, ss_frequency, ss_nchannels);
  93
  94         return(0);
  95 }
  96
  97
  98 void ss_output_init_frame(float samples[])
  99 {
 100         int n;
 101
 102         for(n=0;n < SS_MAX_CHANNELS;n++)
 103                 samples[n] = 0.0;
 104 }
 105
 106
 107 /**
 108  * ss_output_write - Outputs a frame of samples.
 109  * @samples: the frame of samples
 110  *
 111  * Outputs a frame of samples. The output samples are
 112  * intermixed if needed, have the master volume applied and trimmed
 113  * before being sent to the output driver itself.
 114  *
 115  * If the maximum number of channels the output driver supports
 116  * is lower than the global _n_channels, they are sequentially intermixed
 117  * (for example, when outputting 4 channel data to a stereo device,
 118  * 0 and 2 channels will go to left and 1 and 3 to right).
 119  *
 120  * Returns a negative value in case of error, or 0 otherwise.
 121  */
 122 int ss_output_write(float samples[])
 123 {
 124         int n, clip, ret=0;
 125         float s, fs[SS_MAX_CHANNELS];
 126         short int is[SS_MAX_CHANNELS];
 127
 128         /* clean samples first */
 129         for(n=0;n < ss_nchannels;n++)
 130                 fs[n]=0.0;
 131
 132         /* move samples, 'down-channeling' if needed */
 133         for(n=0;n < SS_MAX_CHANNELS;n++)
 134                 fs[n % ss_nchannels] += samples[n];
 135
 136         /* final corrections */
 137         for(n=clip=0;n < ss_nchannels;n++)
 138         {
 139                 s=fs[n];
 140
 141                 /* store the lowest and highest
 142                    amplitude seen before master volume */
 143                 if(s < ss_output_lowest)
 144                         ss_output_lowest=s;
 145
 146                 if(s > ss_output_highest)
 147                         ss_output_highest=s;
 148
 149                 /* apply master volume */
 150                 s *= ss_master_volume;
 151
 152                 /* clip samples to signed 16 bit boundaries */
 153                 if(s < -32768)
 154                 {
 155                         s=-32768;
 156                         clip++;
 157                 }
 158
 159                 if(s > 32767)
 160                 {
 161                         s=32767;
 162                         clip++;
 163                 }
 164
 165                 /* store in buffer */
 166                 is[n]=(short int) s;
 167         }
 168
 169         /* update accounting */
 170         ss_output_frames++;
 171
 172         if(clip)
 173                 ss_output_clipped++;
 174
 175         /* finally write */
 176 /*      write(ss_of, is, ss_nchannels * sizeof(short int));*/
 177         write(ss_of, is, 256);
 178
 179         return(ret);
 180 }
 181
 182
 183 /**
 184  * ss_output_close - Closes the output device.
 185  *
 186  * Closes the output driver.
 187  */
 188 int ss_output_close(void)
 189 {
 190         int r;
 191
 192         close(ss_of);
 193
 194         /* calculate optimal master volume for
 195            zero saturation */
 196         ss_output_lowest=fabs(ss_output_lowest);
 197
 198         ss_optimal_volume = ss_output_lowest > ss_output_highest ?
 199                 32768.0 / ss_output_lowest :
 200                 32767.0 / ss_output_highest;
 201
 202         return(r);
 203 }