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

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

mpeg/mp3

开发平台：

Visual C++

main.c：源码内容
  1. /*
  2. (c) Copyright 1998, 1999 - Tord Jansson
  3. =======================================
  5. This file is part of the BladeEnc MP3 Encoder, based on
  6. ISO's reference code for MPEG Layer 3 compression.
  8. This file doesn't contain any of the ISO reference code and
  9. is copyright Tord Jansson (tord.jansson@swipnet.se).
  11. BladeEnc is free software; you can redistribute this file
  12. and/or modify it under the terms of the GNU Lesser General Public
  13. License as published by the Free Software Foundation; either
  14. version 2.1 of the License, or (at your option) any later version.
  16. */
  18. #include <stdio.h>
  19. #include    <stdlib.h>
  20. #include    <string.h>
  21. #include    <time.h>
  22. #include    "system.h"
  23. #include "codec.h"
  24. #include    "samplein.h"
  25. #include "arglink.h"
  26. #include "bladesys.h"
  29. #ifdef OS2
  30. # define INCL_DOSFILEMGR
  31. # define INCL_DOSERRORS
  32. # define INCL_DOSPROCESS
  33. # include <os2.h>
  34. # include "os2key.h"
  35. #endif
  37. #if SYSTEM == MAC_OS
  38. # include <SIOUX.h>
  39. # include <Events.h>
  41. void DoEvent(EventRecord *i);
  42. extern int gFriendliness;
  43. #endif
  46. extern char *mystrupr(char * strng);
  50. enum
  51. {
  52. PROG_OFF,
  53. PROG_BOTH_PERC_ETA,
  54. PROG_FILE_GRAPH,
  55. PROG_BATCH_GRAPH,
  56. PROG_BOTH_GRAPH,
  57. PROG_BOTH_SAMPLES,
  58. PROG_BOTH_ETA,
  59. PROG_FILE_RLEN,
  60. PROG_FILE_NORETURN,
  61. };
  64. /*____ Structure Definitions __________________________________________________*/
  66. typedef struct  JobDef  Job;
  68. struct JobDef
  69. {
  70. CodecInitIn sCodec;
  71. SplIn         sInput;
  72. Job         * psNext;
  73. int           fDeleteSource;
  74. char          outputFilename[MAX_NAMELEN];
  75. char          sourceFilename[MAX_NAMELEN];
  76. };
  79. /*____ Function Prototypes ____________________________________________________*/
  81. int printUsage( void );
  82. int validateJobs( Job * psJob );
  83. argLink * readGlobalSwitches( argLink * pArgLink );
  84. argLink * readLocalSwitches( argLink * pArgLink, Job * psJob );
  85. int addCommandlineJob( argLink ** pArgLink );
  86. int addFileToBatch( char * pFilename, char * pOutputFilename );
  87. int clearJobQueue( void );
  88. int removeJobQueueEntry( Job * psJob );
  90. int readL3EncCommandline( int argc, char * argv[] );
  92. void updateProgressIndicator( time_t startBatch, double batchLen, double batchDone,
  93.                      time_t startFile, double fileLen, double fileDone, 
  94.  int progType, Job * psJob );
  95. void quit( int returnValue );
  98. void timerCalibrate( void );
  99. time_t timerStart( void );
  100. float timerStop( time_t startTime );
  104. /*____ Static Data ____________________________________________________________*/
  108. /* Parameters set through the commandline. */
  110. int wantedBitrate = -1;             /* -1 = Unspecified. */
  111. int wantedCRC = FALSE;
  112. int wantedPrivate = FALSE;
  113. int wantedCopyright = FALSE;
  114. int wantedOriginal = TRUE;
  115. SampleType wantedInputType = STEREO;
  116. int wantedProgressBarRate = 2;
  117. int wantedChannelSwap = FALSE;
  119. int wantedDeleteSource = FALSE;
  121. #ifdef WAIT_KEY
  122. int     wantedQuit = FALSE;
  123. int defWantedQuit = FALSE;
  124. #else
  125. int wantedQuit = TRUE;
  126. int defWantedQuit = TRUE;
  127. #endif
  128. int wantedQuiet = FALSE;
  129. int wantedSTDOUT = FALSE;
  130. int fPreparedSTDIN = FALSE;
  132. char prioString[256];
  133. char * pPrioString = NULL;
  135. Job * psJobQueue = NULL;
  137. char outputDir[MAX_NAMELEN];
  139. FILE * textout;
  141. int timerCalibrationValue; /* Only used if PRECISE_TIMER is defined. */
  143. int progType = PROG_BOTH_PERC_ETA; /* Style of the progress bar */
  146. int rawFrequency = 44100;
  147. int rawChannels = 2;
  148. int rawBits = 16;
  149. int rawSigned = TRUE;
  150. int rawByteorder = BYTEORDER;
  153. /*____ main() _________________________________________________________________*/
  155. #if SYSTEM == MAC_OS
  156. int main_( int argc, char* argv[] ) /* Because the real main is somewhere else */
  157. #else
  158. int main( int argc, char* argv[] )
  159. #endif
  160. {
  161. int           samplesPerFrame;
  162. int           nSamples;
  164. short         readBuffer[2304];
  165. int           x;
  167. char          input;
  168. Job         * psTemp;
  170. time_t        startTimeBatch, startTimeFile;
  171. float   seconds;
  172. double        batchSamplesTotal = 0.0, batchSamplesRead = 0.0;
  173. double   fileSamplesRead;
  174. int   showProgressCnt = 0;
  176. CodecInitOut *pCodecInfo;
  177. char        * pBuffer;
  178. uint          encodedChunkSize;
  179. FILE        * fp;
  181. char   temp[256];
  184. argLink * pArgLink, * pNextArg;
  186. #if SYSTEM == MAC_OS
  187. long macTickStart = TickCount();
  188. #endif
  190. /* Setting default parameters. Might seem useless since most of them
  191.    allready are predefined, but the MAC OS port uses main() as a subroutine
  192.    which can be called multiple times. */
  195. wantedBitrate = -1;             /* -1 = Unspecified. */
  196. wantedCRC = FALSE;
  197. wantedPrivate = FALSE;
  198. wantedCopyright = FALSE;
  199. wantedOriginal = TRUE;
  200. wantedInputType = STEREO;
  201. wantedProgressBarRate = 2;
  202. wantedChannelSwap = FALSE;
  204. wantedDeleteSource = FALSE;
  206. wantedQuit = defWantedQuit;
  207. wantedQuiet = FALSE;
  208. wantedSTDOUT = FALSE;
  209. fPreparedSTDIN = FALSE;
  211. pPrioString = NULL;
  213. psJobQueue = NULL;
  216. progType = PROG_BOTH_PERC_ETA; /* Style of the progress bar */
  218. rawFrequency = 44100;
  219. rawChannels = 2;
  220. rawBits = 16;
  221. rawSigned = TRUE;
  222. rawByteorder = BYTEORDER;
  224. textout = stdout;
  225. outputDir[0] = 0;
  227. /* Fix ArgLink */
  229. pArgLink = argv2ArgLink( argc-1, argv+1 );
  231. if( findStrInArgLink( pArgLink, "-NOCFG" ) == NULL )
  232. if( findConfigFile( argv[0], temp ) == TRUE )
  233. addFileContentToArgLink( &pArgLink, temp );
  235. #ifdef WILDCARDS
  236. expandWildcards( &pArgLink );
  237. #endif
  239. pNextArg = readGlobalSwitches( pArgLink );
  241. /* Check for STDOUT */
  243. if( findStrInArgLink( pArgLink, "stdout" ) != NULL )
  244. {
  245. prepStdout();
  246. textout = stderr;
  247. }
  250. /* Print Text */
  252. if( !wantedQuiet )
  253. {
  254. fprintf( textout, "n" );
  255. fprintf( textout, "BladeEnc 0.90    (c) Tord Jansson          Homepage: http://bladeenc.mp3.non" );
  256. fprintf( textout, "===============================================================================n" );
  257. fprintf( textout, "BladeEnc is free software, distributed under the Lesser General Public License.n" );
  258. fprintf( textout, "See the file COPYING, BladeEnc's homepage or www.fsf.org for more details.n" );
  259. fprintf( textout, "n" );
  260. }
  262. /* Initialise batch */
  264. while( pNextArg != NULL )
  265. {
  266. x = addCommandlineJob( &pNextArg );
  267. if( x == FALSE )
  268. {
  269. deleteArgLink( pArgLink );
  270. quit( -1 );
  271. }
  272. }
  274. deleteArgLink( pArgLink );
  276. /* Validate job settings */
  278. x = validateJobs( psJobQueue );
  279. if( x == FALSE )
  280. quit( -2 );
  283. /* Make sure we don't have certain progress indicators if RAW file in batch */
  285. x = 0;
  286. for( psTemp = psJobQueue ; psTemp != NULL ; psTemp = psTemp->psNext )
  287. {
  288. if( psTemp->sInput.filetype == RAW )
  289. x++;
  290. }
  291. if( x != 0 && progType != PROG_OFF && progType != PROG_FILE_RLEN )
  292. progType = PROG_FILE_RLEN;
  294. /* Set priority */
  296. if( setPriority( pPrioString ) == FALSE )
  297. {
  298. fprintf( textout, "Error: '%s' is not a valid priority setting!n", pPrioString );
  299. quit( -1 );
  300. };
  304. /* Procedure if no files found */
  306. if( psJobQueue == NULL )
  307. {
  308. printUsage();                                                           /* No files on the commandline */
  309. quit( -1 );
  310. }
  313. /* Print files to encode */
  315. for( x = 0, psTemp = psJobQueue ; psTemp != NULL ; x++, psTemp = psTemp->psNext );
  316. if( !wantedQuiet )
  317. fprintf( textout, "Files to encode: %dnn", x );
  320. /* Encode */
  322. #ifdef PRECISE_TIMER
  323. timerCalibrate();
  324. #endif
  326. startTimeBatch = timerStart();
  328. for( psTemp = psJobQueue ; psTemp != NULL ; psTemp = psTemp->psNext )
  329. if( psTemp->sInput.length == 0xFFFFFFFF )
  330. {
  331. batchSamplesTotal = 0xFFFFFFFF;
  332. break;
  333. }
  334. else
  335. batchSamplesTotal += psTemp->sInput.length;
  338. while( psJobQueue != NULL )
  339. {
  340. /* Print information */
  342. if( !wantedQuiet )
  343. {
  344. fprintf( textout, "Encoding:  %sn", psJobQueue->sourceFilename );
  345. fprintf( textout, "Input:     %.1f kHz, %d bit, ", psJobQueue->sInput.freq/1000.f, psJobQueue->sInput.bits );
  346. if( psJobQueue->sInput.fReadStereo == TRUE )
  347. fprintf( textout, "stereo.n" );
  348. else
  349. fprintf( textout, "mono.n" );
  350. fprintf( textout, "Output:    %d kBit, ", psJobQueue->sCodec.bitrate );
  351. if( psJobQueue->sCodec.mode == 0 )
  352. fprintf( textout, "stereo.nn" );
  353. else
  354. fprintf( textout, "mono.nn" );
  355. }
  357. /* Init a new job */
  359. startTimeFile = timerStart();
  360. fileSamplesRead = 0;
  361. pCodecInfo = codecInit( &psJobQueue->sCodec );
  362. samplesPerFrame = pCodecInfo->nSamples;
  363. pBuffer = (char *) malloc( pCodecInfo->bufferSize );
  364. if( strcmp( psJobQueue->outputFilename, "STDOUT" ) == 0 )
  365. fp = stdout;
  366. else
  367. {
  368. fp = fopen( psJobQueue->outputFilename, "wb" );
  369. if( fp == NULL )
  370. {
  371. /*  codecExit(); */
  372. closeInput( &psJobQueue->sInput );
  373. fprintf( textout, "ERROR: Couldn't create '%s'!n", psJobQueue->outputFilename );
  374. quit( -1 );
  375. }
  376. }
  378. /* Encoding loop */
  380. while ( (nSamples = readSamples( &psJobQueue->sInput, samplesPerFrame, readBuffer)) > 0 )
  381. {
  384. #if SYSTEM == MAC_OS /* Stuff needed for Petteri Kamppuri's Mac OS port */
  385.   if(macTickStart + gFriendliness < TickCount())
  386. {
  387.          macTickStart = TickCount();
  389.         Boolean       gotEvent;
  390.           EventRecord event;
  392.           gotEvent = GetNextEvent(everyEvent, &event);
  393.           if(gotEvent)
  394. {
  395.              SIOUXHandleOneEvent(&event);
  396.             DoEvent(&event);
  397.           }
  398. }
  399. #endif
  401. encodedChunkSize = codecEncodeChunk( nSamples, readBuffer, pBuffer );
  402. if( fwrite( pBuffer, 1, encodedChunkSize, fp ) != encodedChunkSize )
  403. {
  404. fprintf( textout, "ERROR: Couldn't write '%s'! Disc probably full.n", psJobQueue->outputFilename );
  405. quit( -1 );
  406. }
  408. batchSamplesRead += nSamples;
  409. fileSamplesRead += nSamples;
  411. if( !wantedQuiet )
  412. {
  413. showProgressCnt = (showProgressCnt+1) % wantedProgressBarRate;
  414. if( showProgressCnt == 0 )
  415. updateProgressIndicator( startTimeBatch, batchSamplesTotal, batchSamplesRead,
  416.                          startTimeFile, psJobQueue->sInput.length, fileSamplesRead, 
  417.  progType, psJobQueue );
  418. }
  419. if( be_kbhit() != 0 )
  420. {
  421. input = be_getch();
  422. if( input == 27 )
  423. {
  424. fprintf( textout, "r                                                                             r" );
  425. fprintf( textout, "Quit, are you sure? (y/n)" );
  426. fflush( textout );
  427. input = be_getch();
  428. if( input == 'y' || input == 'Y' )
  429. {
  430. encodedChunkSize = codecExit( pBuffer );
  431. if( encodedChunkSize != 0 )
  432. if( fwrite( pBuffer, encodedChunkSize, 1, fp ) != 1 )
  433. {
  434. fprintf( textout, "ERROR: Couldn't write '%s'! Disc probably full.n", psJobQueue->outputFilename );
  435. quit( -1 );
  436. }
  437. free( pBuffer );
  438. closeInput( &psJobQueue->sInput );
  439. if( fp != stdout )
  440. fclose( fp );
  441. return  0;
  442. }
  443. else
  444. fprintf( textout, "r                                                                             r" );
  445. }
  446. }
  447. }
  449. /* File done */
  452. encodedChunkSize = codecExit( pBuffer );
  453. if( encodedChunkSize != 0 )
  454. if( fwrite( pBuffer, encodedChunkSize, 1, fp ) != 1 )
  455. {
  456. fprintf( textout, "ERROR: Couldn't write '%s'! Disc probably full.n", psJobQueue->outputFilename );
  457. quit( -1 );
  458. }
  459. if( fp != stdout )
  460. fclose( fp );
  461. free( pBuffer );
  462. if( psJobQueue->fDeleteSource == TRUE )
  463. remove( psJobQueue->sourceFilename );
  464. seconds = timerStop( startTimeFile );
  465. x = (int) seconds;
  466. if( !wantedQuiet )
  467. {
  468. fprintf( textout, "r                                                                             r" );
  469. fprintf( textout, "Completed. Encoding time: %02d:%02d:%02d (%.2fX)nn",
  470.          x/3600, (x/60)%60, x%60, ((float)fileSamplesRead) /
  471.          ((psJobQueue->sInput.fReadStereo+1)*psJobQueue->sInput.freq*seconds) );
  472. }
  473. removeJobQueueEntry( psJobQueue );
  474. }
  476. /* Batch done */
  478. if( !wantedQuiet )
  479. {
  480. seconds = timerStop( startTimeBatch );
  481. fprintf( textout, "All operations completed. Total encoding time: %02d:%02d:%02dn",
  482.          (int) seconds/3600, (int)(seconds/60)%60, (int) seconds%60 );
  484. if( !wantedQuit )
  485. {
  486. fprintf( textout, "Press ENTER to exit..." );
  487. be_getch();
  488. fprintf( textout, "n" );
  489. }
  490. }
  492. return 0;
  493. }
  497. /*____ quit() _________________________________________________________________*/
  499. void    quit( int returnValue )
  501. {
  502. if( !wantedQuit )
  503. {
  504. fprintf( textout, "Press ENTER to exit..." );
  505. be_getch();
  506. fprintf( textout, "n" );
  507. }
  508. #if SYSTEM == MAC_OS
  509. throw returnValue;
  510. #else
  511. exit( returnValue );
  512. #endif
  513. }
  517. /*____ timerCalibrate() _______________________________________________________*/
  519. void timerCalibrate( void )
  520. {
  521. time_t x, y;
  522. int i;
  524. x = y = time( NULL );
  525. while( y == x )
  526. y = time( NULL );
  528. for( i = 0 ; y == time( NULL ) ; i++ );
  529. timerCalibrationValue = i;
  530. printf( "Timer Calibration Value: %dn", timerCalibrationValue );
  531. }
  534. /*____ timerStart() ___________________________________________________________*/
  536. time_t timerStart( void )
  537. {
  538. time_t x, y;
  540. x = y = time( NULL );
  541. #ifdef PRECISE_TIMER
  542. while( y == x )
  543. y = time( NULL );
  544. #endif
  545. return y;
  546. }
  548. /*____ timerStop() ____________________________________________________________*/
  550. float timerStop( time_t startTime )
  551. {
  552. float seconds;
  554. time_t stopTime = time( NULL );
  555. #ifdef PRECISE_TIMER
  556. int i;
  557. for( i = 0 ; stopTime == time( NULL ) ; i++ );
  558. #endif
  560. seconds = (float) (stopTime - startTime);
  561. #ifdef PRECISE_TIMER
  562. seconds += ((float)(timerCalibrationValue - i))/timerCalibrationValue;
  564. printf( "Exact seconds: %.5fn", seconds );
  565. #endif
  566. return seconds;
  567. }
  572. /*____ updateProgressIndicator() ______________________________________________*/
  574. void    updateProgressIndicator( time_t startBatch, double batchLen, double batchDone,
  575.                                  time_t startFile, double fileLen, double fileDone, 
  576.  int progType, Job * psJob )
  577. {
  578. time_t  currTime;
  579. float   percentageFile, percentageBatch;
  580. int     fileEta, batchEta;
  582. char temp[82];
  583. int x, i;
  586. static char wheel[4] = { '|' , '/' , '-' , '\' };
  587. static int wheelindex = 0;
  588. static int prevFileDone = -1;
  590. currTime = time( NULL );
  592. switch( progType )
  593. {
  594. case PROG_BOTH_PERC_ETA:
  595. percentageFile = (float) (fileDone / fileLen * 100);
  596. if( percentageFile >= 100.f )
  597. percentageFile = (float) 99.9;
  599. fileEta = (int) (((float)(currTime - startFile)) / fileDone * (fileLen - fileDone) );
  601. percentageBatch = (float)(batchDone / batchLen * 100);
  602. batchEta = (int) (((float)(currTime - startBatch)) / batchDone * (batchLen - batchDone));
  603. fprintf( textout, "Status:   %4.1f%% done, ETA %02d:%02d:%02d          BATCH: %4.1f%% done, ETA %02d:%02d:%02dr",
  604.  percentageFile, fileEta/3600, (fileEta/60)%60, fileEta%60,
  605.  percentageBatch, batchEta/3600, (batchEta/60)%60, batchEta%60 );
  606. fflush( textout );
  607. break;
  609. case PROG_FILE_GRAPH:
  611. strcpy( temp, "File progress: [..................................................]r" );
  612. x = (int) (fileDone*50/fileLen);
  613. memset( temp + 16, '*', x );
  614. if( x < 50 )
  615. {
  616. temp[16+x] = wheel[wheelindex];
  617. wheelindex = (wheelindex + 1) % 4;
  618. }
  620. fprintf( textout, temp );
  621. break;
  623. case PROG_BATCH_GRAPH:
  625. strcpy( temp, "Batch progress: [..................................................]r" );
  626. x = (int) (batchDone*50/batchLen);
  627. memset( temp + 16, '*', x );
  628. if( x < 50 )
  629. {
  630. temp[16+x] = wheel[wheelindex];
  631. wheelindex = (wheelindex + 1) % 4;
  632. }
  634. fprintf( textout, temp );
  635. break;
  637. case PROG_BOTH_GRAPH:
  639. strcpy( temp, "File: [.........................]   Batch: [.........................]r" );
  641. x = (int) (fileDone*25/fileLen);
  642. memset( temp + 7, '*', x );
  644. x = (int) (batchDone*25/batchLen);
  645. memset( temp + 44, '*', x );
  646. if( x < 25 )
  647. {
  648. temp[7+x] = temp[44+x] = wheel[wheelindex];
  649. wheelindex = (wheelindex + 1) % 4;
  650. }
  652. fprintf( textout, temp );
  653. break;
  655. case PROG_BOTH_SAMPLES:
  657. fprintf( textout, "Samples encoded:%10d / %d      BATCH:%10d / %dr", 
  658.  (int) fileDone, (int) fileLen, (int) batchDone, (int) batchLen );
  659. break;
  661. case PROG_BOTH_ETA:
  662. fileEta = (int) (((float)(currTime - startFile)) / fileDone * (fileLen - fileDone) );
  664. batchEta = (int) (((float)(currTime - startBatch)) / batchDone * (batchLen - batchDone));
  665. fprintf( textout, "                >>> %02d:%02d:%02d <<<                >>> %02d:%02d:%02d <<<r",
  666.  fileEta/3600, (fileEta/60)%60, fileEta%60,
  667.  batchEta/3600, (batchEta/60)%60, batchEta%60 );
  668. fflush( textout );
  669. break;
  672. case PROG_FILE_RLEN:
  674. x = (int) (fileDone / psJob->sCodec.frequency);
  675. if( psJob->sCodec.mode != 3 )
  676. x /= 2;
  678. fprintf( textout, "Encoded runlength (current file): %02d:%02d:%02dr", 
  679.          x/3600, (x/60)%60, x%60 );
  680. break;
  682. case PROG_FILE_NORETURN:
  684. x = (int) (fileDone*70/fileLen);
  685. if( prevFileDone > x || prevFileDone == -1 )
  686. {
  687. prevFileDone = 0;
  688. fprintf( textout, " |----------------------------------------------------------------------|n |" );
  689. fflush( textout );
  690. }
  691. for( i = prevFileDone ; i < x ; i++ )
  692. {
  693. fprintf( textout, "#" );
  694. fflush( textout );
  695. }
  697. if( x == 70 )
  698. fprintf( textout, "|nn" );
  699. prevFileDone = x;
  700. break;
  702. }
  705. }
  707. /*____ setOutputDir() _______________________________________________________*/
  709. void setOutputDir( char * pPath )
  710. {
  711. int i;
  713. strcpy( outputDir, pPath );
  714. i = strlen( outputDir ) -1;
  715. if( outputDir[i] != DIRECTORY_SEPARATOR )
  716. {
  717. outputDir[i+1] = DIRECTORY_SEPARATOR;
  718. outputDir[i+2] = 0;
  719. }
  720. }
  722. /*____ readGlobalSwitches() ___________________________________________________*/
  724. argLink * readGlobalSwitches( argLink * pArgLink )
  725. {
  726. char arg[256];
  727. int x, y;
  729. for( ; pArgLink != NULL ; pArgLink = pArgLink->psNext )
  730. {
  731. strcpy( arg, pArgLink->pString );
  732. mystrupr( arg );
  733. if( arg[0] != '-' )
  734. return pArgLink;
  735. if( !strcmp( arg+1, "MONO" ) || !strcmp( arg+1, "DM" ) )
  736. wantedInputType = DOWNMIX_MONO;
  737. else if( !strcmp( arg+1, "CRC" ) )
  738. wantedCRC = TRUE;
  739. else if( !strcmp( arg+1, "PRIVATE" ) || !strcmp( arg+1, "P" ) )
  740. wantedPrivate = TRUE;
  741. else if( !strcmp( arg+1, "COPYRIGHT" ) || !strcmp( arg+1, "C" ) )
  742. wantedCopyright = TRUE;
  743. else if( !strcmp( arg+1, "ORIGINAL" ) )
  744. wantedOriginal = TRUE;
  745. else if( !strcmp( arg+1, "COPY" ) )
  746. wantedOriginal = FALSE;
  747. else if( !strcmp( arg+1, "DELETE" ) || !strcmp( arg+1, "DEL" ) )
  748. wantedDeleteSource = TRUE;
  749. else if( !strcmp( arg+1, "QUIT" ) || !strcmp( arg+1, "Q" ))
  750. wantedQuit = TRUE;
  751. else if( !strcmp( arg+1, "SWAP" ) )
  752. wantedInputType = INVERSE_STEREO;
  753. else if( !strcmp( arg+1, "LEFTMONO" ) || !strcmp( arg+1, "LM" ))
  754. wantedInputType = LEFT_CHANNEL_MONO;
  755. else if( !strcmp( arg+1, "RIGHTMONO" ) || !strcmp( arg+1, "RM" ))
  756. wantedInputType = RIGHT_CHANNEL_MONO;
  757. else if( !strcmp( arg+1, "QUIET" ) )
  758. wantedQuiet = TRUE;
  759. else if( !strcmp( arg+1, "NOCFG" ) )
  760. ; /* simply do nothing... */
  761. else if( strstr( arg+1, "PROGRESS=" ) == arg+1 )
  762. progType = atoi( arg+10 );
  763. else if( strstr( arg+1, "OUTDIR=" ) == arg+1 )
  764. setOutputDir( pArgLink->pString + 8 );
  765. else if( strstr( arg+1, "REFRESH=" ) == arg+1 )
  766. {
  767. wantedProgressBarRate = atoi( arg+9 );
  768. if( wantedProgressBarRate < 1 )
  769. wantedProgressBarRate = 1;
  770. }
  771. #ifdef  PRIO
  772. else if( strstr( arg+1, "PRIO=" ) == arg+1 )
  773. {
  774. strcpy( prioString, arg+6 );
  775. pPrioString = prioString;
  776. }
  777. #endif
  778. else if( !strcmp( arg+1, "RAWMONO" ) )
  779. rawChannels = 1;
  780. else if( !strcmp( arg+1, "RAWSTEREO" ) )
  781. rawChannels = 2;
  782. else if( !strcmp( arg+1, "RAWSIGNED" ) )
  783. rawSigned = TRUE;
  784. else if( !strcmp( arg+1, "RAWUNSIGNED" ) )
  785. rawSigned = FALSE;
  786. else if( strstr( arg+1, "RAWBITS=" ) == arg+1 )
  787. {
  788. rawBits = atoi( arg+9 );
  789. if( rawBits != 8 && rawBits != 16 )
  790. rawBits = 16;
  791. }
  792. else if( strstr( arg+1, "RAWFREQ=" ) == arg+1 )
  793. {
  794. rawFrequency = atoi( arg+9 );
  795. }
  796. else if( strstr( arg+1, "RAWBYTEORDER=" ) == arg+1 )
  797. {
  798. if( strstr( arg+14, "LITTLE" ) == arg+14 )
  799. rawByteorder = LITTLE_ENDIAN;
  800. if( strstr( arg+14, "BIG" ) == arg+14 )
  801. rawByteorder = BIG_ENDIAN;
  802. if( strstr( arg+14, "DEFAULT" ) == arg+14 )
  803. rawByteorder = BYTEORDER;
  804. }
  805. else if( strstr( arg+1, "RAWCHANNELS=" ) == arg+1 )
  806. {
  807. rawChannels = atoi( arg+13 );
  808. if( rawChannels != 1 && rawChannels != 2 )
  809. rawChannels = 2;
  810. }
  811. else if( !strcmp( arg+1, "BR" ) )
  812. {
  813. pArgLink = pArgLink->psNext;
  814. if( pArgLink == NULL )
  815. return NULL;
  816. wantedBitrate = atoi( pArgLink->pString );
  817. if( wantedBitrate > 1000 )
  818. wantedBitrate /= 1000;
  819. }
  820. else
  821. {
  822. y = 0;
  823. for( x = 1 ; arg[x] >= '0' && arg[x] <= '9' ; x++ )
  824. y = y * 10 + (arg[x] - '0');
  825. if( arg[x] == 0 )
  826. {
  827. wantedBitrate = y;
  828. if( wantedBitrate > 1000 )
  829. wantedBitrate /= 1000;
  830. }
  831. else
  832. return pArgLink;
  833. }
  834. }
  835. return  pArgLink;
  836. }
  839. /*____ readLocalSwitches() ___________________________________________________*/
  841. argLink * readLocalSwitches( argLink * pArgLink, Job * psJob )
  842. {
  843. char arg[256];
  844. int x, y;
  846. for( ; pArgLink != NULL ; pArgLink = pArgLink->psNext )
  847. {
  848. strcpy( arg, pArgLink->pString );
  849. mystrupr( arg );
  850. if( arg[0] != '-' )
  851. return pArgLink;
  852. if( !strcmp( arg+1, "MONO" ) || !strcmp( arg+1, "DM" ) )
  853. {
  854. psJob->sInput.outputType = DOWNMIX_MONO;
  855. psJob->sCodec.mode = 3;
  856. }
  857. else if( !strcmp( arg+1, "CRC" ) )
  858. psJob->sCodec.fCRC = TRUE;
  859. else if( !strcmp( arg+1, "PRIVATE" ) || !strcmp( arg+1, "P" ) )
  860. psJob->sCodec.fPrivate = TRUE;
  861. else if( !strcmp( arg+1, "COPYRIGHT" ) || !strcmp( arg+1, "C" ) )
  862. psJob->sCodec.fCopyright = TRUE;
  863. else if( !strcmp( arg+1, "ORIGINAL" ) )
  864. psJob->sCodec.fOriginal = TRUE;
  865. else if( !strcmp( arg+1, "COPY" ) )
  866. psJob->sCodec.fOriginal = FALSE;
  867. else if( !strcmp( arg+1, "DELETE" ) || !strcmp( arg+1, "DEL" ) )
  868. psJob->fDeleteSource = TRUE;
  869. else if( !strcmp( arg+1, "SWAP" ) )
  870. {
  871. if( psJob->sInput.fReadStereo == TRUE )
  872. {
  873. psJob->sInput.outputType = INVERSE_STEREO;
  874. psJob->sCodec.mode = 3;
  875. }
  876. }
  877. else if( !strcmp( arg+1, "LEFTMONO" ) || !strcmp( arg+1, "LM" ))
  878. {
  879. if( psJob->sInput.fReadStereo == TRUE )
  880. {
  881. psJob->sInput.outputType = LEFT_CHANNEL_MONO;
  882. psJob->sCodec.mode = 3;
  883. }
  884. }
  885. else if( !strcmp( arg+1, "RIGHTMONO" ) || !strcmp( arg+1, "RM" ))
  886. {
  887. if( psJob->sInput.fReadStereo == TRUE )
  888. {
  889. psJob->sInput.outputType = RIGHT_CHANNEL_MONO;
  890. psJob->sCodec.mode = 3;
  891. }
  892. }
  893. else if( !strcmp( arg+1, "RAWMONO" ) )
  894. {
  895. if( psJob->sInput.filetype == RAW )
  896. psJob->sInput.fReadStereo = FALSE;
  897. }
  898. else if( !strcmp( arg+1, "RAWSTEREO" ) )
  899. {
  900. if( psJob->sInput.filetype == RAW )
  901. psJob->sInput.fReadStereo = TRUE;
  902. }
  903. else if( !strcmp( arg+1, "RAWSIGNED" ) )
  904. {
  905. if( psJob->sInput.filetype == RAW )
  906. psJob->sInput.fSign = TRUE;
  908. }
  909. else if( !strcmp( arg+1, "RAWUNSIGNED" ) )
  910. {
  911. if( psJob->sInput.filetype == RAW )
  912. psJob->sInput.fSign = FALSE;
  914. }
  915. else if( strstr( arg+1, "RAWBITS=" ) == arg+1 )
  916. {
  917. if( psJob->sInput.filetype == RAW )
  918. {
  919. psJob->sInput.bits = atoi( arg+9 );
  920. if( psJob->sInput.bits != 8 && psJob->sInput.bits != 16 )
  921. psJob->sInput.bits = 16;
  922. }
  923. }
  924. else if( strstr( arg+1, "RAWFREQ=" ) == arg+1 )
  925. {
  926. if( psJob->sInput.filetype == RAW )
  927. psJob->sInput.freq = atoi( arg+9 );
  928. }
  929. else if( strstr( arg+1, "RAWBYTEORDER=" ) == arg+1 )
  930. {
  931. if( psJob->sInput.filetype == RAW )
  932. {
  933. if( strstr( arg+14, "LITTLE" ) == arg+14 )
  934. psJob->sInput.byteorder = LITTLE_ENDIAN;
  935. if( strstr( arg+14, "BIG" ) == arg+14 )
  936. psJob->sInput.byteorder = BIG_ENDIAN;
  937. if( strstr( arg+14, "DEFAULT" ) == arg+14 )
  938. psJob->sInput.byteorder = BYTEORDER;
  939. }
  940. }
  941. else if( strstr( arg+1, "RAWCHANNELS=" ) == arg+1 )
  942. {
  943. if( psJob->sInput.filetype == RAW )
  944. {
  945. psJob->sInput.fReadStereo = atoi( arg+13 )-1;
  946. if( psJob->sInput.fReadStereo != FALSE && psJob->sInput.fReadStereo != TRUE )
  947. psJob->sInput.fReadStereo = TRUE;
  948. }
  949. }
  951. else if( !strcmp( arg+1, "BR" ) )
  952. {
  953. pArgLink = pArgLink->psNext;
  954. if( pArgLink == NULL )
  955. return pArgLink;
  956. psJob->sCodec.bitrate = atoi( pArgLink->pString );
  957. if( psJob->sCodec.bitrate > 1000 )
  958. {
  959. psJob->sCodec.bitrate /= 1000;
  960. wantedQuit = TRUE;
  961. }
  962. }
  963. else if( !strcmp( arg+1, "HQ" ) )
  964. {
  965. wantedQuit = TRUE; /* Dummy for l3enc support */
  966. }
  967. else
  968. {
  969. y = 0;
  970. for( x = 1 ; arg[x] >= '0' && arg[x] <= '9' ; x++ )
  971. y = y * 10 + (arg[x] - '0');
  972. if( arg[x] == 0 )
  973. {
  974. psJob->sCodec.bitrate = y;
  975. if( psJob->sCodec.bitrate > 1000 )
  976. psJob->sCodec.bitrate /= 1000;
  977. }
  978. else
  979. return pArgLink;
  980. }
  981. }
  982. return  pArgLink;
  983. }
  987. /*____ validateJobs() _________________________________________________________*/
  989. int validateJobs( Job * psJob )
  990. {
  991. static  int     aValidBitrates[14] = { 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 };
  993. int i;
  994. int fOk = TRUE;
  996. while( psJob != NULL && fOk )
  997. {
  998. fOk = FALSE;
  999. for( i = 0 ; i < 14 ; i++ )
  1000. if( wantedBitrate == aValidBitrates[i] )
  1001. fOk = TRUE;
  1003. psJob = psJob->psNext;
  1004. }
  1006. if( fOk )
  1007. return TRUE;
  1009. fprintf( textout, "ERROR: %d is not a valid bitrate!nn", wantedBitrate );
  1011. fprintf( textout, "Valid bitrates are:nn" );
  1013. for( i = 0 ; i < 13 ; i++ )
  1014. fprintf( textout, "%d, ", aValidBitrates[i] );
  1016. fprintf( textout, "and %d kBit.n", aValidBitrates[13] );
  1018. return  FALSE;
  1019. }
  1022. /*____ printUsage() ___________________________________________________________*/
  1024. int     printUsage( void )
  1025. {
  1026. fprintf( textout, "Usage: bladeenc [global switches] input1 [output1 [switches]] input2 ...n" );
  1027. fprintf( textout, "n" );
  1028. fprintf( textout, "General switches:n" );
  1029. fprintf( textout, "  -[kbit], -br [kbit]  Set MP3 bitrate. Default is 128 (64 for mono output).n" );
  1030. fprintf( textout, "  -crc                 Include checksum data in MP3 file.n" );
  1031. fprintf( textout, "  -delete, -del        Delete sample after successful encoding.n" );
  1032. fprintf( textout, "  -private, -p         Set the private-flag in the output file.n" );
  1033. fprintf( textout, "  -copyright, -c       Set the copyright-flag in the output file.n" );
  1034. fprintf( textout, "  -copy                Clears the original-flag in the output file.n" );
  1035. fprintf( textout, "  -mono, -dm           Produce mono MP3 files by combining stereo channels.n" );
  1036. fprintf( textout, "  -leftmono, -lm       Produce mono MP3 files from left stereo channel only.n" );
  1037. fprintf( textout, "  -rightmono, -rm      Produce mono MP3 files from right stereo channel only.n" );
  1038. fprintf( textout, "  -swap                Swap left and right stereo channels.n" );
  1039. fprintf( textout, "  -rawfreq=[freq]      Specify frequency for RAW samples. Default is 44100.n" );
  1040. fprintf( textout, "  -rawbits=[bits]      Specify bits per channel for RAW samples. Default is 16.n" );
  1041. fprintf( textout, "  -rawmono             Specifies that RAW samples are in mono, not stereo.n" );
  1042.     fprintf( textout, "  -rawstereo           Specifies that RAW samples are in stereo (default).n" );
  1043. fprintf( textout, "  -rawsigned           Specifies that RAW samples are signed (default).n" );
  1044. fprintf( textout, "  -rawunsigned         Specifies that RAW samples are unsigned.n" );
  1045. #ifdef PAUSE_25_LINES
  1046. fprintf( textout, "Press ENTER to continue..." );
  1047. fflush( textout );
  1048. be_getch();
  1049. fprintf( textout, "n" );
  1050. #endif
  1051. fprintf( textout, "  -rawbyteorder=[order]Specifies byteorder for RAW samples, LITTLE or BIG.n" );
  1052. fprintf( textout, "  -rawchannels=[1/2]   Specifies number of channels for RAW samples. Doesn" );
  1053. fprintf( textout, "                       the same as -rawmono and -rawstereo respectively.n" );
  1054. fprintf( textout, "n" );
  1055. fprintf( textout, "Global only switches:n" );
  1056. fprintf( textout, "  -quit, -q            Quit without waiting for keypress when finished.n" );
  1057. fprintf( textout, "  -outdir=[dir]        Save MP3 files in specified directory.n" );
  1058. fprintf( textout, "  -quiet               Disable screen output.n" );
  1059. fprintf( textout, "  -nocfg               Don't take settings from the config-file.n" );
  1060. #ifdef  PRIO
  1061. fprintf( textout, "  -prio=[prio]         Sets the task priority for BladeEnc. Valid settings aren" );
  1062. fprintf( textout, "                       HIGHEST, HIGHER, NORMAL, LOWER, LOWEST(default) and IDLEn" );
  1063. #endif
  1064. fprintf( textout, "  -refresh=[rate]      Refresh rate for progress indicator. 1=fastest, 2=def.n" );
  1065. fprintf( textout, "  -progress=[0-8]      Which progress indicator to use. 0=Off, 1=Default.n" );
  1066. fprintf( textout, "n" );
  1067. fprintf( textout, "Input/output files can be replaced with STDIN and STDOUT respectively.n" );
  1068. #ifdef  DRAG_DROP
  1069. fprintf( textout, "To make a normal 128kBit MP3, just drag-n-drop your WAV onto the BladeEnc icon.n" );
  1070. #endif
  1071. fprintf( textout, "n" );
  1073. return  TRUE;
  1074. }
  1076. /*____ addCommandlineJob() ____________________________________________________*/
  1078. int addCommandlineJob( argLink ** ppArgLink )
  1079. {
  1080. char temp[256];
  1081. Job * psOp, * psTemp;
  1082. int x;
  1083. argLink * pArgLink;
  1085. pArgLink = * ppArgLink;
  1088. psOp = (Job *) malloc( sizeof( Job ) );
  1089. psOp->psNext = NULL;
  1092. /* Open Input File              */
  1094. strcpy( temp, pArgLink->pString );
  1095. mystrupr( temp );
  1096. if( strcmp( temp, "STDIN" ) == 0 )
  1097. {
  1098. if( !fPreparedSTDIN )
  1099. {
  1100. prepStdin();
  1101. fPreparedSTDIN = TRUE;
  1102. }
  1103. strcpy( psOp->sourceFilename, "Standard input stream" );
  1104. x = openInput( &psOp->sInput, NULL );
  1105. }
  1106. else
  1107. {
  1108. strcpy( psOp->sourceFilename, pArgLink->pString );
  1109. x = openInput( &psOp->sInput, pArgLink->pString );
  1110. }
  1112. if( x != TRUE )
  1113. {
  1114. switch( psOp->sInput.errcode )
  1115. {
  1116. case -1:
  1117. fprintf( textout, "ERROR: '%s' is not a WAV or AIFF file!n", psOp->sourceFilename );
  1118. break;
  1119. case -2:
  1120. fprintf( textout, "ERROR: Couldn't open '%s'!n", psOp->sourceFilename );
  1121. break;
  1122. case -3:
  1123. fprintf( textout, "ERROR: Unexpected end of file '%s'!n", psOp->sourceFilename );
  1124. break;
  1125. case -5:
  1126. fprintf( textout, "ERROR: Necessary chunk missing in '%s'!n", psOp->sourceFilename );
  1127. break;
  1128. case -6:
  1129. fprintf( textout, "ERROR: Sample '%s' is of an unknown subtype!n", psOp->sourceFilename );
  1130. break;
  1131. default:
  1132. fprintf( textout, "ERROR: Unknown error while opening '%s'!n", psOp->sourceFilename );
  1134. }
  1135. free( psOp );
  1136. return  FALSE;
  1137. }
  1139. /* If RAW, set default values */
  1141. if( psOp->sInput.filetype == RAW )
  1142. {
  1143. psOp->sInput.freq = rawFrequency;
  1144. psOp->sInput.outputFreq = rawFrequency;
  1145. psOp->sInput.fReadStereo = rawChannels-1;
  1146. psOp->sInput.bits = rawBits;
  1147. psOp->sInput.fSign = rawSigned;
  1148. psOp->sInput.byteorder = rawByteorder;
  1149. }
  1151. /* */
  1153. if( !psOp->sInput.fReadStereo && (wantedInputType == STEREO || wantedInputType == INVERSE_STEREO) )
  1154. psOp->sInput.outputType = DOWNMIX_MONO;
  1155. else
  1156. psOp->sInput.outputType = wantedInputType;
  1159. /* Set sCodec.mode (MONO or STEREO) */
  1161. if( psOp->sInput.outputType == DOWNMIX_MONO || psOp->sInput.outputType == LEFT_CHANNEL_MONO
  1162.         || psOp->sInput.outputType == RIGHT_CHANNEL_MONO )
  1163. psOp->sCodec.mode = 3;                                                   /* Force to mono... */
  1164. else
  1165. {
  1166. psOp->sCodec.mode = 0;
  1167. }
  1169. /* Set frequency */
  1171. if( psOp->sInput.freq != 44100 && psOp->sInput.freq != 48000
  1172.         && psOp->sInput.freq != 32000 )
  1173. {
  1174. fprintf( textout, "ERROR: Sample '%s' is not in 32, 44.1 or 48 kHz!n", psOp->sourceFilename );
  1175. closeInput( &(psOp->sInput) );
  1176. free( psOp );
  1177. return  FALSE;
  1178. }
  1180. psOp->sCodec.frequency = psOp->sInput.freq;
  1182. /* Set bitrate */
  1184. if( wantedBitrate == -1 )
  1185. {
  1186. if( psOp->sCodec.mode == 3 )
  1187. wantedBitrate = 64;
  1188. else
  1189. wantedBitrate = 128;
  1190. }
  1191. else
  1192. psOp->sCodec.bitrate = wantedBitrate;
  1195. /* Set other parameters */
  1197. psOp->sCodec.bitrate = wantedBitrate;
  1199. psOp->sCodec.fPrivate = wantedPrivate;
  1200. psOp->sCodec.fCRC = wantedCRC;
  1201. psOp->sCodec.fCopyright = wantedCopyright;
  1202. psOp->sCodec.fOriginal = wantedOriginal;
  1203. psOp->fDeleteSource = wantedDeleteSource;
  1206. /* Set unsupported parameters */
  1208. psOp->sCodec.emphasis = 0;
  1210. pArgLink = pArgLink->psNext;
  1212. /* Check for output specification and set output name */
  1214. psOp->outputFilename[0] = 0;
  1215. if( pArgLink != NULL )
  1216. {
  1217. strcpy( temp, pArgLink->pString );
  1218. mystrupr( temp );
  1219. if( !strcmp( temp, "STDOUT" ) )
  1220. {
  1221. wantedSTDOUT = TRUE;
  1222. strcpy( psOp->outputFilename, "STDOUT" );
  1223. pArgLink = pArgLink->psNext;
  1224. }
  1225. else if( strlen( temp ) >= 4 && !strcmp( temp+strlen(temp)-4, ".MP3" ) )
  1226. {
  1227. strcpy( psOp->outputFilename, pArgLink->pString );
  1228. pArgLink = pArgLink->psNext;
  1229. }
  1230. }
  1232. /* Generate output name if not allready set */
  1234. if( psOp->outputFilename[0] == 0 )
  1235. {
  1236. if( outputDir[0] != 0 )
  1237. {
  1238. strcpy( psOp->outputFilename, outputDir );
  1240. strcpy( temp, psOp->sourceFilename );
  1241. x = strlen( temp );
  1242. while( temp[x] != '.' && x >=0 && temp[x] != DIRECTORY_SEPARATOR )
  1243. x--;
  1245. if( temp[x] == DIRECTORY_SEPARATOR )
  1246. x = strlen(temp);
  1248. if( x >= 0 )
  1249. strcpy( temp + x, ".mp3" );
  1250. else
  1251. {
  1252. x = strlen( temp );
  1253. strcat( temp, ".mp3" );
  1254. }
  1256. while( x >= 0 && temp[x] != '\' && temp[x] != '/' && temp[x] != ':' )
  1257. x--;
  1258. x++;
  1260. strcat( psOp->outputFilename, temp + x );
  1261. }
  1262. else
  1263. {
  1264. strcpy( temp, psOp->sourceFilename );
  1265. x = strlen( temp );
  1266. while( temp[x] != '.' && x >=0 && temp[x] != DIRECTORY_SEPARATOR )
  1267. x--;
  1269. if( temp[x] == DIRECTORY_SEPARATOR )
  1270. x = strlen(temp);
  1272. if( x >= 0 )
  1273. strcpy( temp + x, ".mp3" );
  1274. else
  1275. strcat( temp, ".mp3" );
  1277. strcpy( psOp->outputFilename, temp );
  1278. }
  1279. }
  1282. /* Read local switches */
  1284. pArgLink = readLocalSwitches( pArgLink, psOp );
  1287. /* Put this Job in the batch */
  1289. if( psJobQueue == NULL )
  1290. psJobQueue = psOp;
  1291. else
  1292. {
  1293. psTemp = psJobQueue;
  1294. while( psTemp->psNext != NULL )
  1295. psTemp = psTemp->psNext;
  1296. psTemp->psNext = psOp;
  1297. }
  1299. * ppArgLink = pArgLink;
  1300. return  TRUE;
  1301. }
  1304. /*____ clearJobQueue() ________________________________________________________*/
  1306. int     clearJobQueue( void )
  1307. {
  1308. while( psJobQueue != NULL )
  1309. removeJobQueueEntry( psJobQueue );
  1310. return  TRUE;
  1311. }
  1314. /*____ removeQueueEntry() _____________________________________________________*/
  1316. int removeJobQueueEntry( Job * psJob )
  1317. {
  1318. Job     * psPrev;
  1320. /* Unlink specified entry */
  1322. if( psJob == psJobQueue )
  1323. psJobQueue = psJob->psNext;
  1324. else
  1325. {
  1326. psPrev = psJobQueue;
  1327. while( psPrev->psNext != psJobQueue && psPrev->psNext != NULL )
  1328. psPrev = psPrev->psNext;
  1330. if( psPrev->psNext == NULL )
  1331. return  FALSE;
  1333. psPrev->psNext = psJob->psNext;
  1334. }
  1336. /* Close open file, free the entry and return. */
  1338. closeInput( &psJob->sInput );
  1339. free( psJob );
  1340. return  TRUE;
  1341. }