headers.c

音频信号的重采样程序,如44.1K的WAV转换成采样频率为48K的WAV.

    {
    case MUS_BSHORT:           return(TO_LANG(S_mus_bshort));
    case MUS_LSHORT:           return(TO_LANG(S_mus_lshort));
    case MUS_MULAW:            return(TO_LANG(S_mus_mulaw));
    case MUS_ALAW:             return(TO_LANG(S_mus_alaw));
    case MUS_BYTE:             return(TO_LANG(S_mus_byte));
    case MUS_UBYTE:            return(TO_LANG(S_mus_ubyte));
    case MUS_BFLOAT:           return(TO_LANG(S_mus_bfloat));
    case MUS_LFLOAT:           return(TO_LANG(S_mus_lfloat));
    case MUS_BINT:             return(TO_LANG(S_mus_bint));
    case MUS_LINT:             return(TO_LANG(S_mus_lint));
    case MUS_BINTN:            return(TO_LANG(S_mus_bintn));
    case MUS_LINTN:            return(TO_LANG(S_mus_lintn));
    case MUS_B24INT:           return(TO_LANG(S_mus_b24int));
    case MUS_L24INT:           return(TO_LANG(S_mus_l24int));
    case MUS_BDOUBLE:          return(TO_LANG(S_mus_bdouble));
    case MUS_LDOUBLE:          return(TO_LANG(S_mus_ldouble));
    case MUS_UBSHORT:          return(TO_LANG(S_mus_ubshort));
    case MUS_ULSHORT:          return(TO_LANG(S_mus_ulshort));
    case MUS_BDOUBLE_UNSCALED: return(TO_LANG(S_mus_bdouble_unscaled));
    case MUS_LDOUBLE_UNSCALED: return(TO_LANG(S_mus_ldouble_unscaled));
    case MUS_BFLOAT_UNSCALED:  return(TO_LANG(S_mus_bfloat_unscaled));
    case MUS_LFLOAT_UNSCALED:  return(TO_LANG(S_mus_lfloat_unscaled));
    }
  return(NULL);
}

static const char *any_data_format_name(int sndlib_format)
{
  if (MUS_DATA_FORMAT_OK(sndlib_format))
    return(mus_data_format_name(sndlib_format));
  else return(mus_header_original_format_name(mus_header_original_format(),
					      mus_header_type()));
}

#define SEEK_FILE_LENGTH(File) lseek(File, 0L, SEEK_END)
static int read_bicsf_header(const char *filename, int chan);


/* ------------------------------------ NeXT (or Sun) -------------------------------- 
 * 
 *   0:  ".snd"
 *   4:  data_location (bytes) (not necessarily word aligned on Sun)
 *   8:  data_size (bytes) -- sometimes incorrect ("advisory")
 *   12: data format indicator -- see below
 *   16: srate (int)
 *   20: chans
 *   24: comment start
 *   
 * in an AFsp file, the first 4 bytes of the comment are "AFsp",
 * for bicsf, the integer at 28 is 107364 or 107415
 *
 * on NeXTStep, always big-endian.  ".snd"==0x2e736e64 on big-endian machines.
 *
 * formats are: 
 * 0 unspecified, 1 mulaw_8, 2 linear_8, 3 linear_16, 4 linear_24, 5 linear_32, 6 float,
 * 7 double, 8 indirect, 9 nested, 10 dsp_core, 11 dsp_data_8, 12 dsp_data_16, 13 dsp_data_24,
 * 14 dsp_data_32, 16 display, 17 mulaw_squelch, 18 emphasized, 19 compressed, 20 compressed_emphasized
 * 21 dsp_commands, 22 dsp_commands_samples, 23 adpcm_g721, 24 adpcm_g722, 25 adpcm_g723,
 * 26 adpcm_g723_5, 27 alaw_8, 28 aes, 29 delat_mulaw_8 
 *   internal Snd(lib)-only formats: 
 *     30: mus_lint, 31: mus_lfloat, 
 *     32: mus_bintn, 33: mus_lintn,
 *     34: mus_ldouble and others... (added by me for Snd internal use)
 */

/* according to the file /usr/share/magic, the DECN versions were little endian */

static int read_next_header(const char *filename, int chan)
{
  int maybe_bicsf, err = MUS_NO_ERROR, i;
  type_specifier = mus_char_to_uninterpreted_int((unsigned char *)hdrbuf);
  data_location = mus_char_to_bint((unsigned char *)(hdrbuf + 4));
  if (data_location < 24) return(mus_error(MUS_HEADER_READ_FAILED, "%s: data location: " OFF_TD "?", filename, data_location));
  data_size = mus_char_to_bint((unsigned char *)(hdrbuf + 8));
  /* can be bogus -- fixup if possible */
  true_file_length = SEEK_FILE_LENGTH(chan);
  if ((data_size <= 24) || (data_size > true_file_length))
    data_size = (true_file_length - data_location);
  else
    {
      if (true_file_length > (off_t)(1 << 31))
	data_size = true_file_length - data_location; /* assume size field overflowed 32 bits */
    }
  original_data_format = mus_char_to_bint((unsigned char *)(hdrbuf + 12));
  switch (original_data_format) 
    {
    case 1:  data_format = MUS_MULAW;            break;
    case 2:  data_format = MUS_BYTE;             break; /* some sound files assume MUS_UBYTE here! (NAS from 1994 X11R6 contrib) */
    case 3:  data_format = MUS_BSHORT;           break;
    case 4:  data_format = MUS_B24INT;           break;
    case 5:  data_format = MUS_BINT;             break;
    case 6:  data_format = MUS_BFLOAT;           break;
    case 7:  data_format = MUS_BDOUBLE;          break;
    case 18: data_format = MUS_BSHORT;           break; /* "emphasized": Xavier Serra's de-emphasis filter: y(n) = x(n) + .9 y(n-1) */
    case 27: data_format = MUS_ALAW;             break;
    case 30: data_format = MUS_LINT;             break; /* from here on, for Snd's internal benefit -- these are probably not used elsewhere */
    case 31: data_format = MUS_LFLOAT;           break; 
    case 32: data_format = MUS_BINTN;            break; 
    case 33: data_format = MUS_LINTN;            break; 
    case 34: data_format = MUS_LDOUBLE;          break; 
    case 35: data_format = MUS_ULSHORT;          break; 
    case 36: data_format = MUS_UBSHORT;          break; 
    case 37: data_format = MUS_LFLOAT_UNSCALED;  break;
    case 38: data_format = MUS_BFLOAT_UNSCALED;  break;
    case 39: data_format = MUS_LDOUBLE_UNSCALED; break;
    case 40: data_format = MUS_BDOUBLE_UNSCALED; break;
    case 41: data_format = MUS_LSHORT;           break; 
    case 42: data_format = MUS_L24INT;           break; 
    case 43: data_format = MUS_UBYTE;            break; 
    default: data_format = MUS_UNKNOWN;          break;
    }
  srate = mus_char_to_bint((unsigned char *)(hdrbuf + 16));
  chans = mus_char_to_bint((unsigned char *)(hdrbuf + 20));
  comment_start = 0;
  comment_end = 0;
  for (i = 24; i < data_location - 1; i++)
    if (hdrbuf[i] == '\0') 
      break;
    else
      {
	if (hdrbuf[i] != ' ')
	  {
	    comment_start = i;
	    comment_end = data_location - 1;
	    break;
	  }
      }
  if (comment_end < comment_start) comment_end = comment_start;
  maybe_bicsf = mus_char_to_bint((unsigned char *)(hdrbuf + 28));
  if (maybe_bicsf == 107364) err = read_bicsf_header(filename, chan);
  data_size = mus_bytes_to_samples(data_format, data_size);
  return(err);
}

static int sndlib_format_to_next(int format)
{
  switch (format)
    {
    case MUS_MULAW:            return(1);  break;
    case MUS_BYTE:             return(2);  break;
    case MUS_BSHORT:           return(3);  break;
    case MUS_B24INT:           return(4);  break;
    case MUS_BINT:             return(5);  break;
    case MUS_BFLOAT:           return(6);  break;
    case MUS_BDOUBLE:          return(7);  break;
    case MUS_ALAW:             return(27); break;
    case MUS_LINT:             return(30); break; /* see above */
    case MUS_LFLOAT:           return(31); break; 
    case MUS_BINTN:            return(32); break; 
    case MUS_LINTN:            return(33); break; 
    case MUS_LDOUBLE:          return(34); break; 
    case MUS_ULSHORT:          return(35); break; 
    case MUS_UBSHORT:          return(36); break;
    case MUS_LFLOAT_UNSCALED:  return(37); break;
    case MUS_BFLOAT_UNSCALED:  return(38); break;
    case MUS_LDOUBLE_UNSCALED: return(39); break;
    case MUS_BDOUBLE_UNSCALED: return(40); break;
    case MUS_LSHORT:           return(41); break;
    case MUS_L24INT:           return(42); break;
    case MUS_UBYTE:            return(43); break;
    default: 
      return(mus_error(MUS_UNSUPPORTED_DATA_FORMAT, "Next header: can't write data format: %d (%s)",
		       format,
		       any_data_format_name(format)));
      break;
    }
}

#if MUS_DEBUGGING
  #define CHK_WRITE(Fd, Buf, Len)						\
    do { size_t bytes = 0;							\
         if (((Len) > 0) && ((bytes = write(Fd, Buf, Len)) == 0))	\
	   fprintf(stderr, "%s[%d]: header write error (wrote: %d != requested: %d)", c__FUNCTION__, __LINE__, (int)bytes, (int)(Len)); \
       } while (0)
  #define CHK_READ(Fd, Buf, Len)			  \
    do { size_t bytes = 0;							\
         if (((Len) > 0) && ((bytes = read(Fd, Buf, (Len))) == 0))	\
  	   fprintf(stderr, "%s[%d]: header read error (read %d != requested %d)", c__FUNCTION__, __LINE__, (int)bytes, (int)(Len)); \
       } while (0)
#else
  #define CHK_WRITE(Fd, Buf, Len) do {if (((Len) > 0) && (write(Fd, Buf, Len) == 0)) fprintf(stderr, "header write error");} while (0)
  #define CHK_READ(Fd, Buf, Len) do {if (((Len) > 0) && (read(Fd, Buf, Len) == 0)) fprintf(stderr, "header read error");} while (0)
#endif

static void write_next_comment(int fd, const char *comment, int len, int loc)
{
  if (len > 0)
    CHK_WRITE(fd, (unsigned char *)comment, len);
  len = loc - (len + 24);
  if (len > 0)
    {
      unsigned char *combuf;
      combuf = (unsigned char *)CALLOC(len, sizeof(char));
      CHK_WRITE(fd, combuf, len);
      FREE(combuf);
    }
}

int mus_header_write_next_header(int chan, int wsrate, int wchans, int loc, int siz, int format, const char *comment, int len)
{
  int i, j;
  write_four_chars((unsigned char *)hdrbuf, I_DSND); /* ".snd" */
  i = len / 4;
  j = 24 + (4 * (i + 1));
  if (loc < j) loc = j;
  mus_bint_to_char((unsigned char *)(hdrbuf + 4), loc);
  mus_bint_to_char((unsigned char *)(hdrbuf + 8), siz);
  mus_bint_to_char((unsigned char *)(hdrbuf + 12), sndlib_format_to_next(format));
  mus_bint_to_char((unsigned char *)(hdrbuf + 16), wsrate);
  mus_bint_to_char((unsigned char *)(hdrbuf + 20), wchans);
  CHK_WRITE(chan, hdrbuf, 24);
  write_next_comment(chan, comment, len, loc);
  data_location = loc;
  return(MUS_NO_ERROR);
}



/* ------------------------------------ AIFF ------------------------------------ 
 *
 *  0: "FORM"
 *  4: size (bytes)
 *  8: "AIFF" or "AIFC" -- the latter includes compressed formats (list extended for 8.5 Sound.h)
 *
 *  Thereafter the file is organized into "chunks", each chunk being 
 *  a 4-byte identifer followed by an int (4-bytes) giving the chunk size
 *  not including the 8-byte header.  AIFF data is signed.  If the chunk
 *  size is odd, an extra (unaccounted-for) null byte is added at the end.
 *
 *  The chunks we want are "COMM", "SSND", and "APPL".
 *
 * COMM: 0: chans
 *       2: frames
 *       6: bits per sample
 *       8: srate as 80-bit IEEE float
 *  then if AIFC (not AIFF), 4 bytes giving compression id ("NONE"=not compressed)
 *    followed by Pascal string giving long name of compression type
 *
 * SSND: 0: data location (offset within SSND chunk)
 *
 * Other chunks include:  ANNO: a comment, INST: loop control, MARK: marker, MIDI: midi,
 *                        COMT: comment (max 65536 chars), NAME: sound name, AUTH: author's name
 *                        (c), AESD: recording data, APPL: application specific stuff
 *    "MARK" size short-#marks {marks} -- latter are short-ID long-position pstring-name.
 *    "INST" size chars[baseNote detune lowNote highNote lowVelocity HighVelocity] short-gain loops[sustain release]
 *      loop: short-playMode marker-begin marker-end (signed?) shorts)
 *         playMode: 0 no loop, 1 forward loop, 2 forward/backward loop
 *      chars are MIDI data (detune is in cents)
 *    "MIDI" size MIDI-data...
 *    "AESD" size AES Channel Status Data (24 bytes as specified by AES)
 *      see "AES: Guidelines for the use of the AES3 interface"
 *      byte 0: bit 0: 0 = consumer, 1 = pro
 *              bit 1: 0 = audio, 1 = non-audio
 *              bits 2:4: emphasis: 0:none, 4:none, 6:CD, 7:CCITT J17
 *              bits 6:7: srate: 00 = 48KHz, 01 = 48, 10 = 44.1, 11 = 32
 *      byte 1: bits 0:3: chans: 2:mono, else stereo
 *      byte 2 for word size stuff (always ends up 16-bit): bits 3-5 = sample length where 4 = 16-bit
 *      byte 3: multi-channels modes, 4: AES sync ref, 5:unused, 6-9:ASCII source ID, 10-13:ASCII destination ID
 *      byte 14-17:local sample addr, 18-21:time of day addr, then CRC checks
 *    "APPL" size signature data
 *    "COMT" size short-#comments {comments} -- the latter are long-time marker short-text-length char-text
 *       time is in seconds since 1-Jan-1904
 *    "NAME"/"AUTH"/"(c) "/"ANNO" size char-name
 *    "FVER" size(4) AIFC-format-version -- currently always 0xA2805140
 *    "SAXL" -- a desperate kludge to get around Apple's own compression schemes!
 *
 * always big-endian
 * There was also (briefly) an AIFS file, now deprecated.
 */

/* ieee-80 conversions -- design by committee! */
/* this code taken from CSound sources -- apparently originally written by Malcolm Slaney at Apple */

#define ULPOW2TO31	((unsigned int)0x80000000)