AuStream *as;

  if (AUdebugLevel >= 1) {
    printf("AudioOpenWrite: fileName=\"%s\"  format=\"%s\"\n",fileName,format);
    printf("AudioOpenWrite: numChannel=%d  fSample=%.1f\n",
	   numChannel,fSample);
  }

  if (strcmp(fileName,"-")) {
#ifdef USE_AFSP
    fmti = 0;
    while (fmtstr[fmti].str && !isfmtstr(format,fmtstr[fmti].str))
      fmti++;
    if (fmtstr[fmti].str)
      fmt = FD_INT16 + fmtstr[fmti].fmt;
    else {
#else
    fmti = 0;
    while (fmtstr[fmti].str && !isfmtstr(format,fmtstr[fmti].str))
      fmti++;
    if (!fmtstr[fmti].str) {
#endif
      CommonWarning("AudioOpenWrite: unkown audio file format \"%s\"",
		    format);
      return (AudioFile*)NULL;
    }
  }

  if ((file=(AudioFile*)malloc(sizeof(AudioFile))) == NULL)
    CommonExit(1,"AudioOpenWrite: memory allocation error");

#ifdef USE_AFSP
  if (strcmp(fileName,"-")) {
    af = AFopenWrite(fileName,fmt,numChannel,fSample,
		     AUdebugLevel?stdout:(FILE*)NULL);
    as = NULL;
  }
  else {
#endif
    af = NULL;
    as = AuOpenWrite(fileName,numChannel,fSample);
#ifdef USE_AFSP
  }
#endif

  if (as==NULL && af==NULL) {
    CommonWarning("AudioOpenWrite: error opening audio file %s",fileName);
   FREE(file);
    return (AudioFile*)NULL;
  }

  file->file = af;
  file->stream = as;
  file->numChannel = numChannel;
  file->currentSample = 0;
  file->write = 1;
  file->numClip = 0;

  return file;
}


/* AudioReadData() */
/* Read data from audio file. */
/* Requested samples that could not be read from the file are set to 0. */

long AudioReadData (
  AudioFile *file,		/* in: audio file (handle) */
  float **data,			/* out: data[channel][sample] */
				/*      (range [-32768 .. 32767]) */
  long numSample)		/* in: number of samples to be read */
				/*     (samples per channel!) */
				/* returns: */
				/*  number of samples read */
{
  long tot,cur,num,tmp;
  long i;
  long numRead;
#ifdef USE_AFSP
  float buf[SAMPLE_BUF_SIZE];
#endif
  short bufs[SAMPLE_BUF_SIZE];

  if (AUdebugLevel >= 2)
    printf("AudioReadData: numSample=%ld (currentSample=%ld)\n",
	   numSample,file->currentSample);

  if (file->write != 0)
    CommonExit(1,"AudioReadData: audio file not in read mode");

  /* set initial unavailable samples to 0 */
  tot = file->numChannel*numSample;
  cur = 0;
  if (file->stream && file->currentSample < 0) {
    cur = min(-file->numChannel*file->currentSample,tot);
    for (i=0; i<cur; i++)
      data[i%file->numChannel][i/file->numChannel] = 0;
  }

  /* read samples from file */
  while (cur < tot) {
    num = min(tot-cur,SAMPLE_BUF_SIZE);
#ifdef USE_AFSP
    if (file->file) {
      tmp = AFreadData(file->file,
		       file->numChannel*file->currentSample+cur,buf,num);
      for (i=0; i<tmp; i++)
	data[(cur+i)%file->numChannel][(cur+i)/file->numChannel] = buf[i];
    }
#endif
    if (file->stream) {
      tmp = AuReadData(file->stream,bufs,num);
      for (i=0; i<tmp; i++)
	data[(cur+i)%file->numChannel][(cur+i)/file->numChannel] = bufs[i];
    }
    cur += tmp;
    if (tmp < num)
      break;
  }
  numRead = cur/file->numChannel;
  file->currentSample += numRead;

  /* set remaining unavailable samples to 0 */
  for (i=cur; i<tot; i++)
    data[i%file->numChannel][i/file->numChannel] = 0;

  return numRead;
}


/* AudioWriteData() */
/* Write data to audio file. */

void AudioWriteData (
  AudioFile *file,		/* in: audio file (handle) */
  float **data,			/* in: data[channel][sample] */
				/*     (range [-32768 .. 32767]) */
  long numSample)		/* in: number of samples to be written */
				/*     (samples per channel!) */
{
  long tot,cur,num;
  long i;
  long numClip,tmp;
#ifdef USE_AFSP
  float buf[SAMPLE_BUF_SIZE];
#endif
  short bufs[SAMPLE_BUF_SIZE];

  if (AUdebugLevel >= 2)
    printf("AudioWriteData: numSample=%ld (currentSample=%ld)\n",
	   numSample,file->currentSample);

  if (file->write != 1)
    CommonExit(1,"AudioWriteData: audio file not in write mode");

  tot = file->numChannel*numSample;
  cur = max(0,-file->numChannel*file->currentSample);
  while (cur < tot) {
    num = min(tot-cur,SAMPLE_BUF_SIZE);
#ifdef USE_AFSP
    if (file->file) {
      for (i=0; i<num; i++)
	buf[i] = data[(cur+i)%file->numChannel][(cur+i)/file->numChannel];
      AFwriteData(file->file,buf,num);
    }
#endif
    if (file->stream) {
      numClip = 0;
      for (i=0; i<num; i++) {
	tmp = ((long)(data[(cur+i)%file->numChannel]
		      [(cur+i)/file->numChannel]+32768.5))-32768;
	if (tmp>32767) {
	  tmp = 32767;
	  numClip++;
	}
	if (tmp<-32768) {
	    tmp = -32768;
	    numClip++;
	}
	bufs[i] = (short)tmp;
      }
      if (numClip && !file->numClip)
	CommonWarning("AudioWriteData: output samples clipped");
      file->numClip += numClip;
      AuWriteData(file->stream,bufs,num);
    }
    cur += num;
  }
  file->currentSample += tot/file->numChannel;
}


/* AudioSeek() */
/* Set position in audio file to curSample. */
/* (Beginning of file: curSample=0) */
/* NOTE: It is not possible to seek backwards in a output file if */
/*       any samples were already written to the file. */

void AudioSeek (
  AudioFile *file,		/* in: audio file (handle) */
  long curSample)		/* in: new position [samples] */
				/*     (samples per channel!) */
{
  long tot,cur,num,tmp;
#ifdef USE_AFSP
  float buf[SAMPLE_BUF_SIZE];
#endif
  short bufs[SAMPLE_BUF_SIZE];

  if (AUdebugLevel >= 1)
    printf("AudioSeek: curSample=%ld (currentSample=%ld)\n",
	   curSample,file->currentSample);

  if (file->write==0) {
    if (file->stream) {
      if (file->currentSample <= 0) {
	/* nothing read from stream yet */
	if (curSample <= 0)
	  file->currentSample = curSample;
	else
	  file->currentSample = 0;
      }
      if (curSample < file->currentSample)
	CommonWarning("AudioSeek: can not seek backward in input stream");
      else {
	/* read samples to skip */
	tot = file->numChannel*(curSample-file->currentSample);
	cur = 0;
	while (cur < tot) {
	  num = min(tot-cur,SAMPLE_BUF_SIZE);
	  tmp = AuReadData(file->stream,bufs,num);
	  cur += tmp;
	  if (tmp < num)
	    break;
	}
	file->currentSample = curSample;
      }
    }
    else
      file->currentSample = curSample;
  }
  else {
    if (file->currentSample <= 0) {
      /* nothing written to file yet */
      if (curSample <= 0)
	file->currentSample = curSample;
      else
	file->currentSample = 0;
    }
    if (curSample < file->currentSample)
      CommonExit(1,"AudioSeek: error seeking backwards in output file");
    if (curSample > file->currentSample) {
      /* seek forward, fill skipped region with silence */
#ifdef USE_AFSP
      memset(buf,0,SAMPLE_BUF_SIZE*sizeof(float));
#endif
      memset(bufs,0,SAMPLE_BUF_SIZE*sizeof(short));
      tot = file->numChannel*(curSample-file->currentSample);
      cur = 0;
      while (cur < tot) {
	num = min(tot-cur,SAMPLE_BUF_SIZE);
#ifdef USE_AFSP
	if (file->file)
	  AFwriteData(file->file,buf,num);
#endif
	if (file->stream)
	  AuWriteData(file->stream,bufs,num);
	cur += num;
      }
      file->currentSample = curSample;
    }
  }
}


/* AudioClose() */
/* Close audio file.*/

void AudioClose (
  AudioFile *file)		/* in: audio file (handle) */
{
  if (AUdebugLevel >= 1)
    printf("AudioClose: (currentSample=%ld)\n",file->currentSample);

  if (file->numClip)
    CommonWarning("AudioClose: %ld samples clipped",file->numClip);

#ifdef USE_AFSP
  if (file->file)
    AFclose(file->file);
#endif
  if (file->stream)
    AuClose(file->stream);
 FREE(file);
}


/* end of audio.c */