ref: b818f48f41895754dd9b470be407ba85cfea45bd
dir: /sys/src/cmd/audio/mp3enc/get_audio.c/
/* * Get Audio routines source file * * Copyright (c) 1999 Albert L Faber * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* $Id: get_audio.c,v 1.61 2001/03/19 21:26:05 markt Exp $ */ #ifdef HAVE_CONFIG_H # include <config.h> #endif #include <assert.h> #ifdef HAVE_LIMITS_H # include <limits.h> #endif #include <stdio.h> #ifdef STDC_HEADERS # include <stdlib.h> # include <string.h> #else # ifndef HAVE_STRCHR # define strchr index # define strrchr rindex # endif char *strchr(), *strrchr(); # ifndef HAVE_MEMCPY # define memcpy(d, s, n) bcopy ((s), (d), (n)) # define memmove(d, s, n) bcopy ((s), (d), (n)) # endif #endif #include <math.h> #include <sys/types.h> #include <sys/stat.h> #include "lame.h" #include "main.h" #include "get_audio.h" #include "portableio.h" #include "timestatus.h" #include "lametime.h" #ifdef WITH_DMALLOC #include <dmalloc.h> #endif /* global data for get_audio.c. */ int count_samples_carefully; int pcmbitwidth; mp3data_struct mp3input_data; /* used by Ogg and MP3 */ unsigned int num_samples_read; FILE *musicin; #ifdef AMIGA_MPEGA int lame_decode_initfile(const char *fullname, mp3data_struct * const mp3data); #else int lame_decode_initfile(FILE * const fd, mp3data_struct * const mp3data); #endif /* read mp3 file until mpglib returns one frame of PCM data */ int lame_decode_fromfile(FILE * fd, short int pcm_l[], short int pcm_r[], mp3data_struct * mp3data); /* and for Vorbis: */ int lame_decode_ogg_initfile( lame_global_flags* gfp, FILE* fd, mp3data_struct* mp3data ); int lame_decode_ogg_fromfile( lame_global_flags* gfc, FILE* fd, short int pcm_l[], short int pcm_r[], mp3data_struct* mp3data ); static int read_samples_pcm(FILE * musicin, short sample_buffer[2304], int frame_size, int samples_to_read); static int read_samples_mp3(lame_global_flags * gfp, FILE * musicin, short int mpg123pcm[2][1152], int num_chan); static int read_samples_ogg(lame_global_flags * gfp, FILE * musicin, short int mpg123pcm[2][1152], int num_chan); void CloseSndFile(sound_file_format input, FILE * musicin); FILE *OpenSndFile(lame_global_flags * gfp, char *); /* Replacement for forward fseek(,,SEEK_CUR), because fseek() fails on pipes */ static int fskip(FILE * fp, long offset, int whence) { #ifndef PIPE_BUF char buffer[4096]; #else char buffer[PIPE_BUF]; #endif int read; if (0 == fseek(fp, offset, whence)) return 0; if (whence != SEEK_CUR || offset < 0) { fprintf(stderr, "fskip problem: Mostly the return status of functions is not evaluated so it is more secure to pollute <stderr>.\n"); return -1; } while (offset > 0) { read = offset > sizeof(buffer) ? sizeof(buffer) : offset; if ((read = fread(buffer, 1, read, fp)) <= 0) return -1; offset -= read; } return 0; } FILE * init_outfile(char *outPath, int decode) { FILE *outf; /* open the output file */ if (0 == strcmp(outPath, "-")) lame_set_stream_binary_mode(outf = stdout); else if ((outf = fopen(outPath, "wb+")) == NULL) return NULL; return outf; } void init_infile(lame_global_flags * gfp, char *inPath) { /* open the input file */ count_samples_carefully = 0; pcmbitwidth = 16; musicin = OpenSndFile(gfp, inPath); } void close_infile(void) { CloseSndFile(input_format, musicin); } void SwapBytesInWords(short *ptr, int short_words) { /* Some speedy code */ unsigned long val; unsigned long *p = (unsigned long *) ptr; #ifndef lint # if defined(CHAR_BIT) # if CHAR_BIT != 8 # error CHAR_BIT != 8 # endif # else # error can not determine number of bits in a char # endif #endif /* lint */ assert(sizeof(short) == 2); #if defined(SIZEOF_UNSIGNED_LONG) && SIZEOF_UNSIGNED_LONG == 4 for (; short_words >= 2; short_words -= 2, p++) { val = *p; *p = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0x00FF00FF); } ptr = (short *) p; for (; short_words >= 1; short_words -= 1, ptr++) { val = *ptr; *ptr = ((val << 8) & 0xFF00) | ((val >> 8) & 0x00FF); } #elif defined(SIZEOF_UNSIGNED_LONG) && SIZEOF_UNSIGNED_LONG == 8 for (; short_words >= 4; short_words -= 4, p++) { val = *p; *p = ((val << 8) & 0xFF00FF00FF00FF00) | ((val >> 8) & 0x00FF00FF00FF00FF); } ptr = (short *) p; for (; short_words >= 1; short_words -= 1, ptr++) { val = *ptr; *ptr = ((val << 8) & 0xFF00) | ((val >> 8) & 0x00FF); } #else # ifdef SIZEOF_UNSIGNED_LONG //# warning Using unoptimized SwapBytesInWords(). # endif for (; short_words >= 1; short_words -= 1, ptr++) { val = *ptr; *ptr = ((val << 8) & 0xFF00) | ((val >> 8) & 0x00FF); } #endif assert(short_words == 0); } /************************************************************************ * * get_audio() * * PURPOSE: reads a frame of audio data from a file to the buffer, * aligns the data for future processing, and separates the * left and right channels * ************************************************************************/ int get_audio(lame_global_flags * const gfp, short buffer[2][1152]) { int num_channels = lame_get_num_channels( gfp ); short insamp[2 * 1152]; int samples_read; int framesize; int samples_to_read; unsigned int remaining, tmp_num_samples; int j; short *p; /* * NOTE: LAME can now handle arbritray size input data packets, * so there is no reason to read the input data in chuncks of * size "gfp->framesize". EXCEPT: the LAME graphical frame analyzer * will get out of sync if we read more than framesize worth of data. */ samples_to_read = framesize = gfp->framesize; assert(framesize <= 1152); /* get num_samples */ tmp_num_samples = lame_get_num_samples( gfp ); /* if this flag has been set, then we are carefull to read * exactly num_samples and no more. This is useful for .wav and .aiff * files which have id3 or other tags at the end. Note that if you * are using LIBSNDFILE, this is not necessary */ if (count_samples_carefully) { remaining = tmp_num_samples - Min(tmp_num_samples, num_samples_read); if (remaining < framesize) samples_to_read = remaining; } switch (input_format) { case sf_mp1: case sf_mp2: case sf_mp3: samples_read = read_samples_mp3(gfp, musicin, buffer, num_channels); break; case sf_ogg: samples_read = read_samples_ogg(gfp, musicin, buffer, num_channels); break; default: samples_read = read_samples_pcm(musicin, insamp, num_channels * framesize, num_channels * samples_to_read); samples_read /= num_channels; p = insamp; switch (num_channels) { case 1: for (j = 0; j < framesize; j++) { buffer[0][j] = *p++; buffer[1][j] = 0; } break; case 2: for (j = 0; j < framesize; j++) { buffer[0][j] = *p++; buffer[1][j] = *p++; } break; default: assert(0); break; } } /* if num_samples = MAX_U_32_NUM, then it is considered infinitely long. Don't count the samples */ if ( tmp_num_samples != MAX_U_32_NUM ) num_samples_read += samples_read; return samples_read; } int read_samples_ogg(lame_global_flags * const gfp, FILE * const musicin, short int oggpcm[2][1152], const int stereo) { int out = 0; #ifdef HAVE_VORBIS static const char type_name[] = "Ogg Vorbis file"; out = lame_decode_ogg_fromfile( gfp, musicin, oggpcm[0], oggpcm[1], &mp3input_data ); /* * out < 0: error, probably EOF * out = 0: not possible with lame_decode_fromfile() ??? * out > 0: number of output samples */ if (out < 0) { memset(oggpcm, 0, sizeof(**oggpcm) * 2 * 1152); return 0; } if (lame_get_num_channels( gfp ) != mp3input_data.stereo) fprintf(stderr, "Error: number of channels has changed in %s - not supported\n", type_name); if ( lame_get_in_samplerate( gfp ) != mp3input_data.samplerate ) fprintf(stderr, "Error: sample frequency has changed in %s - not supported\n", type_name); #else out = -1; /* wanna read ogg without vorbis support? */ #endif return out; } int read_samples_mp3(lame_global_flags * const gfp, FILE * const musicin, short int mpg123pcm[2][1152], int stereo) { int out; #if defined(AMIGA_MPEGA) || defined(HAVE_MPGLIB) static const char type_name[] = "MP3 file"; out = lame_decode_fromfile(musicin, mpg123pcm[0], mpg123pcm[1], &mp3input_data); /* * out < 0: error, probably EOF * out = 0: not possible with lame_decode_fromfile() ??? * out > 0: number of output samples */ if (out < 0) { memset(mpg123pcm, 0, sizeof(**mpg123pcm) * 2 * 1152); return 0; } if ( lame_get_num_channels( gfp ) != mp3input_data.stereo ) fprintf(stderr, "Error: number of channels has changed in %s - not supported\n", type_name); if ( lame_get_in_samplerate( gfp ) != mp3input_data.samplerate ) fprintf(stderr, "Error: sample frequency has changed in %s - not supported\n", type_name); #else out = -1; #endif return out; } static int WriteWaveHeader(FILE * const fp, const int pcmbytes, const int freq, const int channels, const int bits) { int bytes = (bits + 7) / 8; /* quick and dirty, but documented */ fwrite("RIFF", 1, 4, fp); // label Write32BitsLowHigh(fp, pcmbytes + 44 - 8); // length in bytes without header fwrite("WAVEfmt ", 2, 4, fp); // 2 labels Write32BitsLowHigh(fp, 2 + 2 + 4 + 4 + 2 + 2); // length of PCM format declaration area Write16BitsLowHigh(fp, 1); // is PCM? Write16BitsLowHigh(fp, channels); // number of channels Write32BitsLowHigh(fp, freq); // sample frequency in [Hz] Write32BitsLowHigh(fp, freq * channels * bytes); // bytes per second Write16BitsLowHigh(fp, channels * bytes); // bytes per sample time Write16BitsLowHigh(fp, bits); // bits per sample fwrite("data", 1, 4, fp); // label Write32BitsLowHigh(fp, pcmbytes); // length in bytes of raw PCM data return ferror(fp) ? -1 : 0; } /* the simple lame decoder */ /* After calling lame_init(), lame_init_params() and * init_infile(), call this routine to read the input MP3 file * and output .wav data to the specified file pointer*/ /* lame_decoder will ignore the first 528 samples, since these samples * represent the mpglib delay (and are all 0). skip = number of additional * samples to skip, to (for example) compensate for the encoder delay */ int lame_decoder(lame_global_flags * gfp, FILE * outf, int skip, char *inPath, char *outPath) { short int Buffer[2][1152]; int iread; double wavsize; int i; void (*WriteFunction) (FILE * fp, char *p, int n); int tmp_num_channels = lame_get_num_channels( gfp ); fprintf(stderr, "\rinput: %s%s(%g kHz, %i channel%s, ", strcmp(inPath, "-") ? inPath : "<stdin>", strlen(inPath) > 26 ? "\n\t" : " ", lame_get_in_samplerate( gfp ) / 1.e3, tmp_num_channels, tmp_num_channels != 1 ? "s" : ""); switch (input_format) { case sf_mp3: skip += 528 + 1; /* mp3 decoder has a 528 sample delay, plus user supplied "skip" */ fprintf(stderr, "MPEG-%u%s Layer %s", 2 - gfp->version, lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "III"); break; case sf_mp2: skip += 240 + 1; fprintf(stderr, "MPEG-%u%s Layer %s", 2 - gfp->version, lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "II"); break; case sf_mp1: skip += 240 + 1; fprintf(stderr, "MPEG-%u%s Layer %s", 2 - gfp->version, lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "I"); break; case sf_ogg: fprintf(stderr, "Ogg Vorbis"); skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_raw: fprintf(stderr, "raw PCM data"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_wave: fprintf(stderr, "Microsoft WAVE"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_aiff: fprintf(stderr, "SGI/Apple AIFF"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; default: fprintf(stderr, "unknown"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ assert(0); break; } fprintf(stderr, ")\noutput: %s%s(16 bit, Microsoft WAVE)\n", strcmp(outPath, "-") ? outPath : "<stdout>", strlen(outPath) > 45 ? "\n\t" : " "); if (skip > 0) fprintf(stderr, "skipping initial %i samples (encoder+decoder delay)\n", skip); if ( 0 == lame_get_disable_waveheader( gfp ) ) WriteWaveHeader(outf, 0x7FFFFFFF, lame_get_in_samplerate( gfp ), tmp_num_channels, 16); /* unknown size, so write maximum 32 bit signed value */ wavsize = -skip; WriteFunction = swapbytes ? WriteBytesSwapped : WriteBytes; mp3input_data.totalframes = mp3input_data.nsamp / mp3input_data.framesize; assert(tmp_num_channels >= 1 && tmp_num_channels <= 2); do { iread = get_audio(gfp, Buffer); /* read in 'iread' samples */ mp3input_data.framenum += iread / mp3input_data.framesize; wavsize += iread; if (!silent) decoder_progress(gfp, &mp3input_data); skip -= (i = skip < iread ? skip : iread); /* 'i' samples are to skip in this frame */ for (; i < iread; i++) { if ( lame_get_disable_waveheader( gfp ) ) { WriteFunction(outf, (char *) Buffer[0] + i, sizeof(short)); if (tmp_num_channels == 2) WriteFunction(outf, (char *) Buffer[1] + i, sizeof(short)); } else { Write16BitsLowHigh(outf, Buffer[0][i]); if (tmp_num_channels == 2) Write16BitsLowHigh(outf, Buffer[1][i]); } } } while (iread); i = (16 / 8) * tmp_num_channels; assert(i > 0); if (wavsize <= 0) { fprintf(stderr, "WAVE file contains 0 PCM samples\n"); wavsize = 0; } else if (wavsize > 0xFFFFFFD0 / i) { fprintf(stderr, "Very huge WAVE file, can't set filesize accordingly\n"); wavsize = 0xFFFFFFD0; } else { wavsize *= i; } if ( 0 == lame_get_disable_waveheader( gfp ) ) if (!fseek(outf, 0l, SEEK_SET)) /* if outf is seekable, rewind and adjust length */ WriteWaveHeader(outf, wavsize, lame_get_in_samplerate( gfp ), tmp_num_channels, 16); fclose(outf); decoder_progress_finish(gfp); return 0; } #if defined(LIBSNDFILE) #if 0 /* currently disabled */ # include "sndfile.h" // prototype for sf_get_lib_version() void print_sndlib_version(FILE * fp) { char tmp[80]; sf_get_lib_version(tmp, sizeof(tmp)); fprintf(fp, "Input handled by %s (http://www.zip.com.au/~erikd/libsndfile/)\n", tmp); } #endif /* ** Copyright (C) 1999 Albert Faber ** * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ void CloseSndFile(sound_file_format input, FILE * musicin) { SNDFILE *gs_pSndFileIn = (SNDFILE *) musicin; if (input == sf_mp1 || input == sf_mp2 || input == sf_mp3) { #ifndef AMIGA_MPEGA if (fclose(musicin) != 0) { fprintf(stderr, "Could not close audio input file\n"); exit(2); } #endif } else { if (gs_pSndFileIn) { if (sf_close(gs_pSndFileIn) != 0) { fprintf(stderr, "Could not close sound file \n"); exit(2); } } } } FILE * OpenSndFile(lame_global_flags * gfp, char *inPath) { char *lpszFileName = inPath; FILE *musicin; SNDFILE *gs_pSndFileIn; SF_INFO gs_wfInfo; if (input_format == sf_mp1 || input_format == sf_mp2 || input_format == sf_mp3) { #ifdef AMIGA_MPEGA if (-1 == lame_decode_initfile(lpszFileName, &mp3input_data)) { fprintf(stderr, "Error reading headers in mp3 input file %s.\n", lpszFileName); exit(1); } #endif #ifdef HAVE_MPGLIB if ((musicin = fopen(lpszFileName, "rb")) == NULL) { fprintf(stderr, "Could not find \"%s\".\n", lpszFileName); exit(1); } if (-1 == lame_decode_initfile(musicin, &mp3input_data)) { fprintf(stderr, "Error reading headers in mp3 input file %s.\n", lpszFileName); exit(1); } #endif if( -1 == lame_set_num_channels( gfp, mp3input_data.stereo ) ) { fprintf( stderr, "Unsupported number of channels: %ud\n", mp3input_data.stereo ); exit( 1 ); } (void) lame_set_in_samplerate( gfp, mp3input_data.samplerate ); (void) lame_set_num_samples( gfp, mp3input_data.nsamp ); } else if (input_format == sf_ogg) { #ifdef HAVE_VORBIS if ((musicin = fopen(lpszFileName, "rb")) == NULL) { fprintf(stderr, "Could not find \"%s\".\n", lpszFileName); exit(1); } if ( -1 == lame_decode_ogg_initfile( gfp, musicin, &mp3input_data ) ) { fprintf(stderr, "Error reading headers in mp3 input file %s.\n", lpszFileName); exit(1); } #else fprintf(stderr, "mp3enc not compiled with libvorbis support.\n"); exit(1); #endif } else { /* Try to open the sound file */ /* set some defaults incase input is raw PCM */ gs_wfInfo.seekable = (input_format != sf_raw); /* if user specified -r, set to not seekable */ gs_wfInfo.samplerate = lame_get_in_samplerate( gfp ); gs_wfInfo.pcmbitwidth = 16; gs_wfInfo.channels = lame_get_num_channels( gfp ); #ifndef WORDS_BIGENDIAN /* little endian */ if (swapbytes) gs_wfInfo.format = SF_FORMAT_RAW_BE; else gs_wfInfo.format = SF_FORMAT_RAW_LE; #else if (swapbytes) gs_wfInfo.format = SF_FORMAT_RAW_LE; else gs_wfInfo.format = SF_FORMAT_RAW_BE; #endif gs_pSndFileIn = sf_open_read(lpszFileName, &gs_wfInfo); musicin = (SNDFILE *) gs_pSndFileIn; /* Check result */ if (gs_pSndFileIn == NULL) { sf_perror(gs_pSndFileIn); fprintf(stderr, "Could not open sound file \"%s\".\n", lpszFileName); exit(1); } if ((gs_wfInfo.format == SF_FORMAT_RAW_LE) || (gs_wfInfo.format == SF_FORMAT_RAW_BE)) input_format = sf_raw; #ifdef _DEBUG_SND_FILE DEBUGF("\n\nSF_INFO structure\n"); DEBUGF("samplerate :%d\n", gs_wfInfo.samplerate); DEBUGF("samples :%d\n", gs_wfInfo.samples); DEBUGF("channels :%d\n", gs_wfInfo.channels); DEBUGF("pcmbitwidth :%d\n", gs_wfInfo.pcmbitwidth); DEBUGF("format :"); /* new formats from [email protected] 1/2000 */ switch (gs_wfInfo.format & SF_FORMAT_TYPEMASK) { case SF_FORMAT_WAV: DEBUGF("Microsoft WAV format (big endian). "); break; case SF_FORMAT_AIFF: DEBUGF("Apple/SGI AIFF format (little endian). "); break; case SF_FORMAT_AU: DEBUGF("Sun/NeXT AU format (big endian). "); break; case SF_FORMAT_AULE: DEBUGF("DEC AU format (little endian). "); break; case SF_FORMAT_RAW: DEBUGF("RAW PCM data. "); break; case SF_FORMAT_PAF: DEBUGF("Ensoniq PARIS file format. "); break; case SF_FORMAT_SVX: DEBUGF("Amiga IFF / SVX8 / SV16 format. "); break; case SF_FORMAT_NIST: DEBUGF("Sphere NIST format. "); break; default: assert(0); break; } switch (gs_wfInfo.format & SF_FORMAT_SUBMASK) { case SF_FORMAT_PCM: DEBUGF("PCM data in 8, 16, 24 or 32 bits."); break; case SF_FORMAT_FLOAT: DEBUGF("32 bit Intel x86 floats."); break; case SF_FORMAT_ULAW: DEBUGF("U-Law encoded."); break; case SF_FORMAT_ALAW: DEBUGF("A-Law encoded."); break; case SF_FORMAT_IMA_ADPCM: DEBUGF("IMA ADPCM."); break; case SF_FORMAT_MS_ADPCM: DEBUGF("Microsoft ADPCM."); break; case SF_FORMAT_PCM_BE: DEBUGF("Big endian PCM data."); break; case SF_FORMAT_PCM_LE: DEBUGF("Little endian PCM data."); break; case SF_FORMAT_PCM_S8: DEBUGF("Signed 8 bit PCM."); break; case SF_FORMAT_PCM_U8: DEBUGF("Unsigned 8 bit PCM."); break; case SF_FORMAT_SVX_FIB: DEBUGF("SVX Fibonacci Delta encoding."); break; case SF_FORMAT_SVX_EXP: DEBUGF("SVX Exponential Delta encoding."); break; default: assert(0); break; } DEBUGF("\n"); DEBUGF("pcmbitwidth :%d\n", gs_wfInfo.pcmbitwidth); DEBUGF("sections :%d\n", gs_wfInfo.sections); DEBUGF("seekable :\n", gs_wfInfo.seekable); #endif (void) lame_set_num_samples( gfp, gs_wfInfo.samples ); if( -1 == lame_set_num_channels( gfp, gs_wfInfo.channels ) ) { fprintf( stderr, "Unsupported number of channels: %ud\n", gs_wfInfo.channels ); exit( 1 ); } (void) lame_set_in_samplerate( gfp, gs_wfInfo.samplerate ); pcmbitwidth = gs_wfInfo.pcmbitwidth; } if (lame_get_num_samples( gfp ) == MAX_U_32_NUM) { /* try to figure out num_samples */ double flen = lame_get_file_size( lpszFileName ); if (flen >= 0) { /* try file size, assume 2 bytes per sample */ if (input_format == sf_mp1 || input_format == sf_mp2 || input_format == sf_mp3) { double totalseconds = (flen * 8.0 / (1000.0 * mp3input_data.bitrate)); unsigned long tmp_num_samples = totalseconds * lame_get_in_samplerate( gfp ); (void) lame_set_num_samples( gfp, tmp_num_samples ); mp3input_data.nsamp = tmp_num_samples; } else { lame_set_num_samples( gfp, flen / (2 * lame_get_num_channels( gfp )) ); } } } return musicin; } /************************************************************************ * * read_samples() * * PURPOSE: reads the PCM samples from a file to the buffer * * SEMANTICS: * Reads #samples_read# number of shorts from #musicin# filepointer * into #sample_buffer[]#. Returns the number of samples read. * ************************************************************************/ static int read_samples_pcm(FILE * const musicin, short sample_buffer[2304], int frame_size /* unused */ , int samples_to_read) { int i; int samples_read; samples_read = sf_read_short((SNDFILE *) musicin, sample_buffer, samples_to_read); switch (pcmbitwidth) { case 8: for (i = 0; i < samples_read; i++) sample_buffer[i] <<= 8; break; case 16: break; default: fprintf(stderr, "Only 8 and 16 bit input files supported \n"); exit(1); } return samples_read; } #else /* defined(LIBSNDFILE) */ /************************************************************************ ************************************************************************ ************************************************************************ ************************************************************************ ************************************************************************ ************************************************************************ * * OLD ISO/LAME routines follow. Used if you dont have LIBSNDFILE * or for stdin/stdout support * ************************************************************************ ************************************************************************ ************************************************************************ ************************************************************************ ************************************************************************ ************************************************************************/ /************************************************************************ * * read_samples() * * PURPOSE: reads the PCM samples from a file to the buffer * * SEMANTICS: * Reads #samples_read# number of shorts from #musicin# filepointer * into #sample_buffer[]#. Returns the number of samples read. * ************************************************************************/ int read_samples_pcm(FILE * musicin, short sample_buffer[2304], int frame_size, int samples_to_read) { int samples_read; int iswav = (input_format == sf_wave); if (16 == pcmbitwidth) { samples_read = fread(sample_buffer, 2, samples_to_read, musicin); } else if (8 == pcmbitwidth) { char temp[2304]; int i; samples_read = fread(temp, 1, samples_to_read, musicin); for (i = 0; i < samples_read; ++i) { /* note: 8bit .wav samples are unsigned */ /* map [0,255] -> [-32768,32767] */ sample_buffer[i] = ((short int)temp[i] - 128)*256 + 127; } } else { fprintf(stderr, "Only 8 and 16 bit input files supported \n"); exit(1); } if (ferror(musicin)) { fprintf(stderr, "Error reading input file\n"); exit(1); } if (16 == pcmbitwidth) { /* intel=littleEndian. wav files are always little endian */ #ifndef WORDS_BIGENDIAN /* little endian */ if (!iswav) SwapBytesInWords(sample_buffer, samples_read); #else /* big endian */ if (iswav) SwapBytesInWords(sample_buffer, samples_read); #endif if (swapbytes) SwapBytesInWords(sample_buffer, samples_read); } return samples_read; } /* AIFF Definitions */ #define IFF_ID_FORM 0x464f524d /* "FORM" */ #define IFF_ID_AIFF 0x41494646 /* "AIFF" */ #define IFF_ID_COMM 0x434f4d4d /* "COMM" */ #define IFF_ID_SSND 0x53534e44 /* "SSND" */ #define IFF_ID_MPEG 0x4d504547 /* "MPEG" */ #define WAV_ID_RIFF 0x52494646 /* "RIFF" */ #define WAV_ID_WAVE 0x57415645 /* "WAVE" */ #define WAV_ID_FMT 0x666d7420 /* "fmt " */ #define WAV_ID_DATA 0x64617461 /* "data" */ /***************************************************************************** * * Read Microsoft Wave headers * * By the time we get here the first 32-bits of the file have already been * read, and we're pretty sure that we're looking at a WAV file. * *****************************************************************************/ static int parse_wave_header(lame_global_flags * gfp, FILE * sf) { int format_tag = 0; int channels = 0; int block_align = 0; int bits_per_sample = 0; int samples_per_sec = 0; int avg_bytes_per_sec = 0; int is_wav = 0; long data_length = 0, file_length, subSize = 0; int loop_sanity = 0; file_length = Read32BitsHighLow(sf); if (Read32BitsHighLow(sf) != WAV_ID_WAVE) return 0; for (loop_sanity = 0; loop_sanity < 20; ++loop_sanity) { int type = Read32BitsHighLow(sf); if (type == WAV_ID_FMT) { subSize = Read32BitsLowHigh(sf); if (subSize < 16) { /*DEBUGF( "'fmt' chunk too short (only %ld bytes)!", subSize); */ return 0; } format_tag = Read16BitsLowHigh(sf); subSize -= 2; channels = Read16BitsLowHigh(sf); subSize -= 2; samples_per_sec = Read32BitsLowHigh(sf); subSize -= 4; avg_bytes_per_sec = Read32BitsLowHigh(sf); subSize -= 4; block_align = Read16BitsLowHigh(sf); subSize -= 2; bits_per_sample = Read16BitsLowHigh(sf); subSize -= 2; /* DEBUGF(" skipping %d bytes\n", subSize); */ if (subSize > 0) { if (fskip(sf, (long) subSize, SEEK_CUR) != 0) return 0; }; } else if (type == WAV_ID_DATA) { subSize = Read32BitsLowHigh(sf); data_length = subSize; is_wav = 1; /* We've found the audio data. Read no further! */ break; } else { subSize = Read32BitsLowHigh(sf); if (fskip(sf, (long) subSize, SEEK_CUR) != 0) return 0; } } if (format_tag != 1) { return 0; /* oh no! non-supported format */ } if (is_wav) { /* make sure the header is sane */ if( -1 == lame_set_num_channels( gfp, channels ) ) { fprintf( stderr, "Unsupported number of channels: %ud\n", channels ); exit( 1 ); } (void) lame_set_in_samplerate( gfp, samples_per_sec ); pcmbitwidth = bits_per_sample; (void) lame_set_num_samples( gfp, data_length / (channels * ((bits_per_sample+7) / 8)) ); } return is_wav; } /************************************************************************ * aiff_check2 * * PURPOSE: Checks AIFF header information to make sure it is valid. * returns 0 on success, 1 on errors ************************************************************************/ int aiff_check2(const char *file_name, IFF_AIFF * const pcm_aiff_data) { if (pcm_aiff_data->sampleType != IFF_ID_SSND) { fprintf(stderr, "Sound data is not PCM in '%s'\n", file_name); return 1; } if (pcm_aiff_data->sampleSize != sizeof(short) * CHAR_BIT) { fprintf(stderr, "Sound data is not %i bits in '%s'\n", sizeof(short) * CHAR_BIT, file_name); return 1; } if (pcm_aiff_data->numChannels != 1 && pcm_aiff_data->numChannels != 2) { fprintf(stderr, "Sound data is not mono or stereo in '%s'\n", file_name); return 1; } if (pcm_aiff_data->blkAlgn.blockSize != 0) { fprintf(stderr, "Block size is not 0 bytes in '%s'\n", file_name); return 1; } if (pcm_aiff_data->blkAlgn.offset != 0) { fprintf(stderr, "Block offset is not 0 bytes in '%s'\n", file_name); return 1; } return 0; } /***************************************************************************** * * Read Audio Interchange File Format (AIFF) headers. * * By the time we get here the first 32 bits of the file have already been * read, and we're pretty sure that we're looking at an AIFF file. * *****************************************************************************/ static int parse_aiff_header(lame_global_flags * gfp, FILE * sf) { int is_aiff = 0; long chunkSize = 0, subSize = 0; IFF_AIFF aiff_info; memset(&aiff_info, 0, sizeof(aiff_info)); chunkSize = Read32BitsHighLow(sf); if (Read32BitsHighLow(sf) != IFF_ID_AIFF) return 0; while (chunkSize > 0) { int type = Read32BitsHighLow(sf); chunkSize -= 4; /* DEBUGF( "found chunk type %08x '%4.4s'\n", type, (char*)&type); */ /* don't use a switch here to make it easier to use 'break' for SSND */ if (type == IFF_ID_COMM) { subSize = Read32BitsHighLow(sf); chunkSize -= subSize; aiff_info.numChannels = Read16BitsHighLow(sf); subSize -= 2; aiff_info.numSampleFrames = Read32BitsHighLow(sf); subSize -= 4; aiff_info.sampleSize = Read16BitsHighLow(sf); subSize -= 2; aiff_info.sampleRate = ReadIeeeExtendedHighLow(sf); subSize -= 10; if (fskip(sf, (long) subSize, SEEK_CUR) != 0) return 0; } else if (type == IFF_ID_SSND) { subSize = Read32BitsHighLow(sf); chunkSize -= subSize; aiff_info.blkAlgn.offset = Read32BitsHighLow(sf); subSize -= 4; aiff_info.blkAlgn.blockSize = Read32BitsHighLow(sf); subSize -= 4; if (fskip(sf, (long) aiff_info.blkAlgn.offset, SEEK_CUR) != 0) return 0; aiff_info.sampleType = IFF_ID_SSND; is_aiff = 1; /* We've found the audio data. Read no further! */ break; } else { subSize = Read32BitsHighLow(sf); chunkSize -= subSize; if (fskip(sf, (long) subSize, SEEK_CUR) != 0) return 0; } } /* DEBUGF("Parsed AIFF %d\n", is_aiff); */ if (is_aiff) { /* make sure the header is sane */ if (0 != aiff_check2("name" /*???????????? */ , &aiff_info)) return 0; if( -1 == lame_set_num_channels( gfp, aiff_info.numChannels ) ) { fprintf( stderr, "Unsupported number of channels: %ud\n", aiff_info.numChannels ); exit( 1 ); } (void) lame_set_in_samplerate( gfp, aiff_info.sampleRate ); pcmbitwidth = aiff_info.sampleSize; (void) lame_set_num_samples( gfp, aiff_info.numSampleFrames ); } return is_aiff; } /************************************************************************ * * parse_file_header * * PURPOSE: Read the header from a bytestream. Try to determine whether * it's a WAV file or AIFF without rewinding, since rewind * doesn't work on pipes and there's a good chance we're reading * from stdin (otherwise we'd probably be using libsndfile). * * When this function returns, the file offset will be positioned at the * beginning of the sound data. * ************************************************************************/ void parse_file_header(lame_global_flags * gfp, FILE * sf) { int type = Read32BitsHighLow(sf); /* DEBUGF( "First word of input stream: %08x '%4.4s'\n", type, (char*) &type); */ count_samples_carefully = 0; input_format = sf_raw; if (type == WAV_ID_RIFF) { /* It's probably a WAV file */ if (parse_wave_header(gfp, sf)) { input_format = sf_wave; count_samples_carefully = 1; } else { fprintf( stderr, "Warning: corrupt or unsupported WAVE format\n"); } } else if (type == IFF_ID_FORM) { /* It's probably an AIFF file */ if (parse_aiff_header(gfp, sf)) { input_format = sf_aiff; count_samples_carefully = 1; } } if (input_format == sf_raw) { /* ** Assume it's raw PCM. Since the audio data is assumed to begin ** at byte zero, this will unfortunately require seeking. */ if (fseek(sf, 0L, SEEK_SET) != 0) { /* ignore errors */ } input_format = sf_raw; } } void CloseSndFile(sound_file_format input, FILE * musicin) { if (fclose(musicin) != 0) { fprintf(stderr, "Could not close audio input file\n"); exit(2); } } FILE * OpenSndFile(lame_global_flags * gfp, char *inPath) { FILE *musicin; /* set the defaults from info incase we cannot determine them from file */ lame_set_num_samples( gfp, MAX_U_32_NUM ); if (!strcmp(inPath, "-")) { lame_set_stream_binary_mode(musicin = stdin); /* Read from standard input. */ } else { if ((musicin = fopen(inPath, "rb")) == NULL) { fprintf(stderr, "Could not find \"%s\".\n", inPath); exit(1); } } if (input_format == sf_mp1 || input_format == sf_mp2 || input_format == sf_mp3) { #ifdef AMIGA_MPEGA if (-1 == lame_decode_initfile(inPath, &mp3input_data)) { fprintf(stderr, "Error reading headers in mp3 input file %s.\n", inPath); exit(1); } #endif #ifdef HAVE_MPGLIB if (-1 == lame_decode_initfile(musicin, &mp3input_data)) { fprintf(stderr, "Error reading headers in mp3 input file %s.\n", inPath); exit(1); } #endif if( -1 == lame_set_num_channels( gfp, mp3input_data.stereo ) ) { fprintf( stderr, "Unsupported number of channels: %ud\n", mp3input_data.stereo ); exit( 1 ); } (void) lame_set_in_samplerate( gfp, mp3input_data.samplerate ); (void) lame_set_num_samples( gfp, mp3input_data.nsamp ); } else if (input_format == sf_ogg) { #ifdef HAVE_VORBIS if ( -1 == lame_decode_ogg_initfile( gfp, musicin, &mp3input_data ) ) { fprintf(stderr, "Error reading headers in ogg input file %s.\n", inPath); exit(1); } if( -1 == lame_set_num_channels( gfp, mp3input_data.stereo ) ) { fprintf( stderr, "Unsupported number of channels: %ud\n", mp3input_data.stereo ); exit( 1 ); } (void) lame_set_in_samplerate( gfp, mp3input_data.samplerate ); (void) lame_set_num_samples( gfp, mp3input_data.nsamp ); #else fprintf(stderr, "mp3enc not compiled with libvorbis support.\n"); exit(1); #endif } else { if (input_format != sf_raw) { parse_file_header(gfp, musicin); } if (0 && input_format == sf_raw) { fprintf(stderr, "Assuming raw pcm input file"); if (swapbytes) fprintf(stderr, " : Forcing byte-swapping\n"); else fprintf(stderr, "\n"); } } if (lame_get_num_samples( gfp ) == MAX_U_32_NUM && musicin != stdin) { double flen = lame_get_file_size(inPath); /* try to figure out num_samples */ if (flen >= 0) { /* try file size, assume 2 bytes per sample */ if (input_format == sf_mp1 || input_format == sf_mp2 || input_format == sf_mp3) { if (mp3input_data.bitrate > 0) { double totalseconds = (flen * 8.0 / (1000.0 * mp3input_data.bitrate)); unsigned long tmp_num_samples = totalseconds * lame_get_in_samplerate( gfp ); (void) lame_set_num_samples( gfp, tmp_num_samples ); mp3input_data.nsamp = tmp_num_samples; } } else { (void) lame_set_num_samples( gfp, flen / (2 * lame_get_num_channels( gfp )) ); } } } return musicin; } #endif /* defined(LIBSNDFILE) */ #if defined(HAVE_MPGLIB) static int check_aid(const unsigned char *header) { return 0 == strncmp(header, "AiD\1", 4); } /* * Please check this and don't kill me if there's a bug * This is a (nearly?) complete header analysis for a MPEG-1/2/2.5 Layer I, II or III * data stream */ static int is_syncword_mp123(const void *const headerptr) { const unsigned char *const p = headerptr; static const char abl2[16] = { 0, 7, 7, 7, 0, 7, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8 }; if ((p[0] & 0xFF) != 0xFF) return 0; // first 8 bits must be '1' if ((p[1] & 0xE0) != 0xE0) return 0; // next 3 bits are also if ((p[1] & 0x18) == 0x08) return 0; // no MPEG-1, -2 or -2.5 if ((p[1] & 0x06) == 0x00) return 0; // no Layer I, II and III if ((p[2] & 0xF0) == 0xF0) return 0; // bad bitrate if ((p[2] & 0x0C) == 0x0C) return 0; // no sample frequency with (32,44.1,48)/(1,2,4) if ((p[1] & 0x06) == 0x04) // illegal Layer II bitrate/Channel Mode comb if (abl2[p[2] >> 4] & (1 << (p[3] >> 6))) return 0; return 1; } static int is_syncword_mp3(const void *const headerptr) { const unsigned char *const p = headerptr; if ((p[0] & 0xFF) != 0xFF) return 0; // first 8 bits must be '1' if ((p[1] & 0xE0) != 0xE0) return 0; // next 3 bits are also if ((p[1] & 0x18) == 0x08) return 0; // no MPEG-1, -2 or -2.5 if ((p[1] & 0x06) != 0x02) return 0; // no Layer III (can be merged with 'next 3 bits are also' test, but don't do this, this decreases readability) if ((p[2] & 0xF0) == 0xF0) return 0; // bad bitrate if ((p[2] & 0x0C) == 0x0C) return 0; // no sample frequency with (32,44.1,48)/(1,2,4) return 1; } int lame_decode_initfile(FILE * fd, mp3data_struct * mp3data) { // VBRTAGDATA pTagData; // int xing_header,len2,num_frames; unsigned char buf[100]; int ret; int len, aid_header; short int pcm_l[1152], pcm_r[1152]; memset(mp3data, 0, sizeof(mp3data_struct)); lame_decode_init(); len = 4; if (fread(&buf, 1, len, fd) != len) return -1; /* failed */ aid_header = check_aid(buf); if (aid_header) { if (fread(&buf, 1, 2, fd) != 2) return -1; /* failed */ aid_header = (unsigned char) buf[0] + 256 * (unsigned char) buf[1]; fprintf(stderr, "Album ID found. length=%i \n", aid_header); /* skip rest of AID, except for 6 bytes we have already read */ fskip(fd, aid_header - 6, SEEK_CUR); /* read 4 more bytes to set up buffer for MP3 header check */ len = fread(&buf, 1, 4, fd); } /* look for valid 4 byte MPEG header */ if (len < 4) return -1; while (!is_syncword_mp123(buf)) { int i; for (i = 0; i < len - 1; i++) buf[i] = buf[i + 1]; if (fread(buf + len - 1, 1, 1, fd) != 1) return -1; /* failed */ } #if 0 /* buffer 48 bytes so we can check for Xing header */ len2 = fread(&buf[len], 1, 48 - len, fd); if (len2 != 48 - len) return -1; len = 48; /* check first 48 bytes for Xing header */ xing_header = GetVbrTag(&pTagData, (unsigned char *) buf); if (xing_header && pTagData.headersize >= 48) { num_frames = pTagData.frames; fprintf(stderr, "\rXing VBR header dectected. MP3 file has %i frames\n", num_frames); // skip the rest of the Xing header. LAME decoder ignores TOC data fskip(fd, pTagData.headersize - 48, SEEK_CUR); // buffer a few more bytes for next header check: len = fread(buf, 1, 4, fd); } else { /* we have read 48 bytes, but did not find a Xing header */ /* lets try and rewind the stream: */ if (fseek(fd, -44, SEEK_CUR) != 0) { /* backwards fseek failed. input is probably a pipe */ /* keep 'len' unchanged */ } else { len -= 44; } } #endif // now parse the current buffer looking for MP3 headers // we dont want to feed too much data to lame_decode1_headers - // we dont want it to actually decode the first frame // (as of 11/00: mpglib modified so that for the first frame where // headers are parsed, no data will be decoded. So the above is // now a moot point. ret = lame_decode1_headers(buf, len, pcm_l, pcm_r, mp3data); if (-1 == ret) return -1; /* repeat until we decode a valid mp3 header */ while (!mp3data->header_parsed) { len = fread(buf, 1, sizeof(buf), fd); if (len != sizeof(buf)) return -1; ret = lame_decode1_headers(buf, len, pcm_l, pcm_r, mp3data); if (-1 == ret) return -1; } #if 1 if (mp3data->totalframes > 0) { /* mpglib found a Xing VBR header and computed nsamp & totalframes */ } else { mp3data->nsamp = MAX_U_32_NUM; } #else mp3data->nsamp = MAX_U_32_NUM; if (xing_header && num_frames) { mp3data->nsamp = mp3data->framesize * num_frames; } #endif /* fprintf(stderr,"ret = %i NEED_MORE=%i \n",ret,MP3_NEED_MORE); fprintf(stderr,"stereo = %i \n",mp.fr.stereo); fprintf(stderr,"samp = %i \n",freqs[mp.fr.sampling_frequency]); fprintf(stderr,"framesize = %i \n",framesize); fprintf(stderr,"bitrate = %i \n",mp3data->bitrate); fprintf(stderr,"num frames = %ui \n",num_frames); fprintf(stderr,"num samp = %ui \n",mp3data->nsamp); fprintf(stderr,"mode = %i \n",mp.fr.mode); */ return 0; } /* For lame_decode_fromfile: return code -1 error 0 ok, but need more data before outputing any samples n number of samples output. either 576 or 1152 depending on MP3 file. */ int lame_decode_fromfile(FILE * fd, short pcm_l[], short pcm_r[], mp3data_struct * mp3data) { int ret = 0, len; unsigned char buf[100]; /* read until we get a valid output frame */ while (0 == ret) { len = fread(buf, 1, 100, fd); if (len != 100) return -1; ret = lame_decode1_headers(buf, len, pcm_l, pcm_r, mp3data); if (ret == -1) return -1; } return ret; } #endif /* defined(HAVE_MPGLIB) */ /* end of get_audio.c */