ss_output.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2006 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 <signal.h>
  35
  36 #include "annhell.h"
  37
  38 /*******************
  39         Data
  40 ********************/
  41
  42 /* master output volume */
  43 sample_t ss_master_volume = 0.5;
  44
  45 /* output accounting */
  46 int ss_output_clipped = 0;
  47 sample_t ss_output_lowest = 0;
  48 sample_t ss_output_highest = 0;
  49
  50 /* optimal output volume */
  51 sample_t ss_optimal_volume;
  52
  53 /* driver data */
  54 static void * outdev;
  55
  56 /*
  57         usual channel mapping:
  58
  59         mono: all
  60         stereo: left | right
  61         3 channel: left | right | center
  62         quad: front left | front right | rear left | rear right
  63         4 channel: left | center | right | surround
  64         6 channel: left center | left | center | right center | right | surround
  65 */
  66
  67 /* a copy of the output file name */
  68 static char * ss_output_file_name = NULL;
  69
  70 /* cue file name and track */
  71 char * ss_cue_file_name = NULL;
  72 static int ss_cue_file_track = -1;
  73
  74 /*******************
  75         Code
  76 ********************/
  77
  78 void * ss_outdev_open(char * drvname, char * file, int freq, int n_channels);
  79 void ss_outdev_write(void * drv, short int * frame);
  80 void * ss_outdev_close(void * drv);
  81
  82
  83 static void close_on_signal(int sig_num)
  84 /* SIGINT (and other) signal handler */
  85 {
  86         /* close output device */
  87         outdev = ss_outdev_close(outdev);
  88
  89         /* exit */
  90         exit(0);
  91 }
  92
  93
  94 /**
  95  * ss_output_open - Opens an output device.
  96  * @name: name of the driver
  97  * @filename: name of the file or device
  98  *
  99  * Opens an output device. @name contains the name of the driver
 100  * (i.e. "oss" or "wav"), @filename contains the (optional) name
 101  * of the output file or device (i.e. a filename
 102  * "wav" or "/dev/dsp" for a direct audio device like "oss").
 103  * @Name can be the special pseudo-driver "default"
 104  * to select the most appropriate (usually a platform-specific
 105  * direct output device, or "wav" if no one exists).
 106  * @filename can also be NULL; in that case, a driver dependent,
 107  * default value is used.
 108  *
 109  * Returns zero if the output device was correctly open, or
 110  * nonzero otherwise.
 111  */
 112 int ss_output_open(char * drvname, char * filename)
 113 {
 114         if(strcmp(drvname, "default") == 0)
 115                 drvname = NULL;
 116
 117         /* reset accounting */
 118         ss_output_clipped = 0;
 119         ss_output_lowest = ss_output_highest = 0.0;
 120
 121         /* close the device on unexpected signals */
 122         signal(SIGINT, close_on_signal);
 123
 124         /* store a copy of the filename */
 125         ss_output_file_name = filename;
 126
 127         return((outdev = ss_outdev_open(drvname,
 128                 filename, ss_frequency, ss_nchannels)) == NULL);
 129 }
 130
 131
 132 /**
 133  * ss_output_init_frame - Inits a frame
 134  * @frame: the frame
 135  *
 136  * Inits a frame, setting all samples to zero.
 137  */
 138 void ss_output_init_frame(sample_t frame[])
 139 {
 140         int n;
 141
 142         for(n = 0;n < SS_MAX_CHANNELS;n++)
 143                 frame[n] = 0.0;
 144 }
 145
 146
 147 /**
 148  * ss_output_write - Outputs a frame of samples.
 149  * @frame: the frame of samples
 150  *
 151  * Outputs a frame of samples. The output samples are
 152  * intermixed if needed, have the master volume applied and trimmed
 153  * before being sent to the output driver itself.
 154  *
 155  * If the maximum number of channels the output driver supports
 156  * is lower than the global ss_nchannels, they are sequentially intermixed
 157  * (for example, when outputting 4 channel data to a stereo device,
 158  * 0 and 2 channels will go to left and 1 and 3 to right).
 159  *
 160  * Returns a negative value in case of error, or 0 otherwise.
 161  */
 162 int ss_output_write(sample_t frame[])
 163 {
 164         int n, clip, ret = 0;
 165         sample_t s;
 166         short int is[SS_MAX_CHANNELS];
 167
 168         /* final corrections */
 169         for(n = clip = 0;n < ss_nchannels;n++)
 170         {
 171                 s = frame[n];
 172
 173                 /* store the lowest and highest
 174                    amplitude seen before master volume */
 175                 if(s < ss_output_lowest)
 176                         ss_output_lowest = s;
 177
 178                 if(s > ss_output_highest)
 179                         ss_output_highest = s;
 180
 181                 /* apply master volume */
 182                 s *= ss_master_volume;
 183
 184                 /* clip samples to signed 16 bit boundaries */
 185                 if(s < -32768)
 186                 {
 187                         s = -32768;
 188                         clip++;
 189                 }
 190
 191                 if(s > 32767)
 192                 {
 193                         s = 32767;
 194                         clip++;
 195                 }
 196
 197                 /* store in buffer */
 198                 is[n] = (short int) s;
 199         }
 200
 201         if(clip)
 202                 ss_output_clipped++;
 203
 204         /* finally write */
 205         ss_outdev_write(outdev, is);
 206
 207         return(ret);
 208 }
 209
 210
 211 /**
 212  * ss_output_close - Closes the output device.
 213  *
 214  * Closes the output driver.
 215  */
 216 void ss_output_close(void)
 217 {
 218         /* back to default signal behaviour */
 219         signal(SIGINT, SIG_DFL);
 220
 221         /* close the device */
 222         outdev = ss_outdev_close(outdev);
 223
 224         /* calculate optimal master volume for
 225            zero saturation */
 226         ss_output_lowest = fabs(ss_output_lowest);
 227
 228         ss_optimal_volume = ss_output_lowest > ss_output_highest ?
 229                 32768.0 / ss_output_lowest :
 230                 32767.0 / ss_output_highest;
 231 }
 232
 233
 234 static int cue_file_init(void)
 235 /* inits the cue file, writing the first line */
 236 {
 237         FILE * f;
 238
 239         if(ss_output_file_name == NULL ||
 240                 (f = fopen(ss_cue_file_name, "w")) == NULL)
 241                 return(-2);
 242
 243         /* write first line */
 244         fprintf(f, "FILE \"%s\" WAVE\n", ss_output_file_name);
 245         fclose(f);
 246
 247         ss_cue_file_track = 0;
 248
 249         return(0);
 250 }
 251
 252
 253 int cue_file_song_info(int frame, char * author, char * name)
 254 {
 255         int s;
 256         FILE * f;
 257
 258         if(ss_cue_file_name == NULL)
 259                 return(0);
 260
 261         /* init if it's the first time */
 262         if(ss_cue_file_track == -1)
 263         {
 264                 /* can't open? fail */
 265                 if(cue_file_init() < 0)
 266                 {
 267                         ss_cue_file_name = NULL;
 268                         return(-1);
 269                 }
 270         }
 271
 272         /* open or fail */
 273         if((f = fopen(ss_cue_file_name, "a")) == NULL)
 274                 return(-1);
 275
 276         s = frame / ss_frequency;
 277
 278         fprintf(f, "TRACK %02d AUDIO\n", ss_cue_file_track++);
 279         fprintf(f, "  PERFORMER \"%s\"\n",      author);
 280         fprintf(f, "  TITLE \"%s\"\n", name);
 281         fprintf(f, "  INDEX 01 %02d:%02d:00\n", s / 60, s % 60);
 282
 283         fclose(f);
 284         return(0);
 285 }