PDL-Audio/sndlib/sound.c

/* sound.c */

/* TODO: make this thread-safe by wrapping locks around the header/data base references */

#if defined(HAVE_CONFIG_H)
  #include "config.h"
#endif

#include <math.h>
#include <stdio.h>
#if (!defined(HAVE_CONFIG_H)) || (defined(HAVE_FCNTL_H))
  #include <fcntl.h>
#endif
#include <signal.h>
#if (!defined(HAVE_CONFIG_H)) || (defined(HAVE_LIMITS_H))
  #include <limits.h>
#endif
#include <errno.h>
#include <stdlib.h>

#if (defined(NEXT) || (defined(HAVE_LIBC_H) && (!defined(HAVE_UNISTD_H))))
  #include <libc.h>
#else
  #if (!(defined(_MSC_VER))) && (!(defined(MPW_C)))
    #include <unistd.h>
  #endif
  #if (!defined(HAVE_CONFIG_H)) || (defined(HAVE_STRING_H))
    #include <string.h>
  #endif
#endif

#include <ctype.h>
#include <stddef.h>

#include "sndlib.h"

#if MACOS
  #if (!defined(MPW_C))
    #include <time.h>
    #include <stat.h>
  #endif
#else
  #include <sys/types.h>
  #include <sys/stat.h>
#endif

#include <stdarg.h>

static int mus_error_tag = MUS_INITIAL_ERROR_TAG;
int mus_make_error_tag(void) {return(mus_error_tag++);}
static void (*mus_error_handler)(int err_type, char *err_msg);
void mus_set_error_handler(void (*new_error_handler)(int err_type, char *err_msg)) {mus_error_handler = new_error_handler;}
static char *mus_error_buffer = NULL;

void mus_error(int error, char *format, ...)
{
  va_list ap;
  va_start(ap,format);
  vsprintf(mus_error_buffer,format,ap);
  va_end(ap);
  if (mus_error_handler)
    (*mus_error_handler)(error,mus_error_buffer);
  else fprintf(stderr,mus_error_buffer);
}

void mus_fwrite(int fd, char *format, ...)
{
  va_list ap;
  va_start(ap,format);
  vsprintf(mus_error_buffer,format,ap);
  va_end(ap);
  write(fd,mus_error_buffer,strlen(mus_error_buffer));
}

static char *s_copy_string (char *str)
{
  char *newstr = NULL;
  if ((str) && (*str))
    {
      newstr = (char *)CALLOC(strlen(str)+1,sizeof(char));
      strcpy(newstr,str);
    }
  return(newstr);
}
      
          
#ifndef MPW_C
static time_t file_write_date(char *filename)
{
  struct stat statbuf;
  int err;
  err = stat(filename,&statbuf);
  if (err < 0) return(err);
  return((time_t)(statbuf.st_mtime));
}
#else
#include <Files.h>
static int file_write_date(char *filename)
{
#if 0
  /* this isn't right... */
  HParamBlockRec pb;
  FSSpec fs;
  FSMakeFSSpec(0,0,(unsigned char *)filename,&fs);
  pb.fileParam.ioVRefNum = fs.vRefNum;
  pb.fileParam.ioDirID = fs.parID;
  pb.fileParam.ioNamePtr = fs.name;
  PBHGetFInfo(&pb,FALSE);
mus_error(0,"%s date: %d ",filename,pb.fileParam.ioFlMdDat);
  return(pb.fileParam.ioFlMdDat);
#else
  return(1);
#endif
}
#endif

static int sndlib_initialized = 0;

int initialize_sndlib(void)
{
  int err = 0;
  if (!sndlib_initialized)
    {
      sndlib_initialized = 1;
      mus_error_buffer = (char *)CALLOC(256,sizeof(char));
      if (mus_error_buffer == NULL) return(-1);
      err = mus_create_header_buffer();
      if (err == 0)
        {
          err = mus_create_descriptors();
          if (err == 0) err = initialize_audio();
        }
      if (err == -1) {FREE(mus_error_buffer); return(-1);}
    }
  return(0);
}

typedef struct {
  char *file_name;  /* full path -- everything is keyed to this name */
  int table_pos;
  int *aux_comment_start,*aux_comment_end;
  int *loop_modes,*loop_starts,*loop_ends;
  int markers;
  int *marker_ids,*marker_positions;
  int samples, datum_size, data_location, srate, chans, header_type, data_format, original_sound_format, true_file_length;
  int comment_start, comment_end, header_distributed, type_specifier, bits_per_sample, fact_samples, block_align;
  int write_date;
  int *max_amps;
} sound_file;

static int sound_table_size = 0;
static sound_file **sound_table = NULL;

static void free_sound_file(sound_file *sf)
{
  if (sf)
    {
      sound_table[sf->table_pos] = NULL;
      if (sf->aux_comment_start) FREE(sf->aux_comment_start);
      if (sf->aux_comment_end) FREE(sf->aux_comment_end);
      if (sf->file_name) FREE(sf->file_name);
      if (sf->loop_modes) FREE(sf->loop_modes);
      if (sf->loop_starts) FREE(sf->loop_starts);
      if (sf->loop_ends) FREE(sf->loop_ends);
      if (sf->marker_ids) FREE(sf->marker_ids);
      if (sf->marker_positions) FREE(sf->marker_positions);
      if (sf->max_amps) FREE(sf->max_amps);
      FREE(sf);
    }
}

static sound_file *add_to_sound_table(void)
{
  int i,pos;
#ifdef MACOS
  sound_file **ptr;
#endif
  pos = -1;
  for (i=0;i<sound_table_size;i++)
    if (sound_table[i] == NULL) 
      {
        pos = i;
        break;
      }
  if (pos == -1)
    {
      pos = sound_table_size;
      sound_table_size += 16;
      if (sound_table == NULL)
        sound_table = (sound_file **)CALLOC(sound_table_size,sizeof(sound_file *));
      else 
        {
#ifdef MACOS
          ptr = (sound_file **)CALLOC(sound_table_size,sizeof(sound_file *));
          for (i=0;i<pos;i++) ptr[i] = sound_table[i];
          FREE(sound_table);
          sound_table = ptr;
#else
          sound_table = (sound_file **)REALLOC(sound_table,sound_table_size * sizeof(sound_file *));
#endif
          for (i=pos;i<sound_table_size;i++) sound_table[i] = NULL;
        }
    }
  sound_table[pos] = (sound_file *)CALLOC(1,sizeof(sound_file));
  sound_table[pos]->table_pos = pos;
  return(sound_table[pos]);
}

static void re_read_raw_header(sound_file *sf)
{
  int chan,data_size;
  chan = mus_open_read(sf->file_name);
  data_size = lseek(chan,0L,SEEK_END);
  sf->true_file_length = data_size;
  sf->samples = mus_bytes2samples(sf->data_format,data_size);
  close(chan);  
}

int forget_sound(char *name)
{
  int i;
  for (i=0;i<sound_table_size;i++)
    {
      if (sound_table[i])
        {
          if (strcmp(name,sound_table[i]->file_name) == 0)
            {
              free_sound_file(sound_table[i]);
              return(0);
            }
        }
    }
  return(-1);
}

static sound_file *find_sound_file(char *name)
{
  int i,date;
  sound_file *sf;
  for (i=0;i<sound_table_size;i++)
    {
      if (sound_table[i])
        {
          if (strcmp(name,sound_table[i]->file_name) == 0)
            {
              sf = sound_table[i];
              date = file_write_date(name);
              if (date == sf->write_date)
                return(sf);
              else 
                {
                  if (sf->header_type == raw_sound_file)
                    {
                      /* sound has changed since we last read it, but it has no header, so
                       * the only sensible thing to check is the new length (i.e. caller
                       * has set other fields by hand)
                       */
                      sf->write_date = date;
                      re_read_raw_header(sf);
                      return(sf);
                    }
                  free_sound_file(sf);
                  return(NULL);
                }
            }
        }
    }
  return(NULL);
}

static void fill_sf_record(sound_file *sf)
{
  sf->data_location = mus_header_data_location();
  sf->samples = mus_header_samples();
  sf->data_format = mus_header_format();
  sf->srate = mus_header_srate();
  sf->chans = mus_header_chans();
  sf->datum_size = mus_header_format2bytes();
  sf->header_type = mus_header_type();
  sf->original_sound_format = mus_header_original_format();
  sf->true_file_length = mus_true_file_length();
  sf->comment_start = mus_header_comment_start();
  sf->comment_end = mus_header_comment_end();
  sf->header_distributed = mus_header_distributed();
  sf->type_specifier = mus_header_type_specifier();
  sf->bits_per_sample = mus_header_bits_per_sample();
  sf->fact_samples = mus_header_fact_samples();
  sf->block_align = mus_header_block_align();
  sf->write_date = file_write_date(sf->file_name);
  /* loop points and aux comments */
}

static sound_file *read_sound_file_header_with_fd(int fd, char *arg)
{
  int err=0;
  sound_file *sf = NULL;
  initialize_sndlib();
  err = mus_read_header_with_fd(fd);
  if (err == -1) return(NULL);
  sf = add_to_sound_table();
  sf->file_name = s_copy_string(arg);
  fill_sf_record(sf);
  return(sf);
}

static sound_file *read_sound_file_header_with_name(char *name)
{
  sound_file *sf = NULL;
  initialize_sndlib();
  if (mus_read_header(name) != -1)
    {
      sf = add_to_sound_table();
      sf->file_name = s_copy_string(name);
      fill_sf_record(sf);
    }
  return(sf);
}

static sound_file *getsf(char *arg) 
{
  sound_file *sf = NULL;
  if ((sf = find_sound_file(arg)) == NULL)
    {
      sf = read_sound_file_header_with_name(arg);
      if (sf == NULL) set_audio_error(SNDLIB_CANT_OPEN);
    }
  return(sf);
}

int sound_samples (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->samples); else return(-1);}
int sound_frames (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->samples / sf->chans); else return(-1);}
int sound_datum_size (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->datum_size); else return(-1);}
int sound_data_location (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->data_location); else return(-1);}
int sound_chans (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->chans); else return(-1);}
int sound_srate (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->srate); else return(-1);}
int sound_header_type (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->header_type); else return(-1);}
int sound_data_format (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->data_format); else return(-1);}
int sound_original_format (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->original_sound_format); else return(-1);}
int sound_comment_start (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->comment_start); else return(-1);}
int sound_comment_end (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->comment_end); else return(-1);}
int sound_length (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->true_file_length); else return(-1);}
int sound_fact_samples (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->fact_samples); else return(-1);}
int sound_distributed (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->header_distributed); else return(-1);}
int sound_write_date (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->write_date); else return(-1);}
int sound_type_specifier (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->type_specifier); else return(-1);}
int sound_align (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->block_align); else return(-1);}
int sound_bits_per_sample (char *arg) {sound_file *sf; sf = getsf(arg); if (sf) return(sf->bits_per_sample); else return(-1);}
float sound_duration(char *arg) {return((float)sound_frames(arg) / (float)sound_srate(arg));}

int sound_aiff_p(char *arg) 
{
  return(sound_header_type(arg) == AIFF_sound_file);
}

char *sound_comment(char *name)
{
  int start,end,fd,len;
  char *sc = NULL;
  start = sound_comment_start(name);
  end = sound_comment_end(name);
  if (end == 0) return(NULL);
  len = end-start+1;
  if (len>0)
    {
      /* open and get the comment */
      sc = (char *)CALLOC(len+1,sizeof(char)); /* len+1 calloc'd => we'll always have a trailing null */
#if MACOS
      fd = open(name,O_RDONLY);
#else
  #ifdef WINDOZE
      fd = open(name,O_RDONLY | O_BINARY);
  #else
      fd = open(name,O_RDONLY,0);
  #endif
#endif
      lseek(fd,start,SEEK_SET);
      read(fd,sc,len);
      close(fd);
      return(sc);
    }
  else return(NULL);
}

char *sound_type_name(int type)
{
  return(mus_header_type2string(type));
}

char *sound_format_name(int format)
{
  return(mus_header_data_format2string(format));
}

int sound_bytes_per_sample(int format) {return(mus_format2bytes(format));}

typedef struct {
  int fd;
  char *name;
} output_info;

static output_info **header_names = NULL;
static int header_names_size = 0;

static void save_header_name(int fd, char *arg)
{
  int i,loc;
#ifdef MACOS
  output_info **ptr;
#endif
  loc = -1;
  for (i=0;i<header_names_size;i++)
    {
      if (header_names[i] == NULL)
        {
          loc = i;
          break;
        }
    }
  if (loc == -1)
    {
      loc = header_names_size;
      header_names_size += 4;
      if (header_names == NULL)
        header_names = (output_info **)CALLOC(header_names_size,sizeof(output_info *));
      else 
        {
#ifdef MACOS
          ptr = (output_info **)CALLOC(header_names_size,sizeof(output_info *));
          for (i=0;i<loc;i++) ptr[i] = header_names[i];
          FREE(header_names);
          header_names = ptr;
#else
          header_names = (output_info **)REALLOC(header_names,header_names_size * sizeof(output_info *));
#endif
          for (i=loc;i<header_names_size;i++) header_names[i] = NULL;
        }
    }
  header_names[loc] = (output_info *)CALLOC(1,sizeof(output_info));
  header_names[loc]->fd = fd;
  header_names[loc]->name = s_copy_string(arg);
}

static void flush_header(int fd)
{
  int i,loc,val;
  sound_file *sf;
  loc = -1;
  val = -1;
  for (i=0;i<header_names_size;i++)
    {
      if (header_names[i])
        {
          if (header_names[i]->fd == fd)
            {
              loc = i;
              break;
            }
        }
    }
  if (loc != -1)
    {
      if (header_names[loc]->name)
        { 
          sf = getsf(header_names[loc]->name);
          if (sf) sf->write_date = 0; /* force subsequent re-read */
          FREE(header_names[loc]->name);
          header_names[loc]->name = NULL;
        }   
      FREE(header_names[loc]);
      header_names[loc] = NULL;
    }
}

int open_sound_input (char *arg) 
{
  int fd;
  sound_file *sf = NULL;
  set_audio_error(SNDLIB_NO_ERROR);
  initialize_sndlib();
  fd = mus_open_read(arg);
  if (fd != -1)
    {
      if ((sf = find_sound_file(arg)) == NULL)
        {
          sf = read_sound_file_header_with_fd(fd,arg);
        }
    }
  if (sf) 
    {
      mus_set_file_descriptors(fd,sf->data_format,sf->datum_size,sf->data_location,sf->chans,sf->header_type);
      mus_seek(fd,sf->data_location,SEEK_SET);
    }
  else set_audio_error(SNDLIB_CANT_OPEN); 
  return(fd);
}

int open_sound_output (char *arg, int srate, int chans, int data_format, int header_type, char *comment)
{
  int fd = 0,err,comlen = 0;
  if (comment) comlen = strlen(comment);
  set_audio_error(SNDLIB_NO_ERROR);
  initialize_sndlib();
  err = mus_write_header(arg,header_type,srate,chans,0,0,data_format,comment,comlen);
  if (err != -1)
    {
      fd = mus_open_write(arg);
      mus_set_file_descriptors(fd,data_format,mus_format2bytes(data_format),mus_header_data_location(),chans,header_type);
      save_header_name(fd,arg);
    }
  else set_audio_error(SNDLIB_CANT_OPEN); 
  return(fd);
}

int reopen_sound_output(char *arg, int chans, int format, int type, int data_loc)
{
  int fd;
  set_audio_error(SNDLIB_NO_ERROR);
  initialize_sndlib();
  fd = mus_reopen_write(arg);
  mus_set_file_descriptors(fd,format,mus_format2bytes(format),data_loc,chans,type);
  save_header_name(fd,arg);
  return(fd);
}

int close_sound_input (int fd) 
{
  return(mus_close(fd)); /* this closes the clm file descriptors */
}

int close_sound_output (int fd, int bytes_of_data) 
{
  flush_header(fd);
  mus_update_header_with_fd(fd,mus_get_header_type(fd),bytes_of_data);
  return(mus_close(fd));
}

int read_sound (int fd, int beg, int end, int chans, int **bufs) 
{
  return(mus_read(fd,beg,end,chans,bufs));
}

int write_sound (int tfd, int beg, int end, int chans, int **bufs) 
{
  return(mus_write(tfd,beg,end,chans,bufs));
}

int seek_sound (int tfd, long offset, int origin) 
{
  return(mus_seek(tfd,offset,origin));
}

int seek_sound_frame(int tfd, int frame)
{
  return(mus_seek_frame(tfd,frame));
}

int override_sound_header(char *arg, int srate, int chans, int format, int type, int location, int size)
{
  sound_file *sf; 
  /* perhaps once a header has been over-ridden, we should not reset the relevant fields upon re-read? */
  sf = getsf(arg); 
  if (sf)
    {
      if (location != -1) sf->data_location = location;
      if (size != -1) sf->samples = size;
      if (format != -1) 
        {
          sf->data_format = format;
          sf->datum_size = mus_format2bytes(format);
        }
      if (srate != -1) sf->srate = srate;
      if (chans != -1) sf->chans = chans;
      if (type != -1) sf->header_type = type;
      return(0);
    }
  else return(-1);
}

int sound_max_amp(char *ifile, int *vals)
{
  int ifd,ichans,bufnum,n,curframes,i,frames,chn,fc;
  int *buffer,*time,*samp;
  int **ibufs;
  sound_file *sf; 
  sf = getsf(ifile); 
  if ((sf) && (sf->max_amps))
    {
      for (chn=0;chn<sf->chans;chn++)
        {
          vals[chn*2] = sf->max_amps[chn*2];
          vals[chn*2+1] = sf->max_amps[chn*2+1];
        }
      return(sf->samples / sf->chans);
    }
  ifd = open_sound_input(ifile);
  sf = getsf(ifile);
  if (ifd == -1) return(-1);
  ichans = sound_chans(ifile);
  frames = sound_frames(ifile);
  if (frames <= 0) {close_sound_input(ifd); return(0);}
  seek_sound_frame(ifd,0);
  ibufs = (int **)CALLOC(ichans,sizeof(int *));
  bufnum = 8192;
  for (i=0;i<ichans;i++) ibufs[i] = (int *)CALLOC(bufnum,sizeof(int));
  time = (int *)CALLOC(ichans,sizeof(int));
  samp = (int *)CALLOC(ichans,sizeof(int));
  for (n=0;n<frames;n+=bufnum)
    {
      if ((n+bufnum)<frames) curframes = bufnum; else curframes = (frames-n);
      read_sound(ifd,0,curframes-1,ichans,ibufs);
      for (chn=0;chn<ichans;chn++)
        {
          buffer = (int *)(ibufs[chn]);
          fc=samp[chn];
          for (i=0;i<curframes;i++) 
            {
              if ((buffer[i]>fc) || (fc < -buffer[i])) 
                {
                  time[chn]=i+n; 
                  samp[chn]=buffer[i]; 
                  if (samp[chn]<0) samp[chn] = -samp[chn];
                  fc = samp[chn];
                }
            }
        }
    }
  close_sound_input(ifd);
  if (sf->max_amps == NULL) sf->max_amps = (int *)CALLOC(ichans*2,sizeof(int));
  for (chn=0,i=0;chn<ichans;chn++,i+=2)
    {
      vals[i]=samp[chn];
      vals[i+1]=time[chn];
      sf->max_amps[i] = vals[i];
      sf->max_amps[i+1] = vals[i+1];
    }
  FREE(time);
  FREE(samp);
  for (i=0;i<ichans;i++) FREE(ibufs[i]);
  FREE(ibufs);
  return(frames);
}


int mus_file2array(char *filename, int chan, int start, int samples, int *array)
{
  int ifd,chans,total_read;
  int **bufs;
  ifd = open_sound_input(filename);
  if (ifd == -1) return(-1);
  chans = sound_chans(filename);
  bufs = (int **)CALLOC(chans,sizeof(int *));
  bufs[chan] = array;
  seek_sound_frame(ifd,start);
  total_read = mus_read_any(ifd,0,chans,samples,bufs,(int *)bufs);
  close_sound_input(ifd);
  FREE(bufs);
  return(total_read);
}

int mus_array2file(char *filename, int *ddata, int len, int srate, int channels)
{
  /* put ddata into a sound file, taking byte order into account */
  /* assume ddata is interleaved already if more than one channel */
  int fd;
#ifdef SNDLIB_LITTLE_ENDIAN
  int i;
  unsigned char *o;
  unsigned char tmp;
#endif
  fd = mus_create(filename);
  if (fd == -1) return(-1);
  mus_write_next_header(fd,srate,channels,28,len*4,SNDLIB_32_LINEAR,NULL,0);
#ifdef SNDLIB_LITTLE_ENDIAN
  o = (unsigned char *)ddata;
  for (i=0;i<len;i++,o+=4)
    {
      tmp = o[0]; o[0]=o[3]; o[3]=tmp; tmp=o[1]; o[1]=o[2]; o[2]=tmp;
    }
#endif
#ifndef MACOS
  write(fd,(unsigned char *)ddata,len*4);
#else
  write(fd,(char *)ddata,len*4);
#endif
  close(fd);
  return(0);
}

Revision:	1.1
Committed:	Tue Dec 28 01:05:17 2004 UTC (19 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1_1, rel-1_2, HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/* sound.c */
2
3			/* TODO: make this thread-safe by wrapping locks around the header/data base references */
4
5			#if defined(HAVE_CONFIG_H)
6			#include "config.h"
7			#endif
8
9			#include <math.h>
10			#include <stdio.h>
11			#if (!defined(HAVE_CONFIG_H)) \|\| (defined(HAVE_FCNTL_H))
12			#include <fcntl.h>
13			#endif
14			#include <signal.h>
15			#if (!defined(HAVE_CONFIG_H)) \|\| (defined(HAVE_LIMITS_H))
16			#include <limits.h>
17			#endif
18			#include <errno.h>
19			#include <stdlib.h>
20
21			#if (defined(NEXT) \|\| (defined(HAVE_LIBC_H) && (!defined(HAVE_UNISTD_H))))
22			#include <libc.h>
23			#else
24			#if (!(defined(_MSC_VER))) && (!(defined(MPW_C)))
25			#include <unistd.h>
26			#endif
27			#if (!defined(HAVE_CONFIG_H)) \|\| (defined(HAVE_STRING_H))
28			#include <string.h>
29			#endif
30			#endif
31
32			#include <ctype.h>
33			#include <stddef.h>
34
35			#include "sndlib.h"
36
37			#if MACOS
38			#if (!defined(MPW_C))
39			#include <time.h>
40			#include <stat.h>
41			#endif
42			#else
43			#include <sys/types.h>
44			#include <sys/stat.h>
45			#endif
46
47			#include <stdarg.h>
48
49			static int mus_error_tag = MUS_INITIAL_ERROR_TAG;
50			int mus_make_error_tag(void) {return(mus_error_tag++);}
51			static void (mus_error_handler)(int err_type, char err_msg);
52			void mus_set_error_handler(void (new_error_handler)(int err_type, char err_msg)) {mus_error_handler = new_error_handler;}
53			static char *mus_error_buffer = NULL;
54
55			void mus_error(int error, char *format, ...)
56			{
57			va_list ap;
58			va_start(ap,format);
59			vsprintf(mus_error_buffer,format,ap);
60			va_end(ap);
61			if (mus_error_handler)
62			(*mus_error_handler)(error,mus_error_buffer);
63			else fprintf(stderr,mus_error_buffer);
64			}
65
66			void mus_fwrite(int fd, char *format, ...)
67			{
68			va_list ap;
69			va_start(ap,format);
70			vsprintf(mus_error_buffer,format,ap);
71			va_end(ap);
72			write(fd,mus_error_buffer,strlen(mus_error_buffer));
73			}
74
75			static char s_copy_string (char str)
76			{
77			char *newstr = NULL;
78			if ((str) && (*str))
79			{
80			newstr = (char *)CALLOC(strlen(str)+1,sizeof(char));
81			strcpy(newstr,str);
82			}
83			return(newstr);
84			}
85
86
87			#ifndef MPW_C
88			static time_t file_write_date(char *filename)
89			{
90			struct stat statbuf;
91			int err;
92			err = stat(filename,&statbuf);
93			if (err < 0) return(err);
94			return((time_t)(statbuf.st_mtime));
95			}
96			#else
97			#include <Files.h>
98			static int file_write_date(char *filename)
99			{
100			#if 0
101			/* this isn't right... */
102			HParamBlockRec pb;
103			FSSpec fs;
104			FSMakeFSSpec(0,0,(unsigned char *)filename,&fs);
105			pb.fileParam.ioVRefNum = fs.vRefNum;
106			pb.fileParam.ioDirID = fs.parID;
107			pb.fileParam.ioNamePtr = fs.name;
108			PBHGetFInfo(&pb,FALSE);
109			mus_error(0,"%s date: %d ",filename,pb.fileParam.ioFlMdDat);
110			return(pb.fileParam.ioFlMdDat);
111			#else
112			return(1);
113			#endif
114			}
115			#endif
116
117			static int sndlib_initialized = 0;
118
119			int initialize_sndlib(void)
120			{
121			int err = 0;
122			if (!sndlib_initialized)
123			{
124			sndlib_initialized = 1;
125			mus_error_buffer = (char *)CALLOC(256,sizeof(char));
126			if (mus_error_buffer == NULL) return(-1);
127			err = mus_create_header_buffer();
128			if (err == 0)
129			{
130			err = mus_create_descriptors();
131			if (err == 0) err = initialize_audio();
132			}
133			if (err == -1) {FREE(mus_error_buffer); return(-1);}
134			}
135			return(0);
136			}
137
138			typedef struct {
139			char file_name; / full path -- everything is keyed to this name */
140			int table_pos;
141			int aux_comment_start,aux_comment_end;
142			int loop_modes,loop_starts,*loop_ends;
143			int markers;
144			int marker_ids,marker_positions;
145			int samples, datum_size, data_location, srate, chans, header_type, data_format, original_sound_format, true_file_length;
146			int comment_start, comment_end, header_distributed, type_specifier, bits_per_sample, fact_samples, block_align;
147			int write_date;
148			int *max_amps;
149			} sound_file;
150
151			static int sound_table_size = 0;
152			static sound_file **sound_table = NULL;
153
154			static void free_sound_file(sound_file *sf)
155			{
156			if (sf)
157			{
158			sound_table[sf->table_pos] = NULL;
159			if (sf->aux_comment_start) FREE(sf->aux_comment_start);
160			if (sf->aux_comment_end) FREE(sf->aux_comment_end);
161			if (sf->file_name) FREE(sf->file_name);
162			if (sf->loop_modes) FREE(sf->loop_modes);
163			if (sf->loop_starts) FREE(sf->loop_starts);
164			if (sf->loop_ends) FREE(sf->loop_ends);
165			if (sf->marker_ids) FREE(sf->marker_ids);
166			if (sf->marker_positions) FREE(sf->marker_positions);
167			if (sf->max_amps) FREE(sf->max_amps);
168			FREE(sf);
169			}
170			}
171
172			static sound_file *add_to_sound_table(void)
173			{
174			int i,pos;
175			#ifdef MACOS
176			sound_file **ptr;
177			#endif
178			pos = -1;
179			for (i=0;i<sound_table_size;i++)
180			if (sound_table[i] == NULL)
181			{
182			pos = i;
183			break;
184			}
185			if (pos == -1)
186			{
187			pos = sound_table_size;
188			sound_table_size += 16;
189			if (sound_table == NULL)
190			sound_table = (sound_file *)CALLOC(sound_table_size,sizeof(sound_file ));
191			else
192			{
193			#ifdef MACOS
194			ptr = (sound_file *)CALLOC(sound_table_size,sizeof(sound_file ));
195			for (i=0;i<pos;i++) ptr[i] = sound_table[i];
196			FREE(sound_table);
197			sound_table = ptr;
198			#else
199			sound_table = (sound_file *)REALLOC(sound_table,sound_table_size sizeof(sound_file *));
200			#endif
201			for (i=pos;i<sound_table_size;i++) sound_table[i] = NULL;
202			}
203			}
204			sound_table[pos] = (sound_file *)CALLOC(1,sizeof(sound_file));
205			sound_table[pos]->table_pos = pos;
206			return(sound_table[pos]);
207			}
208
209			static void re_read_raw_header(sound_file *sf)
210			{
211			int chan,data_size;
212			chan = mus_open_read(sf->file_name);
213			data_size = lseek(chan,0L,SEEK_END);
214			sf->true_file_length = data_size;
215			sf->samples = mus_bytes2samples(sf->data_format,data_size);
216			close(chan);
217			}
218
219			int forget_sound(char *name)
220			{
221			int i;
222			for (i=0;i<sound_table_size;i++)
223			{
224			if (sound_table[i])
225			{
226			if (strcmp(name,sound_table[i]->file_name) == 0)
227			{
228			free_sound_file(sound_table[i]);
229			return(0);
230			}
231			}
232			}
233			return(-1);
234			}
235
236			static sound_file find_sound_file(char name)
237			{
238			int i,date;
239			sound_file *sf;
240			for (i=0;i<sound_table_size;i++)
241			{
242			if (sound_table[i])
243			{
244			if (strcmp(name,sound_table[i]->file_name) == 0)
245			{
246			sf = sound_table[i];
247			date = file_write_date(name);
248			if (date == sf->write_date)
249			return(sf);
250			else
251			{
252			if (sf->header_type == raw_sound_file)
253			{
254			/* sound has changed since we last read it, but it has no header, so
255			* the only sensible thing to check is the new length (i.e. caller
256			* has set other fields by hand)
257			*/
258			sf->write_date = date;
259			re_read_raw_header(sf);
260			return(sf);
261			}
262			free_sound_file(sf);
263			return(NULL);
264			}
265			}
266			}
267			}
268			return(NULL);
269			}
270
271			static void fill_sf_record(sound_file *sf)
272			{
273			sf->data_location = mus_header_data_location();
274			sf->samples = mus_header_samples();
275			sf->data_format = mus_header_format();
276			sf->srate = mus_header_srate();
277			sf->chans = mus_header_chans();
278			sf->datum_size = mus_header_format2bytes();
279			sf->header_type = mus_header_type();
280			sf->original_sound_format = mus_header_original_format();
281			sf->true_file_length = mus_true_file_length();
282			sf->comment_start = mus_header_comment_start();
283			sf->comment_end = mus_header_comment_end();
284			sf->header_distributed = mus_header_distributed();
285			sf->type_specifier = mus_header_type_specifier();
286			sf->bits_per_sample = mus_header_bits_per_sample();
287			sf->fact_samples = mus_header_fact_samples();
288			sf->block_align = mus_header_block_align();
289			sf->write_date = file_write_date(sf->file_name);
290			/* loop points and aux comments */
291			}
292
293			static sound_file read_sound_file_header_with_fd(int fd, char arg)
294			{
295			int err=0;
296			sound_file *sf = NULL;
297			initialize_sndlib();
298			err = mus_read_header_with_fd(fd);
299			if (err == -1) return(NULL);
300			sf = add_to_sound_table();
301			sf->file_name = s_copy_string(arg);
302			fill_sf_record(sf);
303			return(sf);
304			}
305
306			static sound_file read_sound_file_header_with_name(char name)
307			{
308			sound_file *sf = NULL;
309			initialize_sndlib();
310			if (mus_read_header(name) != -1)
311			{
312			sf = add_to_sound_table();
313			sf->file_name = s_copy_string(name);
314			fill_sf_record(sf);
315			}
316			return(sf);
317			}
318
319			static sound_file getsf(char arg)
320			{
321			sound_file *sf = NULL;
322			if ((sf = find_sound_file(arg)) == NULL)
323			{
324			sf = read_sound_file_header_with_name(arg);
325			if (sf == NULL) set_audio_error(SNDLIB_CANT_OPEN);
326			}
327			return(sf);
328			}
329
330			int sound_samples (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->samples); else return(-1);}
331			int sound_frames (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->samples / sf->chans); else return(-1);}
332			int sound_datum_size (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->datum_size); else return(-1);}
333			int sound_data_location (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->data_location); else return(-1);}
334			int sound_chans (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->chans); else return(-1);}
335			int sound_srate (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->srate); else return(-1);}
336			int sound_header_type (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->header_type); else return(-1);}
337			int sound_data_format (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->data_format); else return(-1);}
338			int sound_original_format (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->original_sound_format); else return(-1);}
339			int sound_comment_start (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->comment_start); else return(-1);}
340			int sound_comment_end (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->comment_end); else return(-1);}
341			int sound_length (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->true_file_length); else return(-1);}
342			int sound_fact_samples (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->fact_samples); else return(-1);}
343			int sound_distributed (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->header_distributed); else return(-1);}
344			int sound_write_date (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->write_date); else return(-1);}
345			int sound_type_specifier (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->type_specifier); else return(-1);}
346			int sound_align (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->block_align); else return(-1);}
347			int sound_bits_per_sample (char arg) {sound_file sf; sf = getsf(arg); if (sf) return(sf->bits_per_sample); else return(-1);}
348			float sound_duration(char *arg) {return((float)sound_frames(arg) / (float)sound_srate(arg));}
349
350			int sound_aiff_p(char *arg)
351			{
352			return(sound_header_type(arg) == AIFF_sound_file);
353			}
354
355			char sound_comment(char name)
356			{
357			int start,end,fd,len;
358			char *sc = NULL;
359			start = sound_comment_start(name);
360			end = sound_comment_end(name);
361			if (end == 0) return(NULL);
362			len = end-start+1;
363			if (len>0)
364			{
365			/* open and get the comment */
366			sc = (char )CALLOC(len+1,sizeof(char)); / len+1 calloc'd => we'll always have a trailing null */
367			#if MACOS
368			fd = open(name,O_RDONLY);
369			#else
370			#ifdef WINDOZE
371			fd = open(name,O_RDONLY \| O_BINARY);
372			#else
373			fd = open(name,O_RDONLY,0);
374			#endif
375			#endif
376			lseek(fd,start,SEEK_SET);
377			read(fd,sc,len);
378			close(fd);
379			return(sc);
380			}
381			else return(NULL);
382			}
383
384			char *sound_type_name(int type)
385			{
386			return(mus_header_type2string(type));
387			}
388
389			char *sound_format_name(int format)
390			{
391			return(mus_header_data_format2string(format));
392			}
393
394			int sound_bytes_per_sample(int format) {return(mus_format2bytes(format));}
395
396			typedef struct {
397			int fd;
398			char *name;
399			} output_info;
400
401			static output_info **header_names = NULL;
402			static int header_names_size = 0;
403
404			static void save_header_name(int fd, char *arg)
405			{
406			int i,loc;
407			#ifdef MACOS
408			output_info **ptr;
409			#endif
410			loc = -1;
411			for (i=0;i<header_names_size;i++)
412			{
413			if (header_names[i] == NULL)
414			{
415			loc = i;
416			break;
417			}
418			}
419			if (loc == -1)
420			{
421			loc = header_names_size;
422			header_names_size += 4;
423			if (header_names == NULL)
424			header_names = (output_info *)CALLOC(header_names_size,sizeof(output_info ));
425			else
426			{
427			#ifdef MACOS
428			ptr = (output_info *)CALLOC(header_names_size,sizeof(output_info ));
429			for (i=0;i<loc;i++) ptr[i] = header_names[i];
430			FREE(header_names);
431			header_names = ptr;
432			#else
433			header_names = (output_info *)REALLOC(header_names,header_names_size sizeof(output_info *));
434			#endif
435			for (i=loc;i<header_names_size;i++) header_names[i] = NULL;
436			}
437			}
438			header_names[loc] = (output_info *)CALLOC(1,sizeof(output_info));
439			header_names[loc]->fd = fd;
440			header_names[loc]->name = s_copy_string(arg);
441			}
442
443			static void flush_header(int fd)
444			{
445			int i,loc,val;
446			sound_file *sf;
447			loc = -1;
448			val = -1;
449			for (i=0;i<header_names_size;i++)
450			{
451			if (header_names[i])
452			{
453			if (header_names[i]->fd == fd)
454			{
455			loc = i;
456			break;
457			}
458			}
459			}
460			if (loc != -1)
461			{
462			if (header_names[loc]->name)
463			{
464			sf = getsf(header_names[loc]->name);
465			if (sf) sf->write_date = 0; /* force subsequent re-read */
466			FREE(header_names[loc]->name);
467			header_names[loc]->name = NULL;
468			}
469			FREE(header_names[loc]);
470			header_names[loc] = NULL;
471			}
472			}
473
474			int open_sound_input (char *arg)
475			{
476			int fd;
477			sound_file *sf = NULL;
478			set_audio_error(SNDLIB_NO_ERROR);
479			initialize_sndlib();
480			fd = mus_open_read(arg);
481			if (fd != -1)
482			{
483			if ((sf = find_sound_file(arg)) == NULL)
484			{
485			sf = read_sound_file_header_with_fd(fd,arg);
486			}
487			}
488			if (sf)
489			{
490			mus_set_file_descriptors(fd,sf->data_format,sf->datum_size,sf->data_location,sf->chans,sf->header_type);
491			mus_seek(fd,sf->data_location,SEEK_SET);
492			}
493			else set_audio_error(SNDLIB_CANT_OPEN);
494			return(fd);
495			}
496
497			int open_sound_output (char arg, int srate, int chans, int data_format, int header_type, char comment)
498			{
499			int fd = 0,err,comlen = 0;
500			if (comment) comlen = strlen(comment);
501			set_audio_error(SNDLIB_NO_ERROR);
502			initialize_sndlib();
503			err = mus_write_header(arg,header_type,srate,chans,0,0,data_format,comment,comlen);
504			if (err != -1)
505			{
506			fd = mus_open_write(arg);
507			mus_set_file_descriptors(fd,data_format,mus_format2bytes(data_format),mus_header_data_location(),chans,header_type);
508			save_header_name(fd,arg);
509			}
510			else set_audio_error(SNDLIB_CANT_OPEN);
511			return(fd);
512			}
513
514			int reopen_sound_output(char *arg, int chans, int format, int type, int data_loc)
515			{
516			int fd;
517			set_audio_error(SNDLIB_NO_ERROR);
518			initialize_sndlib();
519			fd = mus_reopen_write(arg);
520			mus_set_file_descriptors(fd,format,mus_format2bytes(format),data_loc,chans,type);
521			save_header_name(fd,arg);
522			return(fd);
523			}
524
525			int close_sound_input (int fd)
526			{
527			return(mus_close(fd)); /* this closes the clm file descriptors */
528			}
529
530			int close_sound_output (int fd, int bytes_of_data)
531			{
532			flush_header(fd);
533			mus_update_header_with_fd(fd,mus_get_header_type(fd),bytes_of_data);
534			return(mus_close(fd));
535			}
536
537			int read_sound (int fd, int beg, int end, int chans, int **bufs)
538			{
539			return(mus_read(fd,beg,end,chans,bufs));
540			}
541
542			int write_sound (int tfd, int beg, int end, int chans, int **bufs)
543			{
544			return(mus_write(tfd,beg,end,chans,bufs));
545			}
546
547			int seek_sound (int tfd, long offset, int origin)
548			{
549			return(mus_seek(tfd,offset,origin));
550			}
551
552			int seek_sound_frame(int tfd, int frame)
553			{
554			return(mus_seek_frame(tfd,frame));
555			}
556
557			int override_sound_header(char *arg, int srate, int chans, int format, int type, int location, int size)
558			{
559			sound_file *sf;
560			/* perhaps once a header has been over-ridden, we should not reset the relevant fields upon re-read? */
561			sf = getsf(arg);
562			if (sf)
563			{
564			if (location != -1) sf->data_location = location;
565			if (size != -1) sf->samples = size;
566			if (format != -1)
567			{
568			sf->data_format = format;
569			sf->datum_size = mus_format2bytes(format);
570			}
571			if (srate != -1) sf->srate = srate;
572			if (chans != -1) sf->chans = chans;
573			if (type != -1) sf->header_type = type;
574			return(0);
575			}
576			else return(-1);
577			}
578
579			int sound_max_amp(char ifile, int vals)
580			{
581			int ifd,ichans,bufnum,n,curframes,i,frames,chn,fc;
582			int buffer,time,*samp;
583			int **ibufs;
584			sound_file *sf;
585			sf = getsf(ifile);
586			if ((sf) && (sf->max_amps))
587			{
588			for (chn=0;chn<sf->chans;chn++)
589			{
590			vals[chn2] = sf->max_amps[chn2];
591			vals[chn2+1] = sf->max_amps[chn2+1];
592			}
593			return(sf->samples / sf->chans);
594			}
595			ifd = open_sound_input(ifile);
596			sf = getsf(ifile);
597			if (ifd == -1) return(-1);
598			ichans = sound_chans(ifile);
599			frames = sound_frames(ifile);
600			if (frames <= 0) {close_sound_input(ifd); return(0);}
601			seek_sound_frame(ifd,0);
602			ibufs = (int *)CALLOC(ichans,sizeof(int ));
603			bufnum = 8192;
604			for (i=0;i<ichans;i++) ibufs[i] = (int *)CALLOC(bufnum,sizeof(int));
605			time = (int *)CALLOC(ichans,sizeof(int));
606			samp = (int *)CALLOC(ichans,sizeof(int));
607			for (n=0;n<frames;n+=bufnum)
608			{
609			if ((n+bufnum)<frames) curframes = bufnum; else curframes = (frames-n);
610			read_sound(ifd,0,curframes-1,ichans,ibufs);
611			for (chn=0;chn<ichans;chn++)
612			{
613			buffer = (int *)(ibufs[chn]);
614			fc=samp[chn];
615			for (i=0;i<curframes;i++)
616			{
617			if ((buffer[i]>fc) \|\| (fc < -buffer[i]))
618			{
619			time[chn]=i+n;
620			samp[chn]=buffer[i];
621			if (samp[chn]<0) samp[chn] = -samp[chn];
622			fc = samp[chn];
623			}
624			}
625			}
626			}
627			close_sound_input(ifd);
628			if (sf->max_amps == NULL) sf->max_amps = (int )CALLOC(ichans2,sizeof(int));
629			for (chn=0,i=0;chn<ichans;chn++,i+=2)
630			{
631			vals[i]=samp[chn];
632			vals[i+1]=time[chn];
633			sf->max_amps[i] = vals[i];
634			sf->max_amps[i+1] = vals[i+1];
635			}
636			FREE(time);
637			FREE(samp);
638			for (i=0;i<ichans;i++) FREE(ibufs[i]);
639			FREE(ibufs);
640			return(frames);
641			}
642
643
644			int mus_file2array(char filename, int chan, int start, int samples, int array)
645			{
646			int ifd,chans,total_read;
647			int **bufs;
648			ifd = open_sound_input(filename);
649			if (ifd == -1) return(-1);
650			chans = sound_chans(filename);
651			bufs = (int *)CALLOC(chans,sizeof(int ));
652			bufs[chan] = array;
653			seek_sound_frame(ifd,start);
654			total_read = mus_read_any(ifd,0,chans,samples,bufs,(int *)bufs);
655			close_sound_input(ifd);
656			FREE(bufs);
657			return(total_read);
658			}
659
660			int mus_array2file(char filename, int ddata, int len, int srate, int channels)
661			{
662			/* put ddata into a sound file, taking byte order into account */
663			/* assume ddata is interleaved already if more than one channel */
664			int fd;
665			#ifdef SNDLIB_LITTLE_ENDIAN
666			int i;
667			unsigned char *o;
668			unsigned char tmp;
669			#endif
670			fd = mus_create(filename);
671			if (fd == -1) return(-1);
672			mus_write_next_header(fd,srate,channels,28,len*4,SNDLIB_32_LINEAR,NULL,0);
673			#ifdef SNDLIB_LITTLE_ENDIAN
674			o = (unsigned char *)ddata;
675			for (i=0;i<len;i++,o+=4)
676			{
677			tmp = o[0]; o[0]=o[3]; o[3]=tmp; tmp=o[1]; o[1]=o[2]; o[2]=tmp;
678			}
679			#endif
680			#ifndef MACOS
681			write(fd,(unsigned char )ddata,len4);
682			#else
683			write(fd,(char )ddata,len4);
684			#endif
685			close(fd);
686			return(0);
687			}
688