pcm2aiff.c

ISO mp3 sources (distribution 10) Layer 1/2/3, C Source, 512 k Sources of the Mpeg 1,2 layer 1,2

/**********************************************************************
 * ISO MPEG Audio Subgroup Software Simulation Group (1996)
 * Audio Interchange File Format (AIFF) / PCM file conversion.
 *
 * $Id: pcm2aiff.c,v 1.2 1996/04/18 06:15:42 rowlands Exp $
 *
 * $Log: pcm2aiff.c,v $
 * Revision 1.2  1996/04/18 06:15:42  rowlands
 * Added multilingual file name format facility.
 *
 * Revision 1.1  1996/04/18 03:39:59  rowlands
 * Initial revision
 *
 * Revision 1.0  1995/06/13  fukuchi
 * UNIX version.
 *
 * Revision 1.1  1995/10/03  09:35:00 fukuchi 
 * Ported new code for MSDOS .
 *
 **********************************************************************/

/**********************************************************************
 * VERSION 1.1                                                        *
 *   changes made since last update:                                  *
 *   date   programmers                comment                        *
 * 6/13/95  Hiroyuki Fukuchi    start of version 1.0 records          *
 * 10/03/95  Hiroyuki Fukuchi   Ported new code for MSDOS.            *
 **********************************************************************/

/***********************************************************************
*
*  Global Include Files
*
***********************************************************************/
#include        "common.h"
#include        "decoder.h"

/***************************************************************************/

#define	MaxNumberOfChannels	7

char *	multichannelPCMFilenameSuffix[] = {
	"l", "r", "c", "ls", "rs", NULL
};
char *	multilingualPCMFilenameSuffix[] = {
	"m1", "m2", "m3", "m4", "m5", "m6", "m7", NULL
};
char **	pcmFilenameSuffix	= multichannelPCMFilenameSuffix;

#ifdef __MSDOS__
char *	multichannelAIFFFilenameSuffix = ".aif";
char *	multilingualAIFFFilenameSuffix = ".aif";
char *	aiffFilenameSuffix	= ".aif";
#else
char *	multichannelAIFFFilenameSuffix = ".aiff";
char *	multilingualAIFFFilenameSuffix = ".aiff.ml";
char *	aiffFilenameSuffix	= ".aiff";
#endif

/***************************************************************************/

main(int argc, char *argv[])
{
char    file_name[50];
int     i,j,c,disp,arg_count,config,aiff_mode;
IFF_AIFF        aiff,*aiff_ptr;
void    exit();
int     pcm2aiff(),aiff2pcm();        

	aiff_ptr=&aiff;
	if(argc==1){
	    printf("usage : pcm2aiff <input file> [-a],[-c[nx]],[-r[nx]],[-m]\n");
	    printf("            pcm <-> aiff file conversion\n");
	    printf("         [option]\n");
	    printf("        a : aiff->pcm (default: pcm->aiff)\n");
	    printf("        c[nx]: channel configuration for pcm->aiff\n");
	    printf("            nx (default: 1)\n");
	    printf("            0: L \n");
	    printf("            1: L R\n"); 
	    printf("            2: L R C\n");
	    printf("            3: L R C LS\n");
	    printf("            4: L R C LS RS\n");
	    printf("        m : multilingual filename format (default multichannel)\n");
	    printf("        r[nx]: sampling frequency\n");
	    printf("            nx (default: 0)\n");
	    printf("            0: 44.1 kHz \n");
	    printf("            1: 48 kHz\n"); 
	    printf("            2: 32 KHz\n");
	    printf("        L  ch file is <[input file]_l.pcm>\n");
	    printf("        R  ch file is <[input file]_r.pcm>\n");
	    printf("        LS ch file is <[input file]_ls.pcm>\n");
	    printf("        RS ch file is <[input file]_rs.pcm>\n");
	    printf("        C  ch file is <[input file]_c.pcm>\n");
	    printf("        aiff  file is <[input file].aiff> or <[input file].aiff.ml>\n");
	    exit();
	}
	for(i=0;i<50;i++)
	    file_name[i]=0;
	i=0;
	file_name[i]=(*++argv)[0];
	i++;
	while(file_name[i]=*++argv[0])
	    i++;

	config=1;
	aiff_mode=0;
	arg_count=argc;
	aiff_ptr->sampleRate=44100.00;
	while(arg_count>=3){
	    arg_count--;
	    if((*++argv)[0]=='-'){
		while(c=*++argv[0]){
		    switch(c){
		    case        'r':
			c=*++argv[0];
			switch(c){
			case    '0':
			    aiff_ptr->sampleRate=44100.00;
			    break;
			case    '1':
			    aiff_ptr->sampleRate=48000.00;
			    break;
			case    '2':
			    aiff_ptr->sampleRate=32000.00;
			    break;
			default :
			    aiff_ptr->sampleRate=44100.00;
			    break;
			};
			break;
		    case	'm':
			pcmFilenameSuffix = multilingualPCMFilenameSuffix;
			aiffFilenameSuffix = multilingualAIFFFilenameSuffix;
			break;
		    case        'c':
			config=*++argv[0]-'0';
			break;
		    case        'a':
			aiff_mode=1;
			break;
		    default:
			printf("	????\n");
			exit();
		    }
		}
	    }
	}
	if(aiff_mode){
	    aiff2pcm(file_name,aiff_ptr);
	}else{
	    pcm2aiff(file_name,aiff_ptr,config);
	}
};

/**********************************************************************
*
*  PCM to Audio Interchange File Format(AIFF) conversion.
*
**********************************************************************/

int pcm2aiff(char *fname,IFF_AIFF *aiff_ptr,int config)
{
register char   i;
register long   seek_offset;
int             index,lflag,rflag,cflag,lsflag,rsflag;
int             size;
int             BUF_SIZE=384;
unsigned long   frame;
char            temp_sampleRate[10];
static char     tmp_file_name[200];
char            holder;
FILE            *file_ptr_pcm[MaxNumberOfChannels];
FILE            *file_ptr_aiff;
static char     buf[MaxNumberOfChannels][1152*2];
char            buf0[2]={0,0};
Chunk           FormChunk;
CommonChunk     CommChunk;
SoundDataChunk  SndDChunk;
void            exit();

#ifdef __MSDOS__
long            lholder;
void            swab();
#endif

	printf("        pcm to aiff conversion\n");
	aiff_ptr->numChannels = config + 1;

	for (i = 0; i < aiff_ptr->numChannels; i++) {
	    sprintf(tmp_file_name, "%s_%s.pcm", fname, pcmFilenameSuffix[i]);
	    if(NULL==(file_ptr_pcm[i]=fopen(tmp_file_name,"rb"))){
		printf("        read file open error\n");
		exit(1);
	    }
	}

	strcpy( tmp_file_name,fname); 
	strcat( tmp_file_name,aiffFilenameSuffix); 
	if(NULL==(file_ptr_aiff=fopen(tmp_file_name,"wb"))){
		printf("        write file open error\n");
		exit();
	}

	aiff_ptr->sampleSize=16;
	aiff_ptr->blkAlgn.offset=0;
	aiff_ptr->blkAlgn.blockSize=0;
	strcpy(aiff_ptr->sampleType,IFF_ID_SSND);
	
	double_to_extended(&aiff_ptr->sampleRate, temp_sampleRate);
	
	strcpy( FormChunk.ckID, IFF_ID_FORM);
	strcpy( FormChunk.formType, IFF_ID_AIFF);
	strcpy( CommChunk.ckID, IFF_ID_COMM); 

	for (i = 0; i < sizeof(char[10]); i++)
	    CommChunk.sampleRate[i] = temp_sampleRate[i];

	CommChunk.numChannels             = aiff_ptr->numChannels;
	CommChunk.sampleSize              = aiff_ptr->sampleSize;
	SndDChunk.offset                  = aiff_ptr->blkAlgn.offset;
	SndDChunk.blockSize               = aiff_ptr->blkAlgn.blockSize;
	strncpy( SndDChunk.ckID, aiff_ptr->sampleType,4);
	CommChunk.ckSize = sizeof(CommChunk.numChannels) +
	sizeof(CommChunk.numSampleFrames)+sizeof(CommChunk.sampleSize)+
	sizeof(CommChunk.sampleRate);

	SndDChunk.ckSize = sizeof(SoundDataChunk)-sizeof(ChunkHeader)+
	(CommChunk.sampleSize + BITS_IN_A_BYTE - 1) / BITS_IN_A_BYTE *
	CommChunk.numChannels * CommChunk.numSampleFrames;

	FormChunk.ckSize=sizeof(Chunk)+SndDChunk.ckSize+sizeof(ChunkHeader)+
	    CommChunk.ckSize;


	if(fwrite(&FormChunk, sizeof(Chunk), 1, file_ptr_aiff) != 1)
	    return(-1);

	if(fwrite(CommChunk.ckID, sizeof(ID),1,file_ptr_aiff) != 1)
	    return(-1);

	if(fwrite(&CommChunk.ckSize,sizeof(long),1,file_ptr_aiff)!=1)
	    return(-1);

	if(fwrite(&CommChunk.numChannels,sizeof(short),1,file_ptr_aiff)!=1)
	    return(-1);

	if(fwrite(&CommChunk.numSampleFrames,sizeof(unsigned long),1,
	      file_ptr_aiff) != 1)
	    return(-1);

	if(fwrite(&CommChunk.sampleSize,sizeof(short),1,file_ptr_aiff)!=1)
	    return(-1);
	if(fwrite(CommChunk.sampleRate,sizeof(char[10]),1,file_ptr_aiff)!=1)
	    return(-1);

	if(fwrite(&SndDChunk,sizeof(SoundDataChunk),1,file_ptr_aiff)!=1)
	    return(-1);

	frame=0;
	while(1){
	    for (i = 0; i < aiff_ptr->numChannels; i++) {
		    size=fread(&buf[i],2,BUF_SIZE,file_ptr_pcm[i]);
		    if(size==0) break;
	    }

	    for(index=0;index<size;index++){
		for (i = 0; i < aiff_ptr->numChannels; i++) {
			fwrite(&buf[i][2*index],2,1,file_ptr_aiff);
		}
	    }
	    frame++;
	    if(size<BUF_SIZE){
		for(index=size;index<BUF_SIZE;index++){
		    for (i = 0; i < aiff_ptr->numChannels; i++) {
			fwrite(&buf0[i],2,1,file_ptr_aiff);
		    }
		}
		break;
	    }
	}
	printf("        number of samples in frame / channel = %ld\n",BUF_SIZE*frame-size);

	aiff_ptr->numSampleFrames=BUF_SIZE*frame;
	CommChunk.numSampleFrames         = aiff_ptr->numSampleFrames;
	CommChunk.ckSize = sizeof(CommChunk.numChannels)+
	sizeof(CommChunk.numSampleFrames)+sizeof(CommChunk.sampleSize)+
	sizeof(CommChunk.sampleRate);
	SndDChunk.ckSize =sizeof(SoundDataChunk)-sizeof(ChunkHeader)+
	(CommChunk.sampleSize + BITS_IN_A_BYTE - 1) / BITS_IN_A_BYTE *
	CommChunk.numChannels * CommChunk.numSampleFrames;
	FormChunk.ckSize = sizeof(Chunk)+SndDChunk.ckSize+sizeof(ChunkHeader)+
	    CommChunk.ckSize;


	if (fseek(file_ptr_aiff, 0, SEEK_SET) != 0)
	    return(-1);

#ifdef __MSDOS__
	lholder=FormChunk.ckSize;
	swab(&lholder,&FormChunk.ckSize,4);
	lholder=FormChunk.ckSize&0xffff;
	FormChunk.ckSize=(((FormChunk.ckSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
#endif

	if (fwrite(&FormChunk, sizeof(Chunk), 1, file_ptr_aiff) != 1)
	    return(-1);

#ifdef __MSDOS__
	lholder=CommChunk.ckSize;
	swab(&lholder,&CommChunk.ckSize,4);
	lholder=CommChunk.ckSize&0xffff;
	CommChunk.ckSize=(((CommChunk.ckSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
	
	lholder=CommChunk.sampleSize;
	swab(&lholder,&CommChunk.sampleSize,2);
	lholder=CommChunk.numChannels;
	swab(&lholder,&CommChunk.numChannels,2);
	
	lholder=CommChunk.numSampleFrames;
	swab(&lholder,&CommChunk.numSampleFrames,4);
	lholder=CommChunk.numSampleFrames&0xffff;
	CommChunk.numSampleFrames=(((CommChunk.numSampleFrames>>16)&0xffff)+(lholder<<16))&0xffffffff;
#endif

	if (fwrite(CommChunk.ckID,sizeof(ID),1,file_ptr_aiff)!=1)
	    return(-1);
	if (fwrite(&CommChunk.ckSize,sizeof(long),1,file_ptr_aiff)!=1)
	    return(-1);
	if (fwrite(&CommChunk.numChannels,sizeof(short),1,file_ptr_aiff)!=1)
	    return(-1);
	if (fwrite(&CommChunk.numSampleFrames,sizeof(unsigned long),1,
	      file_ptr_aiff)!=1)
	    return(-1);
	if (fwrite(&CommChunk.sampleSize, sizeof(short),1,file_ptr_aiff)!=1)
	    return(-1);
	if (fwrite(CommChunk.sampleRate,sizeof(char[10]),1,file_ptr_aiff)!=1)
	    return(-1);

#ifdef __MSDOS__
	lholder=SndDChunk.ckSize;
	swab(&lholder,&SndDChunk.ckSize,4);
	lholder=SndDChunk.ckSize&0xffff;
	SndDChunk.ckSize=(((SndDChunk.ckSize>>16)&0xffff)+(lholder<<16))&0xffffffff;

	lholder=SndDChunk.blockSize;
	swab(&lholder,&SndDChunk.blockSize,4);
	lholder=SndDChunk.blockSize&0xffff;
	SndDChunk.blockSize=(((SndDChunk.blockSize>>16)&0xffff)+(lholder<<16))&0xffffffff;

	lholder=SndDChunk.offset;
	swab(&lholder,&SndDChunk.offset,4);
	lholder=SndDChunk.offset&0xffff;
	SndDChunk.offset=(((SndDChunk.offset>>16)&0xffff)+(lholder<<16))&0xffffffff;
#endif

	if(fwrite(&SndDChunk,sizeof(SoundDataChunk),1,file_ptr_aiff)!=1)
	    return(-1);

	for (i = 0; i < aiff_ptr->numChannels; i++) {
		fclose(file_ptr_pcm[i]);
	}
	fclose(file_ptr_aiff);