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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
samplein.c
资源名称：bladeenc-0.90.0-src.zip　[点击查看]
上传用户：bjsgzm
上传日期：2007-01-08
资源大小：256k
文件大小：14k
源码类别：

mpeg/mp3

开发平台：

Visual C++

samplein.c：源码内容
  1. /*
  3. (c) Copyright 1998, 1999 - Tord Jansson
  4. =======================================
  6. This file is part of the BladeEnc MP3 Encoder, based on
  7. ISO's reference code for MPEG Layer 3 compression.
  9. This file doesn't contain any of the ISO reference code and
  10. is copyright Tord Jansson (tord.jansson@swipnet.se).
  12. BladeEnc is free software; you can redistribute this file
  13. and/or modify it under the terms of the GNU Lesser General Public
  14. License as published by the Free Software Foundation; either
  15. version 2.1 of the License, or (at your option) any later version.
  17. */
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include "system.h"
  22. #include "samplein.h"
  26. /* Errorcodes
  27.   -------------
  28.     0 = No Error (OK).
  29.    -1 = Unsupported filetype.
  30.    -2 = Couldn't open file.
  31.    -3 = Unexpected end of file.
  32.    -4 = (Input file is not in the format the file-extension says).
  33.    -5 = Important chunk missing.
  34.    -6 = Samples are in unsupported (compressed?) format.
  35. */
  38. #define STR_COMM 0x4d4d4f43
  39. #define STR_SSND 0x444e5353
  40. #define STR_FORM 0x4d524f46
  41. #define STR_AIFF 0x46464941
  42. #define STR_RIFF 0x46464952
  43. #define STR_WAVE 0x45564157
  44. #define STR_fmt 0x20746d66
  45. #define STR_data 0x61746164
  48. /*____ Function Prototypes ____________________________________________________*/
  50. static int initWAV( SplIn * psInfo );
  51. static uint readWAVSamples( SplIn * psInfo, int nSamples, short * wpSamples );
  53. static int initRAW( SplIn * psInfo );
  54. static uint readRAWSamples( SplIn * psInfo, int nSamples, short * wpSamples );
  56. static int initAIFF( SplIn * psInfo );
  57. static uint readAIFFSamples( SplIn * psInfo, int nSamples, short * wpSamples );
  59. static int myFseek( FILE * fp, int offset );
  62. uint INLINE intlLong( char iLong[4] );
  63. uint INLINE mcLong( char mcLong[4] );
  64. ushort INLINE intlShort( char iShort[2] );
  65. ushort INLINE mcShort( char mcShort[2] );
  69. /*____ Static Data ____________________________________________________________*/
  73. /*____ openInput() ____________________________________________________________*/
  75. int openInput( SplIn * psInfo, char * pFileName )
  76. {
  77. int x;
  78. char header[3*4];
  80. psInfo->errcode = 0;
  81. psInfo->nPreReadBytes = 0;
  83. /* Set Filepointer */
  85. if( pFileName == NULL )
  86. {
  87. psInfo->fp = stdin;
  88. }
  89. else
  90. {
  91. psInfo->fp = fopen( pFileName, "rb" );
  92. if( psInfo->fp == NULL ) goto couldNotOpen;
  93. }
  96. /* Read and analyze header */
  98. if( fread( header, 4, 3, psInfo->fp ) != 3 ) goto couldNotOpen;
  100. if( intlLong(&header[0]) == STR_RIFF && intlLong(&header[8]) == STR_WAVE )
  101. x = initWAV( psInfo );
  102. else if( intlLong(&header[0]) == STR_FORM && intlLong(&header[8]) == STR_AIFF )
  103. x = initAIFF( psInfo );
  104. else
  105. {
  106. memcpy( psInfo->preReadBuffer, header, 12 );
  107. psInfo->nPreReadBytes = 12;
  108. x = initRAW( psInfo );
  109. }
  111. if( x == FALSE )
  112. {
  113. if( psInfo->fp != stdin )
  114. fclose( psInfo->fp );
  115. psInfo->samplesLeft = 0;
  116. return FALSE;
  117. }
  120. /* Set some flags */
  122. if( psInfo->fReadStereo )
  123. psInfo->outputType = STEREO;
  124. else
  125. psInfo->outputType = DOWNMIX_MONO;
  127. psInfo->outputFreq = psInfo->freq;
  129. return TRUE;
  131. couldNotOpen:
  132. psInfo->errcode = -2;
  133. psInfo->samplesLeft = 0;
  134. return FALSE;
  135. }
  138. /*____ readSamples() __________________________________________________________*/
  140. int readSamples( SplIn * psInfo, uint nSamples, short * wpSamples )
  141. {
  142. int retVal = 0;
  143. uint i;
  144. uint readSamples;
  145. char temp;
  146. short tmp;
  148. if( psInfo->fReadStereo == TRUE && (psInfo->outputType == DOWNMIX_MONO
  149.                                     || psInfo->outputType == LEFT_CHANNEL_MONO || psInfo->outputType == RIGHT_CHANNEL_MONO) )
  150. readSamples = nSamples*2;
  151. else
  152. readSamples = nSamples;
  155. if( psInfo->samplesLeft == 0 )
  156. return 0;
  158. if( psInfo->samplesLeft != 0xFFFFFFFF )
  159. {
  160. if( readSamples < psInfo->samplesLeft )
  161. psInfo->samplesLeft -= readSamples;
  162. else
  163. {
  164. readSamples = psInfo->samplesLeft;
  165. psInfo->samplesLeft = 0;
  166. }
  167. }
  169. if( psInfo->filetype == WAV )
  170. retVal = readWAVSamples( psInfo, readSamples, wpSamples );
  171. else if( psInfo->filetype == AIFF )
  172. retVal = readAIFFSamples( psInfo, readSamples, wpSamples );
  173. else if( psInfo->filetype == RAW )
  174. retVal = readRAWSamples( psInfo, readSamples, wpSamples );
  176. if( psInfo->samplesLeft == 0 || retVal == FALSE )
  177. {
  178. psInfo->samplesLeft = 0;
  179. if( psInfo->fp != stdin )
  180. fclose( psInfo->fp );
  181. }
  184. /* Possibly swap byteorder */
  186. if( psInfo->bits == 16 && psInfo->byteorder != BYTEORDER )
  187. {
  188. for( i = 0 ; i < readSamples ; i++ )
  189. {
  190. temp = ((char *)wpSamples)[i*2];
  191. ((char *)wpSamples)[i*2] = ((char *)wpSamples)[i*2+1];
  192. ((char *)wpSamples)[i*2+1] = temp;
  193. }
  194. }
  197. /* Convert between 8/16-bit */
  199. if( psInfo->bits == 8 )
  200. {
  201. for( i = readSamples-1 ; i > 0 ; i-- )
  202. wpSamples[i] = ((short)((unsigned char *) wpSamples)[i]) << 8;
  203. wpSamples[i] = ((short)((unsigned char *) wpSamples)[i]) << 8;
  204. }
  206. /* Convert unsigned to signed */
  208. if( psInfo->fSign == FALSE )
  209. {
  210. for( i = 0 ; i < readSamples ; i++ )
  211. wpSamples[i] ^= 0x8000;
  212. }
  214. /* Convert from Stereo to Mono or inverse stereo in a number of ways */
  216. if( psInfo->outputType != STEREO && psInfo->fReadStereo == TRUE )
  217. {
  218. if( psInfo->outputType == DOWNMIX_MONO )
  219. for( i = 0 ; i < readSamples/2 ; i++ )
  220. wpSamples[i] = (short)((((int)wpSamples[i*2]) + ((int)wpSamples[i*2+1])) >> 1);
  222. if( psInfo->outputType == LEFT_CHANNEL_MONO )
  223. for( i = 0 ; i < readSamples/2 ; i++ )
  224. wpSamples[i] = wpSamples[i*2];
  227. if( psInfo->outputType == RIGHT_CHANNEL_MONO )
  228. for( i = 0 ; i < readSamples/2 ; i++ )
  229. wpSamples[i] = wpSamples[i*2+1];
  231. if( psInfo->outputType == INVERSE_STEREO )
  232. {
  233. for( i = 0 ; i < readSamples ; i += 2 )
  234. {
  235. tmp = wpSamples[i];
  236. wpSamples[i] = wpSamples[i+1];
  237. wpSamples[i+1] = tmp;
  238. }
  239. }
  241. }
  243. return retVal;
  244. }
  247. /*____ closeInput() ___________________________________________________________*/
  249. int closeInput( SplIn * psInfo )
  250. {
  251. if( psInfo->samplesLeft != 0 )
  252. {
  253. if( psInfo->fp != stdin )
  254. fclose( psInfo->fp );
  255. psInfo->samplesLeft = 0;
  256. return TRUE;
  257. }
  258. return FALSE;
  259. }
  262. /*____ initWAV() ______________________________________________________________*/
  264. static int initWAV( SplIn * psInfo )
  266. {
  267. char header[3*4];
  268. int fFmtChunkFound = FALSE;
  270. struct
  271. {
  272. short wFormatTag; /* Format category */
  273. short wChannels; /* Number of channels */
  274. int dwSamplesPerSec; /* Sampling rate */
  275. int dwAvgBytesPerSec; /* For buffer estimation */
  276. short wBlockAlign; /* Data block size */
  277. short bitsPerSample; /* Actually a PCM-specific additional byte... */
  278. } sFmtChunk;
  280. char aTemp[sizeof( sFmtChunk )];
  283. /* Go through the chunks until we have found 'data'. */
  286. if( fread( header, 4, 2, psInfo->fp ) != 2 ) goto unexpEndOfFile;
  288. while( intlLong( &header[0] ) != STR_data )
  289. {
  290. if( intlLong( &header[0] ) == STR_fmt )
  291. {
  292. if( fread( aTemp, sizeof( sFmtChunk ), 1, psInfo->fp ) != 1 )
  293. goto unexpEndOfFile;
  294. myFseek( psInfo->fp, intlLong( &header[4] ) - sizeof( sFmtChunk ) );
  295. fFmtChunkFound = TRUE;
  296. }
  297. else
  298. myFseek( psInfo->fp, intlLong( &header[4] ) );
  300. if( fread( header, 4, 2, psInfo->fp ) != 2 ) goto unexpEndOfFile;
  301. }
  304. /* Fill in sFmtChunk */
  306. sFmtChunk.wFormatTag = intlShort( aTemp );
  307. sFmtChunk.wChannels = intlShort( aTemp + 2);
  308. sFmtChunk.dwSamplesPerSec = intlLong( aTemp + 4 );
  309. sFmtChunk.dwAvgBytesPerSec = intlLong( aTemp + 8 );
  310. sFmtChunk.wBlockAlign = intlShort( aTemp + 12 );
  311. sFmtChunk.bitsPerSample = intlShort( aTemp + 14 );
  314. /* Process the data in sFmtChunk */
  316. if( fFmtChunkFound != TRUE )
  317. {
  318. psInfo->errcode = -5;
  319. return FALSE;
  320. }
  322. if( sFmtChunk.wFormatTag != 1 )
  323. {
  324. psInfo->errcode = -6;
  325. return FALSE; /* Not a PCM-sample. */
  326. }
  328. if( sFmtChunk.wChannels > 2 )
  329. {
  330. psInfo->errcode = -6;
  331. return FALSE; /* More than two channels. */
  332. }
  334. psInfo->freq = sFmtChunk.dwSamplesPerSec;
  335. psInfo->fReadStereo = sFmtChunk.wChannels - 1;
  336. psInfo->bits = sFmtChunk.bitsPerSample;
  338. if( sFmtChunk.bitsPerSample == 8 )
  339. psInfo->fSign = FALSE;
  340. else
  341. psInfo->fSign = TRUE;
  343. psInfo->length = intlLong(&header[4]);
  344. if( sFmtChunk.bitsPerSample == 16 )
  345. psInfo->length /= 2;
  346. psInfo->samplesLeft = psInfo->length;
  348. psInfo->byteorder = LITTLE_ENDIAN;
  349. psInfo->filetype = WAV;
  351. return TRUE;
  353. unexpEndOfFile:
  354. psInfo->errcode = -3;
  355. return FALSE;
  357. }
  360. /*____ readWAVsamples() _______________________________________________________*/
  362. static uint readWAVSamples( SplIn * psInfo, int nSamples, short * wpSamples )
  363. {
  364. return fread( wpSamples, psInfo->bits/8, nSamples, psInfo->fp );
  365. }
  369. /*____ initRAW() ______________________________________________________________*/
  371. static int initRAW( SplIn * psInfo )
  372. {
  374. /* By default we think it is ... */
  376. psInfo->freq = 44100;
  377. psInfo->length = 0xFFFFFFFF;
  378. psInfo->samplesLeft = 0xFFFFFFFF;
  379. psInfo->fReadStereo = TRUE;
  380. psInfo->bits = 16;
  381. psInfo->fSign = TRUE;
  382. psInfo->byteorder = BYTEORDER;
  383. psInfo->filetype = RAW;
  385. return TRUE;
  386. }
  389. /*____ readRAWsamples() _______________________________________________________*/
  391. static uint readRAWSamples( SplIn * psInfo, int nSamples, short * wpSamples )
  392. {
  393. int nPreReadSamples = 0;
  395. if( psInfo->nPreReadBytes != 0 )
  396. {
  397. memcpy( wpSamples, psInfo->preReadBuffer, psInfo->nPreReadBytes );
  398. wpSamples += psInfo->nPreReadBytes / 2;
  400. nPreReadSamples = psInfo->nPreReadBytes / (psInfo->bits/8);
  401. psInfo->nPreReadBytes =  0;
  402. }
  403. return fread( wpSamples, psInfo->bits/8, nSamples - nPreReadSamples, psInfo->fp ) + nPreReadSamples;
  404. }
  407. /*____ initAIFF() _____________________________________________________________*/
  409. static int initAIFF( SplIn * psInfo )
  410. {
  411. char header[3*4];
  413. int fPosAtSample = FALSE;
  414. int fCommChunkFound = FALSE;
  415. uchar * pFreq;
  416. int expo;
  418. double sampleRate;
  420. struct
  421. {
  422. short           numChannels;
  423. unsigned int    numSampleFrames;
  424. short           sampleSize;
  425. /*    char sampleRate[10]; */
  427. } sCommChunk;
  429. char aTemp[18];
  432. /* Go through the file and get COMM and SSND chunks */
  434. while( fPosAtSample == FALSE )
  435. {
  436. if( fread( header, 4, 2, psInfo->fp ) != 2 ) goto unexpEndOfFile;
  438. switch( intlLong( &header[0] ) )
  439. {
  440. case STR_COMM:
  441. if( fread( aTemp, 18, 1, psInfo->fp ) != 1 )
  442. goto unexpEndOfFile;
  443. fCommChunkFound = TRUE;
  444. break;
  445. case STR_SSND:
  446. myFseek( psInfo->fp, 8 );
  447. fPosAtSample = TRUE;
  449. break;
  450. default:
  451. myFseek( psInfo->fp, (mcLong( &header[4] ) + 1) &0xFFFFFFFE );
  452. }
  453. }
  455. if( fPosAtSample != TRUE || fCommChunkFound != TRUE )
  456. return FALSE;
  458. /* Fill in sCommChunk */
  460. sCommChunk.numChannels = mcShort( aTemp );
  461. sCommChunk.numSampleFrames = mcLong( aTemp + 2 );
  462. sCommChunk.sampleSize = mcShort( aTemp + 6 );
  464. /* Read Samplerate */
  466. pFreq = (uchar *) aTemp + 8;
  469. sampleRate = pFreq[9];
  470. sampleRate /= 256;
  471. sampleRate += pFreq[8];
  472. sampleRate /= 256;
  473. sampleRate += pFreq[7];
  474. sampleRate /= 256;
  475. sampleRate += pFreq[6];
  476. sampleRate /= 256;
  477. sampleRate += pFreq[5];
  478. sampleRate /= 256;
  479. sampleRate += pFreq[4];
  480. sampleRate /= 256;
  481. sampleRate += pFreq[3];
  482. sampleRate /= 256;
  483. sampleRate += pFreq[2];
  485. sampleRate /= 256;
  488. expo = (pFreq[0] << 8) + pFreq[1];
  489. expo -= 16383;
  490. expo += 1;
  492. while( expo != 0 )
  493. {
  494. if( expo < 0 )
  495. {
  496. sampleRate /= 2;
  497. expo++;
  498. }
  499. else
  500. {
  501. sampleRate *= 2;
  502. expo--;
  503. }
  504. }
  507. /* compensate for some apps or Macs which write slightly off sample rates */
  509. if ((sampleRate == 44099) || (sampleRate == 44101))
  510. sampleRate = 44100;
  511. if ((sampleRate == 31999) || (sampleRate == 32001))
  512. sampleRate = 32000;
  513. if ((sampleRate == 47999) || (sampleRate == 48001))
  514. sampleRate = 48000;
  517. /* Check number of channles and samplesize, just to be sure... */
  519. if( sCommChunk.numChannels > 2 )
  520. {
  521. psInfo->errcode = -6;
  522. return FALSE; /* More than two channels. */
  523. }
  525. if( sCommChunk.sampleSize != 16 && sCommChunk.sampleSize != 8 )
  526. {
  527. psInfo->errcode = -6;
  528. return FALSE; /* Strange samplesize. */
  529. }
  532. /* Fill in psInfo-struct */
  534. psInfo->freq = (int) (sampleRate + 0.5);
  535. psInfo->fReadStereo = sCommChunk.numChannels - 1;
  536. psInfo->bits = sCommChunk.sampleSize;
  538. psInfo->fSign = TRUE; /* Always signed ? */
  540. psInfo->length = sCommChunk.numSampleFrames * sCommChunk.numChannels;
  541. psInfo->samplesLeft = psInfo->length;
  543. psInfo->byteorder = BIG_ENDIAN;
  544. psInfo->filetype = AIFF;
  547. return TRUE;
  549. unexpEndOfFile:
  550. psInfo->errcode = -3;
  551. return FALSE;
  554. }
  557. /*____ readAIFFsamples() ______________________________________________________*/
  559. static uint readAIFFSamples( SplIn * psInfo, int nSamples, short * wpSamples )
  560. {
  561. return fread( wpSamples, psInfo->bits/8, nSamples, psInfo->fp );
  562. }
  565. /*____ intlLong() _____________________________________________________________*/
  567. uint INLINE intlLong( char iLong[4] )
  568. {
  569. return ((uint)((uchar*)iLong)[0]) + (((uint)((uchar*)iLong)[1]) << 8)
  570.        + (((uint)((uchar*)iLong)[2]) << 16) + (((uint)((uchar*)iLong)[3]) << 24);
  571. }
  574. /*____ mcLong() _______________________________________________________________*/
  576. uint INLINE mcLong( char mcLong[4] )
  577. {
  578. return ((uint)((uchar*)mcLong)[3]) + (((uint)((uchar*)mcLong)[2]) << 8 )
  579.        + (((uint)((uchar*)mcLong)[1]) << 16) + (((uint)((uchar*)mcLong)[0]) << 24);
  580. }
  583. /*____ intlShort() ____________________________________________________________*/
  586. ushort INLINE intlShort( char iShort[2] )
  587. {
  588. return ((ushort)((uchar*)iShort)[0]) + (((ushort)((uchar*)iShort)[1]) << 8);
  589. }
  592. /*____ mcShort() ______________________________________________________________*/
  594. ushort INLINE mcShort( char mcShort[2] )
  595. {
  596. return ((ushort)((uchar*)mcShort)[1]) + (((ushort)((uchar*)mcShort)[0]) << 8);
  597. }
  599. /*____ myFseek() ______________________________________________________________*/
  601. /* We can't use the real fseek() since you can't seek in a stream (stdin) */
  603. int myFseek( FILE * fp, int offset )
  604. {
  605. char dummy[256];
  607. while( offset / 256 )
  608. {
  609. fread( dummy, 256, 1, fp );
  610. offset -= 256;
  611. }
  613. if( offset )
  614. fread( dummy, offset, 1, fp );
  616. return 0;
  617. }