headers.c

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

static const unsigned int I_INRS[NINRS] = {0xcb460020, 0xd0465555, 0xfa460000, 0x1c470040, 0x3b470080, 0x7a470000, 0x9c470040};

static off_t data_location = 0;
static int srate = 0, chans = 0, header_type = MUS_UNSUPPORTED, data_format = MUS_UNKNOWN, original_data_format = 0;
static int type_specifier = 0, bits_per_sample = 0, block_align = 0, fact_samples = 0;
static off_t comment_start = 0, comment_end = 0;
static off_t true_file_length = 0, data_size = 0;
static int base_detune = 0, base_note = 0;
static bool little_endian = false;

off_t mus_header_samples(void) {return(data_size);}
off_t mus_header_data_location(void) {return(data_location);}
int mus_header_chans(void) {return(chans);}
int mus_header_srate(void) {return(srate);}
int mus_header_type(void) {return(header_type);}
int mus_header_format(void) {return(data_format);}
off_t mus_header_comment_start(void) {return(comment_start);}
off_t mus_header_comment_end(void) {return(comment_end);}
off_t mus_header_aux_comment_start(int n) {if (aux_comment_start) return(aux_comment_start[n]); else return(-1);}
off_t mus_header_aux_comment_end(int n) {if (aux_comment_end) return(aux_comment_end[n]); else return(-1);}
int mus_header_type_specifier(void) {return(type_specifier);}
int mus_header_bits_per_sample(void) {return(bits_per_sample);}
int mus_header_fact_samples(void) {return(fact_samples);}
int mus_header_block_align(void) {return(block_align);}
off_t mus_header_true_length(void) {return(true_file_length);}
int mus_header_original_format(void) {return(original_data_format);}
int mus_header_loop_mode(int which) {if (loop_modes) return(loop_modes[which]); else return(-1);}
int mus_header_loop_start(int which) {if (loop_starts) return(loop_starts[which]); else return(-1);}
int mus_header_loop_end(int which) {if (loop_ends) return(loop_ends[which]); else return(-1);}
int mus_header_mark_position(int id) {int i; for (i = 0; i < markers; i++) {if (marker_ids[i] == id) return(marker_positions[i]);} return(-1);}
int mus_header_base_detune(void) {return(base_detune);}
int mus_header_base_note(void) {return(base_note);}

int mus_bytes_per_sample(int format)
{
  switch (format)
    {
    case MUS_BYTE:             return(1); break;
    case MUS_BSHORT:           return(2); break;
    case MUS_UBYTE:            return(1); break;
    case MUS_MULAW:            return(1); break;
    case MUS_ALAW:             return(1); break;
    case MUS_BINT:             return(4); break;
    case MUS_BFLOAT:           return(4); break;
    case MUS_BFLOAT_UNSCALED:  return(4); break;
    case MUS_B24INT:           return(3); break;
    case MUS_BDOUBLE:          return(8); break;
    case MUS_BDOUBLE_UNSCALED: return(8); break;
    case MUS_LSHORT:           return(2); break;
    case MUS_LINT:             return(4); break;
    case MUS_LFLOAT:           return(4); break;
    case MUS_LDOUBLE:          return(8); break;
    case MUS_LFLOAT_UNSCALED:  return(4); break;
    case MUS_LDOUBLE_UNSCALED: return(8); break;
    case MUS_L24INT:           return(3); break;
    case MUS_UBSHORT:          return(2); break;
    case MUS_ULSHORT:          return(2); break;
    case MUS_BINTN:            return(4); break;
    case MUS_LINTN:            return(4); break;
    default:                   return(1); break; /* we divide by this number, so 0 is not safe */
    }
}

off_t mus_samples_to_bytes (int format, off_t size) {return(size * (mus_bytes_per_sample(format)));}
off_t mus_bytes_to_samples (int format, off_t size) {return((off_t)(size / (mus_bytes_per_sample(format))));}


static bool equal_big_or_little_endian(const unsigned char *n1, const unsigned int n2)
{
  return((mus_char_to_ubint(n1) == n2) || (mus_char_to_ulint(n1) == n2));
}

static short big_or_little_endian_short(const unsigned char *n, bool little)
{
  if (little) return(mus_char_to_lshort(n));
  return(mus_char_to_bshort(n));
}

static int big_or_little_endian_int(const unsigned char *n, bool little)
{
  if (little) return(mus_char_to_lint(n));
  return(mus_char_to_bint(n));
}

static unsigned int big_or_little_endian_uint(const unsigned char *n, bool little)
{
  if (little) return(mus_char_to_ulint(n));
  return(mus_char_to_ubint(n));
}

static float big_or_little_endian_float(const unsigned char *n, bool little)
{
  if (little) return(mus_char_to_lfloat(n));
  return(mus_char_to_bfloat(n));
}

static bool match_four_chars(const unsigned char *head, const unsigned char *match)
{ 
  return((head[0] == match[0]) &&
	 (head[1] == match[1]) &&
	 (head[2] == match[2]) &&
	 (head[3] == match[3]));
}
  
static void write_four_chars(unsigned char *head, const unsigned char *match)
{
  head[0] = match[0];
  head[1] = match[1];
  head[2] = match[2];
  head[3] = match[3];
}

const char *mus_header_type_name(int type)
{
  switch (type)
    {
    case MUS_NEXT:             return("Sun/Next");                break;
    case MUS_AIFC:             return("AIFC");                    break;
    case MUS_RIFF:             return("RIFF");                    break;
    case MUS_BICSF:            return("BICSF");                   break;
    case MUS_NIST:             return("NIST");                    break;
    case MUS_INRS:             return("INRS");                    break;
    case MUS_ESPS:             return("ESPS");                    break;
    case MUS_SVX:              return("SVX8");                    break;
    case MUS_VOC:              return("VOC");                     break;
    case MUS_SNDT:             return("SNDT");                    break;
    case MUS_RAW:              return("raw (no header)");         break;
    case MUS_SMP:              return("SMP");                     break;
    case MUS_AVR:              return("AVR");                     break;
    case MUS_IRCAM:            return("IRCAM");                   break;
    case MUS_SD1:              return("Sound Designer 1");        break;
    case MUS_SPPACK:           return("SPPACK");                  break;
    case MUS_MUS10:            return("Mus10");                   break;
    case MUS_HCOM:             return("HCOM");                    break;
    case MUS_PSION:            return("PSION");                   break;
    case MUS_MAUD:             return("MAUD");                    break;
    case MUS_IEEE:             return("IEEE text");               break;
    case MUS_MATLAB:           return("Matlab");                  break;
    case MUS_ADC:              return("ADC/OGI");                 break;
    case MUS_MIDI:             return("MIDI");                    break;
    case MUS_SOUNDFONT:        return("SoundFont");               break;
    case MUS_GRAVIS:           return("Gravis Ultrasound patch"); break;
    case MUS_COMDISCO:         return("Comdisco SPW signal");     break;
    case MUS_GOLDWAVE:         return("Goldwave sample");         break;
    case MUS_SRFS:             return("SRFS");                    break;
    case MUS_MIDI_SAMPLE_DUMP: return("MIDI sample dump");        break;
    case MUS_DIAMONDWARE:      return("DiamondWare");             break;
    case MUS_ADF:              return("CSRE adf");                break;
    case MUS_SBSTUDIOII:       return("SBStudioII");              break;
    case MUS_DELUSION:         return("Delusion");                break;
    case MUS_FARANDOLE:        return("Farandole");               break;
    case MUS_SAMPLE_DUMP:      return("Sample dump");             break;
    case MUS_ULTRATRACKER:     return("Ultratracker");            break;
    case MUS_YAMAHA_TX16W:     return("TX-16W");                  break;
    case MUS_YAMAHA_SY85:      return("Sy-85");                   break;
    case MUS_YAMAHA_SY99:      return("Sy-99");                   break;
    case MUS_KURZWEIL_2000:    return("Kurzweil 2000");           break;
    case MUS_KORG:             return("Korg");                    break;
    case MUS_MAUI:             return("Turtle Beach");            break;
    case MUS_IMPULSETRACKER:   return("Impulse Tracker");         break;
    case MUS_AKAI4:            return("AKAI 4");                  break;
    case MUS_DIGIPLAYER:       return("Digiplayer ST3");          break;
    case MUS_COVOX:            return("Covox V8");                break;
    case MUS_AVI:              return("AVI");                     break;
    case MUS_OMF:              return("OMF");                     break;
    case MUS_QUICKTIME:        return("Quicktime");               break;
    case MUS_ASF:              return("asf");                     break;
    case MUS_AIFF:             return("AIFF");                    break;
    case MUS_PAF:              return("Ensoniq Paris");           break;
    case MUS_CSL:              return("CSL");                     break;
    case MUS_FILE_SAMP:        return("snack SMP");               break;
    case MUS_PVF:              return("Portable Voice Format");   break;
    case MUS_SOUNDFORGE:       return("SoundForge");              break;
    case MUS_TWINVQ:           return("TwinVQ");                  break;
    case MUS_SDIF:             return("IRCAM sdif");              break;
    case MUS_NVF:              return("Creative NVF");            break;
    case MUS_OGG:              return("Ogg Vorbis");              break;
    case MUS_FLAC:             return("Flac");                    break;
    case MUS_SPEEX:            return("Speex");                   break;
    case MUS_MPEG:             return("mpeg");                    break;
    case MUS_SHORTEN:          return("shorten");                 break;
    case MUS_TTA:              return("tta");                     break;
    case MUS_WAVPACK:          return("wavpack");                 break;
    default:                   return("unsupported");             break;
    }
}

const char *mus_data_format_name(int format)
{
  switch (format)
    {
    case MUS_BSHORT:           return("big endian short (16 bits)");               break;
    case MUS_MULAW:            return("mulaw (8 bits)");                           break;
    case MUS_BYTE:             return("signed byte (8 bits)");                     break;
    case MUS_BFLOAT:           return("big endian float (32 bits)");               break;
    case MUS_BFLOAT_UNSCALED:  return("big endian float (32 bits, unscaled)");     break;
    case MUS_BINT:             return("big endian int (32 bits)");                 break;
    case MUS_ALAW:             return("alaw (8 bits)");                            break;
    case MUS_UBYTE:            return("unsigned byte (8 bits)");                   break;
    case MUS_B24INT:           return("big endian int (24 bits)");                 break;
    case MUS_BDOUBLE:          return("big endian double (64 bits)");              break;
    case MUS_BDOUBLE_UNSCALED: return("big endian double (64 bits, unscaled)");    break;
    case MUS_LSHORT:           return("little endian short (16 bits)");            break;
    case MUS_LINT:             return("little endian int (32 bits)");              break;
    case MUS_LFLOAT:           return("little endian float (32 bits)");            break;
    case MUS_LDOUBLE:          return("little endian double (64 bits)");           break;
    case MUS_LFLOAT_UNSCALED:  return("little endian float (32 bits, unscaled)");  break;
    case MUS_LDOUBLE_UNSCALED: return("little endian double (64 bits, unscaled)"); break;
    case MUS_UBSHORT:          return("unsigned big endian short (16 bits)");      break;
    case MUS_ULSHORT:          return("unsigned little endian short (16 bits)");   break;
    case MUS_L24INT:           return("little endian int (24 bits)");              break;
    case MUS_BINTN:            return("normalized big endian int (32 bits)");      break;
    case MUS_LINTN:            return("normalized little endian int (32 bits)");   break;
    default:                   return("unknown");                                  break;
    }
}

const char *mus_data_format_short_name(int format)
{
  switch (format)
    {
    case MUS_BSHORT:           return("short int");       break;
    case MUS_MULAW:            return("mulaw");           break;
    case MUS_BYTE:             return("signed byte");     break;
    case MUS_BFLOAT:           return("float");           break;
    case MUS_BFLOAT_UNSCALED:  return("float unscaled)"); break;
    case MUS_BINT:             return("int");             break;
    case MUS_ALAW:             return("alaw");            break;
    case MUS_UBYTE:            return("unsigned byte");   break;
    case MUS_B24INT:           return("24-bit int");      break;
    case MUS_BDOUBLE:          return("double");          break;
    case MUS_BDOUBLE_UNSCALED: return("double unscaled"); break;
    case MUS_LSHORT:           return("short int");       break;
    case MUS_LINT:             return("int");             break;
    case MUS_LFLOAT:           return("float");           break;
    case MUS_LDOUBLE:          return("double");          break;
    case MUS_LFLOAT_UNSCALED:  return("float unscaled");  break;
    case MUS_LDOUBLE_UNSCALED: return("double unscaled"); break;
    case MUS_UBSHORT:          return("unsigned short");  break;
    case MUS_ULSHORT:          return("unsigned short");  break;
    case MUS_L24INT:           return("24-bit int");      break;
    case MUS_BINTN:            return("normalized int");  break;
    case MUS_LINTN:            return("normalized int");  break;
    default:                   return("unknown");         break;
    }
}

#if HAVE_RUBY
  #define TO_LANG(Str) strdup(xen_scheme_constant_to_ruby(Str))
#else
  #define TO_LANG(Str) Str
#endif

char *mus_header_type_to_string(int type)
{
  switch (type)
    {
    case MUS_NEXT:      return(TO_LANG(S_mus_next));
    case MUS_AIFF:      return(TO_LANG(S_mus_aiff));
    case MUS_AIFC:      return(TO_LANG(S_mus_aifc));
    case MUS_RIFF:      return(TO_LANG(S_mus_riff));
    case MUS_NIST:      return(TO_LANG(S_mus_nist));
    case MUS_IRCAM:     return(TO_LANG(S_mus_ircam));
    case MUS_RAW:       return(TO_LANG(S_mus_raw));
    case MUS_BICSF:     return(TO_LANG(S_mus_bicsf));
    case MUS_VOC:       return(TO_LANG(S_mus_voc));
    case MUS_SVX:       return(TO_LANG(S_mus_svx));
    case MUS_SOUNDFONT: return(TO_LANG(S_mus_soundfont));
    }
  return(NULL);
}

char *mus_data_format_to_string(int format)
{
  switch (format)