开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
PCM2AIFF.C
资源名称：mpeg.zip　[点击查看]
上传用户：njqiyou
上传日期：2007-01-08
资源大小：574k
文件大小：21k
源码类别：

mpeg/mp3

开发平台：

C/C++

PCM2AIFF.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * Audio Interchange File Format (AIFF) / PCM file conversion.
  4.  *
  5.  * $Id: pcm2aiff.c,v 1.2 1996/04/18 06:15:42 rowlands Exp $
  6.  *
  7.  * $Log: pcm2aiff.c,v $
  8.  * Revision 1.2  1996/04/18 06:15:42  rowlands
  9.  * Added multilingual file name format facility.
  10.  *
  11.  * Revision 1.1  1996/04/18 03:39:59  rowlands
  12.  * Initial revision
  13.  *
  14.  * Revision 1.0  1995/06/13  fukuchi
  15.  * UNIX version.
  16.  *
  17.  * Revision 1.1  1995/10/03  09:35:00 fukuchi 
  18.  * Ported new code for MSDOS .
  19.  *
  20.  **********************************************************************/
  22. /**********************************************************************
  23.  * VERSION 1.1                                                        *
  24.  *   changes made since last update:                                  *
  25.  *   date   programmers                comment                        *
  26.  * 6/13/95  Hiroyuki Fukuchi    start of version 1.0 records          *
  27.  * 10/03/95  Hiroyuki Fukuchi   Ported new code for MSDOS.            *
  28.  **********************************************************************/
  30. /***********************************************************************
  31. *
  32. *  Global Include Files
  33. *
  34. ***********************************************************************/
  35. #include        "common.h"
  36. #include        "decoder.h"
  38. /***************************************************************************/
  40. #define MaxNumberOfChannels 7
  42. char * multichannelPCMFilenameSuffix[] = {
  43. "l", "r", "c", "ls", "rs", NULL
  44. };
  45. char * multilingualPCMFilenameSuffix[] = {
  46. "m1", "m2", "m3", "m4", "m5", "m6", "m7", NULL
  47. };
  48. char ** pcmFilenameSuffix = multichannelPCMFilenameSuffix;
  50. #ifdef __MSDOS__
  51. char * multichannelAIFFFilenameSuffix = ".aif";
  52. char * multilingualAIFFFilenameSuffix = ".aif";
  53. char * aiffFilenameSuffix = ".aif";
  54. #else
  55. char * multichannelAIFFFilenameSuffix = ".aiff";
  56. char * multilingualAIFFFilenameSuffix = ".aiff.ml";
  57. char * aiffFilenameSuffix = ".aiff";
  58. #endif
  60. /***************************************************************************/
  62. main(int argc, char *argv[])
  63. {
  64. char    file_name[50];
  65. int     i,j,c,disp,arg_count,config,aiff_mode;
  66. IFF_AIFF        aiff,*aiff_ptr;
  67. void    exit();
  68. int     pcm2aiff(),aiff2pcm();        
  70. aiff_ptr=&aiff;
  71. if(argc==1){
  72.     printf("usage : pcm2aiff <input file> [-a],[-c[nx]],[-r[nx]],[-m]n");
  73.     printf("            pcm <-> aiff file conversionn");
  74.     printf("         [option]n");
  75.     printf("        a : aiff->pcm (default: pcm->aiff)n");
  76.     printf("        c[nx]: channel configuration for pcm->aiffn");
  77.     printf("            nx (default: 1)n");
  78.     printf("            0: L n");
  79.     printf("            1: L Rn"); 
  80.     printf("            2: L R Cn");
  81.     printf("            3: L R C LSn");
  82.     printf("            4: L R C LS RSn");
  83.     printf("        m : multilingual filename format (default multichannel)n");
  84.     printf("        r[nx]: sampling frequencyn");
  85.     printf("            nx (default: 0)n");
  86.     printf("            0: 44.1 kHz n");
  87.     printf("            1: 48 kHzn"); 
  88.     printf("            2: 32 KHzn");
  89.     printf("        L  ch file is <[input file]_l.pcm>n");
  90.     printf("        R  ch file is <[input file]_r.pcm>n");
  91.     printf("        LS ch file is <[input file]_ls.pcm>n");
  92.     printf("        RS ch file is <[input file]_rs.pcm>n");
  93.     printf("        C  ch file is <[input file]_c.pcm>n");
  94.     printf("        aiff  file is <[input file].aiff> or <[input file].aiff.ml>n");
  95.     exit();
  96. }
  97. for(i=0;i<50;i++)
  98.     file_name[i]=0;
  99. i=0;
  100. file_name[i]=(*++argv)[0];
  101. i++;
  102. while(file_name[i]=*++argv[0])
  103.     i++;
  105. config=1;
  106. aiff_mode=0;
  107. arg_count=argc;
  108. aiff_ptr->sampleRate=44100.00;
  109. while(arg_count>=3){
  110.     arg_count--;
  111.     if((*++argv)[0]=='-'){
  112. while(c=*++argv[0]){
  113.     switch(c){
  114.     case        'r':
  115. c=*++argv[0];
  116. switch(c){
  117. case    '0':
  118.     aiff_ptr->sampleRate=44100.00;
  119.     break;
  120. case    '1':
  121.     aiff_ptr->sampleRate=48000.00;
  122.     break;
  123. case    '2':
  124.     aiff_ptr->sampleRate=32000.00;
  125.     break;
  126. default :
  127.     aiff_ptr->sampleRate=44100.00;
  128.     break;
  129. };
  130. break;
  131.     case 'm':
  132. pcmFilenameSuffix = multilingualPCMFilenameSuffix;
  133. aiffFilenameSuffix = multilingualAIFFFilenameSuffix;
  134. break;
  135.     case        'c':
  136. config=*++argv[0]-'0';
  137. break;
  138.     case        'a':
  139. aiff_mode=1;
  140. break;
  141.     default:
  142. printf(" ????n");
  143. exit();
  144.     }
  145. }
  146.     }
  147. }
  148. if(aiff_mode){
  149.     aiff2pcm(file_name,aiff_ptr);
  150. }else{
  151.     pcm2aiff(file_name,aiff_ptr,config);
  152. }
  153. };
  155. /**********************************************************************
  156. *
  157. *  PCM to Audio Interchange File Format(AIFF) conversion.
  158. *
  159. **********************************************************************/
  161. int pcm2aiff(char *fname,IFF_AIFF *aiff_ptr,int config)
  162. {
  163. register char   i;
  164. register long   seek_offset;
  165. int             index,lflag,rflag,cflag,lsflag,rsflag;
  166. int             size;
  167. int             BUF_SIZE=384;
  168. unsigned long   frame;
  169. char            temp_sampleRate[10];
  170. static char     tmp_file_name[200];
  171. char            holder;
  172. FILE            *file_ptr_pcm[MaxNumberOfChannels];
  173. FILE            *file_ptr_aiff;
  174. static char     buf[MaxNumberOfChannels][1152*2];
  175. char            buf0[2]={0,0};
  176. Chunk           FormChunk;
  177. CommonChunk     CommChunk;
  178. SoundDataChunk  SndDChunk;
  179. void            exit();
  181. #ifdef __MSDOS__
  182. long            lholder;
  183. void            swab();
  184. #endif
  186. printf("        pcm to aiff conversionn");
  187. aiff_ptr->numChannels = config + 1;
  189. for (i = 0; i < aiff_ptr->numChannels; i++) {
  190.     sprintf(tmp_file_name, "%s_%s.pcm", fname, pcmFilenameSuffix[i]);
  191.     if(NULL==(file_ptr_pcm[i]=fopen(tmp_file_name,"rb"))){
  192. printf("        read file open errorn");
  193. exit(1);
  194.     }
  195. }
  197. strcpy( tmp_file_name,fname); 
  198. strcat( tmp_file_name,aiffFilenameSuffix); 
  199. if(NULL==(file_ptr_aiff=fopen(tmp_file_name,"wb"))){
  200. printf("        write file open errorn");
  201. exit();
  202. }
  204. aiff_ptr->sampleSize=16;
  205. aiff_ptr->blkAlgn.offset=0;
  206. aiff_ptr->blkAlgn.blockSize=0;
  207. strcpy(aiff_ptr->sampleType,IFF_ID_SSND);
  209. double_to_extended(&aiff_ptr->sampleRate, temp_sampleRate);
  211. strcpy( FormChunk.ckID, IFF_ID_FORM);
  212. strcpy( FormChunk.formType, IFF_ID_AIFF);
  213. strcpy( CommChunk.ckID, IFF_ID_COMM); 
  215. for (i = 0; i < sizeof(char[10]); i++)
  216.     CommChunk.sampleRate[i] = temp_sampleRate[i];
  218. CommChunk.numChannels             = aiff_ptr->numChannels;
  219. CommChunk.sampleSize              = aiff_ptr->sampleSize;
  220. SndDChunk.offset                  = aiff_ptr->blkAlgn.offset;
  221. SndDChunk.blockSize               = aiff_ptr->blkAlgn.blockSize;
  222. strncpy( SndDChunk.ckID, aiff_ptr->sampleType,4);
  223. CommChunk.ckSize = sizeof(CommChunk.numChannels) +
  224. sizeof(CommChunk.numSampleFrames)+sizeof(CommChunk.sampleSize)+
  225. sizeof(CommChunk.sampleRate);
  227. SndDChunk.ckSize = sizeof(SoundDataChunk)-sizeof(ChunkHeader)+
  228. (CommChunk.sampleSize + BITS_IN_A_BYTE - 1) / BITS_IN_A_BYTE *
  229. CommChunk.numChannels * CommChunk.numSampleFrames;
  231. FormChunk.ckSize=sizeof(Chunk)+SndDChunk.ckSize+sizeof(ChunkHeader)+
  232.     CommChunk.ckSize;
  235. if(fwrite(&FormChunk, sizeof(Chunk), 1, file_ptr_aiff) != 1)
  236.     return(-1);
  238. if(fwrite(CommChunk.ckID, sizeof(ID),1,file_ptr_aiff) != 1)
  239.     return(-1);
  241. if(fwrite(&CommChunk.ckSize,sizeof(long),1,file_ptr_aiff)!=1)
  242.     return(-1);
  244. if(fwrite(&CommChunk.numChannels,sizeof(short),1,file_ptr_aiff)!=1)
  245.     return(-1);
  247. if(fwrite(&CommChunk.numSampleFrames,sizeof(unsigned long),1,
  248.       file_ptr_aiff) != 1)
  249.     return(-1);
  251. if(fwrite(&CommChunk.sampleSize,sizeof(short),1,file_ptr_aiff)!=1)
  252.     return(-1);
  253. if(fwrite(CommChunk.sampleRate,sizeof(char[10]),1,file_ptr_aiff)!=1)
  254.     return(-1);
  256. if(fwrite(&SndDChunk,sizeof(SoundDataChunk),1,file_ptr_aiff)!=1)
  257.     return(-1);
  259. frame=0;
  260. while(1){
  261.     for (i = 0; i < aiff_ptr->numChannels; i++) {
  262.     size=fread(&buf[i],2,BUF_SIZE,file_ptr_pcm[i]);
  263.     if(size==0) break;
  264.     }
  266.     for(index=0;index<size;index++){
  267. for (i = 0; i < aiff_ptr->numChannels; i++) {
  268. fwrite(&buf[i][2*index],2,1,file_ptr_aiff);
  269. }
  270.     }
  271.     frame++;
  272.     if(size<BUF_SIZE){
  273. for(index=size;index<BUF_SIZE;index++){
  274.     for (i = 0; i < aiff_ptr->numChannels; i++) {
  275. fwrite(&buf0[i],2,1,file_ptr_aiff);
  276.     }
  277. }
  278. break;
  279.     }
  280. }
  281. printf("        number of samples in frame / channel = %ldn",BUF_SIZE*frame-size);
  283. aiff_ptr->numSampleFrames=BUF_SIZE*frame;
  284. CommChunk.numSampleFrames         = aiff_ptr->numSampleFrames;
  285. CommChunk.ckSize = sizeof(CommChunk.numChannels)+
  286. sizeof(CommChunk.numSampleFrames)+sizeof(CommChunk.sampleSize)+
  287. sizeof(CommChunk.sampleRate);
  288. SndDChunk.ckSize =sizeof(SoundDataChunk)-sizeof(ChunkHeader)+
  289. (CommChunk.sampleSize + BITS_IN_A_BYTE - 1) / BITS_IN_A_BYTE *
  290. CommChunk.numChannels * CommChunk.numSampleFrames;
  291. FormChunk.ckSize = sizeof(Chunk)+SndDChunk.ckSize+sizeof(ChunkHeader)+
  292.     CommChunk.ckSize;
  295. if (fseek(file_ptr_aiff, 0, SEEK_SET) != 0)
  296.     return(-1);
  298. #ifdef __MSDOS__
  299. lholder=FormChunk.ckSize;
  300. swab(&lholder,&FormChunk.ckSize,4);
  301. lholder=FormChunk.ckSize&0xffff;
  302. FormChunk.ckSize=(((FormChunk.ckSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
  303. #endif
  305. if (fwrite(&FormChunk, sizeof(Chunk), 1, file_ptr_aiff) != 1)
  306.     return(-1);
  308. #ifdef __MSDOS__
  309. lholder=CommChunk.ckSize;
  310. swab(&lholder,&CommChunk.ckSize,4);
  311. lholder=CommChunk.ckSize&0xffff;
  312. CommChunk.ckSize=(((CommChunk.ckSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
  314. lholder=CommChunk.sampleSize;
  315. swab(&lholder,&CommChunk.sampleSize,2);
  316. lholder=CommChunk.numChannels;
  317. swab(&lholder,&CommChunk.numChannels,2);
  319. lholder=CommChunk.numSampleFrames;
  320. swab(&lholder,&CommChunk.numSampleFrames,4);
  321. lholder=CommChunk.numSampleFrames&0xffff;
  322. CommChunk.numSampleFrames=(((CommChunk.numSampleFrames>>16)&0xffff)+(lholder<<16))&0xffffffff;
  323. #endif
  325. if (fwrite(CommChunk.ckID,sizeof(ID),1,file_ptr_aiff)!=1)
  326.     return(-1);
  327. if (fwrite(&CommChunk.ckSize,sizeof(long),1,file_ptr_aiff)!=1)
  328.     return(-1);
  329. if (fwrite(&CommChunk.numChannels,sizeof(short),1,file_ptr_aiff)!=1)
  330.     return(-1);
  331. if (fwrite(&CommChunk.numSampleFrames,sizeof(unsigned long),1,
  332.       file_ptr_aiff)!=1)
  333.     return(-1);
  334. if (fwrite(&CommChunk.sampleSize, sizeof(short),1,file_ptr_aiff)!=1)
  335.     return(-1);
  336. if (fwrite(CommChunk.sampleRate,sizeof(char[10]),1,file_ptr_aiff)!=1)
  337.     return(-1);
  339. #ifdef __MSDOS__
  340. lholder=SndDChunk.ckSize;
  341. swab(&lholder,&SndDChunk.ckSize,4);
  342. lholder=SndDChunk.ckSize&0xffff;
  343. SndDChunk.ckSize=(((SndDChunk.ckSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
  345. lholder=SndDChunk.blockSize;
  346. swab(&lholder,&SndDChunk.blockSize,4);
  347. lholder=SndDChunk.blockSize&0xffff;
  348. SndDChunk.blockSize=(((SndDChunk.blockSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
  350. lholder=SndDChunk.offset;
  351. swab(&lholder,&SndDChunk.offset,4);
  352. lholder=SndDChunk.offset&0xffff;
  353. SndDChunk.offset=(((SndDChunk.offset>>16)&0xffff)+(lholder<<16))&0xffffffff;
  354. #endif
  356. if(fwrite(&SndDChunk,sizeof(SoundDataChunk),1,file_ptr_aiff)!=1)
  357.     return(-1);
  359. for (i = 0; i < aiff_ptr->numChannels; i++) {
  360. fclose(file_ptr_pcm[i]);
  361. }
  362. fclose(file_ptr_aiff);
  364. return(0);
  365. }
  367. /**********************************************************************
  368. *
  369. *  Audio Interchange File Format(AIFF) to PCM conversion.
  370. *
  371. **********************************************************************/
  372. int aiff2pcm(char *fname,IFF_AIFF *aiff_ptr)
  373. {
  374. int             *byte_per_sample;
  375. FILE            *file_ptr,*write_file_ptr[MaxNumberOfChannels];
  376. int             ch,numChan,diff_numChan,sample_size;
  377. register char   i;
  378. long            index;
  379. register long   seek_offset;
  380. char            temp_sampleRate[10];
  381. char            tmpBuf[10];
  382. int             *dummy,*dummy1;
  383. char            holder;
  384. static char     tmp_file_name[200];
  386. Chunk           FormChunk;
  387. CommonChunk     CommChunk;
  388. SoundDataChunk  SndDChunk;
  389. identifier      ident;
  390. void            exit();
  392. IEEE_DBL        *p_dbl,dbl;
  394. #ifdef  __MSDOS__
  395. unsigned long   lholder;
  396. void            swab();
  397. #endif
  398. p_dbl=&dbl;
  399. printf("        aiff to pcm conversionn");
  400. strcpy( tmp_file_name,fname); 
  401. strcat( tmp_file_name,aiffFilenameSuffix); 
  402. if(NULL==(file_ptr=fopen(tmp_file_name,"rb"))){
  403.     printf("    read file open errorn");
  404.     exit();
  405. }
  406. if (fseek(file_ptr, 0, SEEK_SET) != 0)
  407.     return(-1);
  408. if (fread(&FormChunk, sizeof(Chunk), 1, file_ptr) != 1)
  409.     return(-1);
  410. if (strncmp(FormChunk.ckID,IFF_ID_FORM,4) != 0 ||
  411.       strncmp(FormChunk.formType,IFF_ID_AIFF,4) != 0)
  412.     return(-1);
  413. if (fread(&ident,sizeof(identifier), 1, file_ptr) != 1)
  414.     return(-1);
  416. #ifdef __MSDOS__
  417. lholder=ident.ck_length;
  418. swab(&lholder,&ident.ck_length,4);
  419. lholder=ident.ck_length&0xffff;
  420. ident.ck_length=(((ident.ck_length>>16)&0xffff)+(lholder<<16))&0xffffffff;
  421. #endif
  423. while(strncmp(ident.name,IFF_ID_COMM,4) != 0)
  424. {
  425.     if(NULL==(dummy = (int *)calloc( ident.ck_length, sizeof(char)))){
  426. printf("        NULL pointer 1 n");
  427.     }
  428.     if(fread( dummy, ident.ck_length, 1, file_ptr) != 1)
  429. return(-1);
  430.     free(dummy);
  431.     if(fread( &ident, sizeof(identifier),1, file_ptr) != 1)
  432. return(-1);
  434. #ifdef __MSDOS__
  435.     lholder=ident.ck_length;
  436.     swab(&lholder,&ident.ck_length,4);
  437.     lholder=ident.ck_length&0xffff;
  438.     ident.ck_length=(((ident.ck_length>>16)&0xffff)+(lholder<<16))&0xffffffff;
  439. #endif
  440. }
  442. for( i = 0; i < 4; ++i){
  443. CommChunk.ckID[i] = ident.name[i];
  444. }
  445. CommChunk.ckSize = ident.ck_length;
  447. if (fread(&CommChunk.numChannels, sizeof(short), 1, file_ptr) != 1)
  448.     return(-1);
  449. if (fread(&CommChunk.numSampleFrames, sizeof(unsigned long), 1,
  450.       file_ptr) != 1)
  451.     return(-1);
  452. if (fread(&CommChunk.sampleSize, sizeof(short), 1, file_ptr) != 1)
  453.     return(-1);
  454. if (fread(CommChunk.sampleRate, sizeof(char[10]), 1, file_ptr) != 1)
  455.     return(-1);
  457. #ifdef __MSDOS__
  458. lholder=CommChunk.numChannels;
  459. swab(&lholder,&CommChunk.numChannels,2);
  461. lholder=CommChunk.numSampleFrames;
  462. swab(&lholder,&CommChunk.numSampleFrames,4);
  463. lholder=CommChunk.numSampleFrames&0xffff;
  464. CommChunk.numSampleFrames=((CommChunk.numSampleFrames>>16)+(lholder<<16))&0xffffffff;
  466. lholder=CommChunk.sampleSize;
  467. swab(&lholder,&CommChunk.sampleSize,2);
  468. #endif
  469. for (i = 0; i < sizeof(char[10]); i++)
  470.     temp_sampleRate[i] = CommChunk.sampleRate[i];
  472. extended_to_double(temp_sampleRate, &aiff_ptr->sampleRate);
  474. fseek (file_ptr, sizeof(Chunk), SEEK_SET);
  476. if (fread(&ident, sizeof(identifier), 1, file_ptr) != 1)
  477.     return(-1);
  479. #ifdef __MSDOS__
  480. lholder=ident.ck_length;
  481. swab(&lholder,&ident.ck_length,4);
  482. lholder=ident.ck_length&0xffff;
  483. ident.ck_length=(((ident.ck_length>>16)&0xffff)+(lholder<<16))&0xffffffff;
  484. #endif
  486. while(strncmp(ident.name,IFF_ID_SSND,4) != 0)
  487. {
  488.     if(NULL==(dummy1 = (int *)calloc( ident.ck_length, sizeof(char)))){
  489. printf("        NULL pointer2 n");
  490.     }
  491.     if(fread( dummy1, ident.ck_length, 1, file_ptr) != 1)
  492. return(-1);
  493.     free(dummy1);
  494.     if(fread( &ident, sizeof(identifier),1, file_ptr) != 1)
  495. return (-1);
  497. #ifdef __MSDOS__
  498.     lholder=ident.ck_length;
  499.     swab(&lholder,&ident.ck_length,4);
  500.     lholder=ident.ck_length&0xffff;
  501.     ident.ck_length=(((ident.ck_length>>16)&0xffff)+(lholder<<16))&0xffffffff;
  502. #endif
  503. }
  505. for(i = 0; i < 4; ++i)
  506.     SndDChunk.ckID[i] = ident.name[i];
  508. if (fread(&SndDChunk.offset, sizeof(unsigned long), 1, file_ptr)!=1)
  509.     return(-1);
  511. #ifdef __MSDOS__
  512. lholder=SndDChunk.offset;
  513. swab(&lholder,&SndDChunk.offset,4);
  514. lholder=SndDChunk.offset&0xffff;
  515. SndDChunk.offset=(((SndDChunk.offset>>16)&0xffff)+(lholder<<16))&0xffffffff;
  516. #endif
  518. if (fread(&SndDChunk.blockSize, sizeof(unsigned long), 1,
  519.      file_ptr) != 1)
  520.     return(-1);
  522. #ifdef __MSDOS__
  523. lholder=SndDChunk.blockSize;
  524. swab(&lholder,&SndDChunk.blockSize,4);
  525. lholder=SndDChunk.blockSize&0xffff;
  526. SndDChunk.blockSize=(((SndDChunk.blockSize>>16)&0xffff)+(lholder<<16))&0xffffffff;
  527. #endif
  529. numChan = CommChunk.numChannels;
  530. ch=0;
  531. for (i = 0; i < numChan; i++) {
  532.     sprintf(tmp_file_name, "%s_%s.pcm", fname, pcmFilenameSuffix[i]);
  533.     if(NULL==(write_file_ptr[ch]=fopen(tmp_file_name,"wb"))){
  534. printf("        write file open errorn");
  535. exit(1);
  536.     }
  537.     ch++;
  538. }
  539. diff_numChan=numChan-CommChunk.numChannels;
  540. if(diff_numChan>0){
  541. }
  543. printf("        number of samples in frame / channel = %ldn",CommChunk.numSampleFrames);
  544. sample_size=(CommChunk.sampleSize+BITS_IN_A_BYTE-1)/BITS_IN_A_BYTE;
  545. for(index = 0; index < CommChunk.numSampleFrames; index++){
  546.     for(ch = 0; ch < CommChunk.numChannels; ch++){
  547. if (fread(&tmpBuf, sample_size, 1,file_ptr) != 1)
  548.     return(-1);
  549. if (fwrite(&tmpBuf, sample_size, 1,write_file_ptr[ch]) != 1)
  550.     return(-1);
  551.     }
  552. }
  554. aiff_ptr->numChannels       = CommChunk.numChannels;
  555. aiff_ptr->numSampleFrames   = CommChunk.numSampleFrames;
  556. aiff_ptr->sampleSize        = CommChunk.sampleSize;
  557. aiff_ptr->blkAlgn.offset    = SndDChunk.offset;
  558. aiff_ptr->blkAlgn.blockSize = SndDChunk.blockSize;
  559. strncpy(aiff_ptr->sampleType, SndDChunk.ckID, 4);
  561. for (i = 0; i < numChan; i++) {
  562. fclose(write_file_ptr[i]);
  563. }
  564. fclose(file_ptr);
  566. return(0);
  567. }
  570. /**********************************************************************
  571. *
  572. *  Seek past some Audio Interchange File Format (AIFF) headers to sound data.
  573. *
  574. **********************************************************************/
  575. int aiff_seek_to_sound_data(FILE *file_ptr)
  576. {
  577. if (fseek(file_ptr,sizeof(Chunk)+sizeof(SoundDataChunk),SEEK_SET)!=0)
  578.     return(-1);
  579. else
  580.     return(0);
  581. }
  583. /**********************************************************************
  584. *
  585. *  double_to_extended()
  586. *
  587. *  Purpose:     Convert from IEEE double precision format to SANE extended
  588. *               format.
  589. *
  590. *  Passed:      Pointer to the double precision number and a pointer to what
  591. *               will hold the Apple SANE extended format value.
  592. *
  593. *  Outputs:     The SANE extended format pointer will be filled with the
  594. *               converted value.
  595. *
  596. *  Returned:    Nothing.
  597. *
  598. *********************************************************************/
  600. void    double_to_extended(double *pd, char ps[10])
  601. {
  602. #ifdef  MACINTOSH
  603. x96tox80(pd, (extended *) ps);
  604. #else
  605. register unsigned long  top2bits;
  606. register unsigned short *ps2;
  607. register IEEE_DBL       *p_dbl;
  608. register SANE_EXT       *p_ext;
  609. SANE_EXT ext_align;
  610. char *c_align;
  611. int i;
  613. #ifdef  __MSDOS__
  614. unsigned long  holder;
  615. void    swab();
  616. #endif
  618. p_dbl = (IEEE_DBL *) pd;
  620. #ifdef  __MSDOS__
  621. holder = p_dbl->lo;
  622. p_dbl->lo = p_dbl->hi;
  623. p_dbl->hi = holder;
  624. #endif
  626. p_ext=&ext_align;
  628. top2bits = p_dbl->hi & 0xc0000000L;
  629. p_ext->l1 = ((p_dbl->hi >> 4) & 0x3ff0000L) | top2bits;
  630. p_ext->l1 |= ((p_dbl->hi >> 5) & 0x7fffL) | 0x8000L;
  631. p_ext->l2 = (p_dbl->hi << 27) & 0xf8000000L;
  632. p_ext->l2 |= ((p_dbl->lo >> 5) & 0x07ffffffL);
  634. #ifdef  __MSDOS__
  635. holder = p_ext->l1 ;
  636. swab(&holder,&p_ext->l1,4);
  637. holder=p_ext->l1&0xffff;
  638. p_ext->l1=((p_ext->l1>>16)+(holder<<16))&0xffffffff;
  639. holder = p_ext->l2 ;
  640. swab(&holder,&p_ext->l2,4);
  641. holder=p_ext->l2&0xffff;
  642. p_ext->l2=((p_ext->l2>>16)+(holder<<16))&0xffffffff;
  643. #endif
  645. ps2 = (unsigned short *) & (p_dbl->lo);
  646. ps2++;
  647. ext_align.s1 = (*ps2 << 11) & 0xf800;
  649. c_align = (char *) p_ext;
  650. for (i=0;i<10;i++)
  651.     ps[i] = c_align[i];
  653. #endif
  654. }
  656. /**********************************************************************
  657. *
  658. *  extended_to_double()
  659. *
  660. *  Purpose:     Convert from SANE extended format to IEEE double precision
  661. *               format.
  662. *
  663. *  Passed:      Pointer to the Apple SANE extended format value and a pointer
  664. *               to what will hold the the IEEE double precision number.
  665. *
  666. *  Outputs:     The IEEE double precision format pointer will be filled with
  667. *               the converted value.
  668. *
  669. *  Returned:    Nothing.
  670. *
  671. **********************************************************************/
  672. void    extended_to_double(char ps[10], double *pd)
  673. {
  674. #ifdef  MACINTOSH
  675.    x80tox96((extended *) ps, pd);
  676. #else
  677. register unsigned long  top2bits;
  678. register IEEE_DBL       *p_dbl;
  679. register SANE_EXT       *p_ext;
  680. SANE_EXT ext_align;
  681. char *c_align;
  682. int i;
  684. #ifdef  __MSDOS__
  685. unsigned long  holder;
  686. void    swab();
  687. #endif
  689. p_dbl = (IEEE_DBL *) pd;
  690. p_ext = &ext_align;
  692. c_align = (char *) p_ext;
  693. for (i=0;i<10;i++)
  694.    c_align[i] = ps[i];
  696. #ifdef  __MSDOS__
  697. holder = p_ext->l1;
  698. swab(&holder,&p_ext->l1,4);
  699. holder = p_ext->l1&0xffff;
  700. p_ext->l1 = (((p_ext->l1>>16)&0xffff)+(holder<<16))&0xffffffff;
  701. holder = p_ext->l2;
  702. swab(&holder,&p_ext->l2,4);
  703. holder = p_ext->l2&0xffff;
  704. p_ext->l2 = (((p_ext->l2>>16)&0xffff)+(holder<<16))&0xffffffff;
  705. holder = p_ext->s1;
  706. swab(&holder,&p_ext->s1,2);
  707. #endif
  709. top2bits = p_ext->l1 & 0xc0000000L;
  710. p_dbl->hi = ((p_ext->l1 << 4) & 0x3ff00000L) | top2bits;
  711. p_dbl->hi |= (p_ext->l1 << 5) & 0xffff0L;
  712. p_dbl->hi |= (p_ext->l2 >> 27) & 0x1f;
  713. p_dbl->lo = (p_ext->l2 << 5) & 0xffffffe0L;
  714. p_dbl->lo |= (unsigned long) ((p_ext->s1 >> 11) & 0x1f);
  716. #ifdef  __MSDOS__
  717. holder = p_dbl->lo;
  718. p_dbl->lo = p_dbl->hi;
  719. p_dbl->hi = holder;
  720. #endif
  722. #endif
  723. };