void BleAudioEncoder_AAC::fini()
{
if (m_faacHandle) faacEncClose(m_faacHandle);
BleFreeArray(m_pInBuf);
BleFreeArray(m_outputBuffer);
}
/***********************************************************************
* Close
***********************************************************************
*
**********************************************************************/
void encfaacClose( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
if ( pv )
{
if ( pv->faac )
{
faacEncClose( pv->faac );
pv->faac = NULL;
}
if ( pv->buf )
{
free( pv->buf );
pv->buf = NULL;
}
if ( pv->obuf )
{
free( pv->obuf );
pv->obuf = NULL;
}
if ( pv->list )
hb_list_empty( &pv->list );
free( pv );
w->private_data = NULL;
}
}
/// Ïú»Ù±àÂëÆ÷
void CAacEncoder::Destroy(void)
{
if(NULL != m_hHandleEncoder)
{
faacEncClose(m_hHandleEncoder);
m_hHandleEncoder = NULL;
}
}
PcmToAac::~PcmToAac(void)
{
if (NULL != hEncoder)
{
/*Close FAAC engine*/
faacEncClose(hEncoder);
}
}
AUDMEncoder_Faac::~AUDMEncoder_Faac()
{
if(_handle)
faacEncClose(_handle);
_handle=NULL;
printf("[FAAC] Deleting faac\n");
cleanup();
};
AVDMProcessAudio_Faac::~AVDMProcessAudio_Faac()
{
delete(_wavheader);
if(_handle)
faacEncClose(_handle);
_handle=NULL;
_wavheader=NULL;
};
static av_cold int Faac_encode_close(AVCodecContext *avctx)
{
FaacAudioContext *s = avctx->priv_data;
av_freep(&avctx->coded_frame);
av_freep(&avctx->extradata);
faacEncClose(s->faac_handle);
return 0;
}
/*------------------------------------------------------------------------------
* Close the encoding session
*----------------------------------------------------------------------------*/
void
FaacEncoder :: close ( void ) throw ( Exception )
{
if ( isOpen() ) {
flush();
faacEncClose(encoderHandle);
faacOpen = false;
getSink()->close();
}
}
int FAACEncoder::Clean()
{
if (m_hfaac!=NULL)
{
faacEncEncode(m_hfaac, NULL, 0, m_pfaacbuffer, 4096);
faacEncClose(m_hfaac);
m_hfaac=NULL;
}
return 0;
}
int CAACEncoderManager::Clean()
{
EnterCriticalSection(&m_hcritical_section);
if (m_hAACEncoder!=NULL)
{
faacEncClose(m_hAACEncoder);
m_hAACEncoder=NULL;
}
LeaveCriticalSection(&m_hcritical_section);
return 0;
}
int aacEncoder::aacEncoderProcess(uint8_t* pdata, int pSize, uint8_t* outputBuffer)
{
if(interrupt)
{
faacEncClose(hEncoder);
return 0;
}
unsigned int bytesWritten;
unsigned int nBufferSize = pSize / (nPCMBitSize / 8);
bytesWritten = faacEncEncode(hEncoder, (int32_t*)pdata, nBufferSize, outputBuffer, nMaxOutputBytes);
return bytesWritten;
}
static av_cold int Faac_encode_close(AVCodecContext *avctx)
{
FaacAudioContext *s = avctx->priv_data;
av_freep(&avctx->extradata);
ff_af_queue_close(&s->afq);
if (s->faac_handle)
faacEncClose(s->faac_handle);
return 0;
}
static av_cold int Faac_encode_close(AVCodecContext *avctx)
{
FaacAudioContext *s = avctx->priv_data;
#if FF_API_OLD_ENCODE_AUDIO
av_freep(&avctx->coded_frame);
#endif
av_freep(&avctx->extradata);
ff_af_queue_close(&s->afq);
if (s->faac_handle)
faacEncClose(s->faac_handle);
return 0;
}
void ZAAC::Clean()
{
IsPlay=false;
if (hEncoder!=NULL)
{
faacEncClose(hEncoder);
hEncoder=NULL;
free(pbAACBuffer);
pbAACBuffer=NULL;
}
m_flv=NULL;
m_mp4=NULL;
// m_rtmp=NULL;
}
static int faac_stop(TCModuleInstance *self)
{
PrivateData *pd;
TC_MODULE_SELF_CHECK(self, "stop");
pd = self->userdata;
if (pd->handle) {
faacEncClose(pd->handle);
pd->handle = NULL;
}
return TC_OK;
}
g7712aac::~g7712aac()
{
/*Close FAAC engine*/
faacEncClose(hEncoder);
/*free the source of malloc*/
free(pbPCMBuffer);
pbPCMBuffer = NULL;
free(pbAACBuffer);
pbAACBuffer = NULL;
free(pbG711ABuffer);
pbG711ABuffer = NULL;
free(pbPCMTmpBuffer);
pbPCMTmpBuffer = NULL;
delete audio_buffer_;
}
/// ´´½¨±àÂëÆ÷
BOOL CAacEncoder::Create(void)
{
if(NULL != m_hHandleEncoder)
return FALSE;
m_hHandleEncoder = faacEncOpen(m_enFrequency, m_enChannel,
(unsigned long*)&m_nInputSamples, (unsigned long*)&m_nMaxOutputBytes);
faacEncConfigurationPtr pConfig = faacEncGetCurrentConfiguration(m_hHandleEncoder);
if(NULL != pConfig)
{
int nInputFormat = FAAC_INPUT_16BIT;
switch(m_enSample)
{
case ENUM_SAMPLE_8BIT:
nInputFormat = FAAC_INPUT_NULL;
break;
case ENUM_SAMPLE_16BIT:
nInputFormat = FAAC_INPUT_16BIT;
break;
default:
nInputFormat = FAAC_INPUT_16BIT;
break;
}
pConfig->version = MPEG4; //MPEG4;
pConfig->outputFormat = 1; //ADTS;
pConfig->inputFormat = nInputFormat; //FAAC_INPUT_16BIT;
pConfig->aacObjectType = LOW; //LOW;
pConfig->useTns = 0; //DEFAULT_TNS;
pConfig->shortctl = SHORTCTL_NORMAL; //SHORTCTL_NORMAL;
pConfig->allowMidside = 1;
pConfig->quantqual = m_nAudioQuant; //Audio Auant (0-100)
pConfig->bandWidth = m_nBandWidth; //Output Band Width
if(0 == faacEncSetConfiguration(m_hHandleEncoder, pConfig))
{
faacEncClose(m_hHandleEncoder);
m_hHandleEncoder = NULL;
}
}
return (NULL != m_hHandleEncoder);
}
AACStream::~AACStream()
{
INFO("Close AACStream...!!\n");
#ifdef AACSTREAM_DEBUG
if(pfOutputMIC!=NULL) {
fclose(pfOutputMIC);
}
if(pfOutputAAC!=NULL) {
fclose(pfOutputAAC);
}
#endif
faacEncClose(hEncoder);
free(pcmAACbuf);
free(bitbuf);
}
int encoder_uninitialize(unsigned long id)
{
if(!pestreams[id].firstwrite)
{
faacEncClose(pestreams[id].enchandle);
sys_mem_free(pestreams[id].floatbuffer);
sys_mem_free(pestreams[id].obuffer);
sys_mem_free(pestreams[id].cachebuffer);
if(!pestreams[id].ismp4)
{
sys_file_close(pestreams[id].fhandle);
}else{
MP4Close(pestreams[id].mp4file);
}
pestreams[id].firstwrite = 1;
}
return 1;
}
bool AudioEncoderFAAC::shutdown() {
if(encoder) {
faacEncClose(encoder);
encoder = NULL;
}
if(faac_buffer) {
delete[] faac_buffer;
faac_buffer = NULL;
}
if(output_file.size()) {
if(ofs.is_open()) {
ofs.close();
}
output_file.clear();
}
nbytes_out = 0;
nsamples_needed = 0;
return true;
}
VOID CSoundRecDlg::CloseDevice()
{
MMRESULT mRes=0;
if(m_hWaveIn)
{
UnPrepareBuffers();
mRes=waveInClose(m_hWaveIn);
}
if(m_hOPFile)
{
mRes=mmioAscend(m_hOPFile, &m_stckOut, 0);
if(mRes!=MMSYSERR_NOERROR)
{
StoreError(mRes,FALSE,"File: %s ,Line Number:%d",__FILE__,__LINE__);
}
mRes=mmioAscend(m_hOPFile, &m_stckOutRIFF, 0);
if(mRes!=MMSYSERR_NOERROR)
{
StoreError(mRes,FALSE,"File: %s ,Line Number:%d",__FILE__,__LINE__);
}
mmioClose(m_hOPFile,0);
m_hOPFile=NULL;
}
m_hWaveIn=NULL;
// Close FAAC encoder
int nRet = faacEncClose(m_hAACEncoder);
m_hAACEncoder = 0;
if (m_pbAACBuffer)
delete[] m_pbAACBuffer;
m_pbAACBuffer = NULL;
if (m_fpAACOutput)
fclose(m_fpAACOutput);
m_fpAACOutput = NULL;
}
static int faac_configure(TCModuleInstance *self,
const char *options,
TCJob *vob,
TCModuleExtraData *xdata[])
{
PrivateData *pd;
int samplerate = vob->mp3frequency ? vob->mp3frequency : vob->a_rate;
int ret;
unsigned long dummy;
faacEncConfiguration conf;
TC_MODULE_SELF_CHECK(self, "configure");
pd = self->userdata;
/* Save bytes per sample */
pd->bps = (vob->dm_chan * vob->dm_bits) / 8;
/* Create FAAC handle (freeing any old one that might be left over) */
if (pd->handle)
faacEncClose(pd->handle);
pd->handle = faacEncOpen(samplerate, vob->dm_chan, &pd->framesize, &dummy);
if (!pd->handle) {
tc_log_error(MOD_NAME, "FAAC initialization failed");
return TC_ERROR;
}
/* Set up our default audio parameters */
/* why can't just use a pointer here? -- FR */
/* Because the function returns a pointer to an internal buffer --AC */
conf = *faacEncGetCurrentConfiguration(pd->handle);
conf.mpegVersion = MPEG4;
conf.aacObjectType = MAIN;
conf.allowMidside = 1;
conf.useLfe = 0;
conf.useTns = 1;
conf.bitRate = vob->mp3bitrate / vob->dm_chan;
conf.bandWidth = 0; // automatic configuration
conf.quantqual = 100; // FIXME: quality should be a per-module setting
conf.outputFormat = 1;
if (vob->dm_bits != 16) {
tc_log_error(MOD_NAME, "Only 16-bit samples supported");
return TC_ERROR;
}
conf.inputFormat = FAAC_INPUT_16BIT;
conf.shortctl = SHORTCTL_NORMAL;
ret = optstr_get(options, "quality", "%li", &conf.quantqual);
if (ret >= 0) {
if (verbose >= TC_INFO) {
tc_log_info(MOD_NAME, "using quality=%li", conf.quantqual);
}
}
if (!faacEncSetConfiguration(pd->handle, &conf)) {
tc_log_error(MOD_NAME, "Failed to set FAAC configuration");
faacEncClose(pd->handle);
pd->handle = 0;
return TC_ERROR;
}
/* Allocate local audio buffer */
if (pd->audiobuf)
free(pd->audiobuf);
pd->audiobuf = tc_malloc(pd->framesize * pd->bps);
if (!pd->audiobuf) {
tc_log_error(MOD_NAME, "Unable to allocate audio buffer");
faacEncClose(pd->handle);
pd->handle = 0;
return TC_ERROR;
}
pd->need_flush = TC_FALSE;
return TC_OK;
}
static av_cold int Faac_encode_init(AVCodecContext *avctx)
{
FaacAudioContext *s = avctx->priv_data;
faacEncConfigurationPtr faac_cfg;
unsigned long samples_input, max_bytes_output;
/* number of channels */
if (avctx->channels < 1 || avctx->channels > 6) {
av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed\n", avctx->channels);
return -1;
}
s->faac_handle = faacEncOpen(avctx->sample_rate,
avctx->channels,
&samples_input, &max_bytes_output);
/* check faac version */
faac_cfg = faacEncGetCurrentConfiguration(s->faac_handle);
if (faac_cfg->version != FAAC_CFG_VERSION) {
av_log(avctx, AV_LOG_ERROR, "wrong libfaac version (compiled for: %d, using %d)\n", FAAC_CFG_VERSION, faac_cfg->version);
faacEncClose(s->faac_handle);
return -1;
}
/* put the options in the configuration struct */
switch(avctx->profile) {
case FF_PROFILE_AAC_MAIN:
faac_cfg->aacObjectType = MAIN;
break;
case FF_PROFILE_UNKNOWN:
case FF_PROFILE_AAC_LOW:
faac_cfg->aacObjectType = LOW;
break;
case FF_PROFILE_AAC_SSR:
faac_cfg->aacObjectType = SSR;
break;
case FF_PROFILE_AAC_LTP:
faac_cfg->aacObjectType = LTP;
break;
default:
av_log(avctx, AV_LOG_ERROR, "invalid AAC profile\n");
faacEncClose(s->faac_handle);
return -1;
}
faac_cfg->mpegVersion = MPEG4;
faac_cfg->useTns = 0;
faac_cfg->allowMidside = 1;
faac_cfg->bitRate = avctx->bit_rate / avctx->channels;
faac_cfg->bandWidth = avctx->cutoff;
if(avctx->flags & CODEC_FLAG_QSCALE) {
faac_cfg->bitRate = 0;
faac_cfg->quantqual = avctx->global_quality / FF_QP2LAMBDA;
}
faac_cfg->outputFormat = 1;
faac_cfg->inputFormat = FAAC_INPUT_16BIT;
avctx->frame_size = samples_input / avctx->channels;
avctx->coded_frame= avcodec_alloc_frame();
avctx->coded_frame->key_frame= 1;
/* Set decoder specific info */
avctx->extradata_size = 0;
if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
unsigned char *buffer = NULL;
unsigned long decoder_specific_info_size;
if (!faacEncGetDecoderSpecificInfo(s->faac_handle, &buffer,
&decoder_specific_info_size)) {
avctx->extradata = av_malloc(decoder_specific_info_size + FF_INPUT_BUFFER_PADDING_SIZE);
avctx->extradata_size = decoder_specific_info_size;
memcpy(avctx->extradata, buffer, avctx->extradata_size);
faac_cfg->outputFormat = 0;
}
#undef free
free(buffer);
#define free please_use_av_free
}
if (!faacEncSetConfiguration(s->faac_handle, faac_cfg)) {
av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
return -1;
}
return 0;
}
bool BleAudioEncoder_AAC::init(int samplerate, int channel, int bitrate)
{
if (channel < 1 || channel > 6)
return false;
m_samplerate = samplerate;
m_channels = channel;
m_bitrate = bitrate;
faacEncConfigurationPtr aacConfig;
m_faacHandle = faacEncOpen(m_samplerate, m_channels, &m_samplesInputSize, &m_maxOutputSize);
// check faac version
aacConfig = faacEncGetCurrentConfiguration(m_faacHandle);
if (aacConfig->version != FAAC_CFG_VERSION)
{
faacEncClose(m_faacHandle);
log_error("faacEncGetCurrentConfiguration failed");
return false;
}
// reserve reuseable output buffer
m_outputBuffer = new unsigned char[m_maxOutputSize];
// put the options in the configuration struct.
aacConfig->aacObjectType = LOW; // MAIN
aacConfig->mpegVersion = MPEG4;
aacConfig->useTns = 1;
aacConfig->useLfe = 1;
aacConfig->allowMidside = 1;
aacConfig->bitRate = m_bitrate / channel;
aacConfig->bandWidth = 0;
aacConfig->quantqual = 100;
aacConfig->outputFormat = 0;
aacConfig->inputFormat = FAAC_INPUT_16BIT;
aacConfig->shortctl = SHORTCTL_NORMAL;
if (!faacEncSetConfiguration(m_faacHandle, aacConfig))
{
log_error("faacEncSetConfiguration failed");
return false;
}
m_nFrameSize = m_samplesInputSize / channel;
m_pInBuf = new int32_t[m_samplesInputSize];
// set decoder specific info
unsigned long extradata_size = 0;
unsigned char *buffer;
unsigned long decoder_specific_info_size;
if (!faacEncGetDecoderSpecificInfo(m_faacHandle, &buffer, &decoder_specific_info_size)) {
extradata_size = decoder_specific_info_size;
}
log_trace("aac encoder extradata_size=%d", extradata_size);
m_header.clear();
unsigned char af[2] = {0xaf, 0x00};
m_header.append((char *)af, 2);
m_header.append((char*)buffer, extradata_size);
BleFreeArray(buffer);
return true;
}
int main(int argc, char* argv[])
{
unsigned long nSampleRate = 11025; // 采样率
unsigned int nChannels = 1; // 声道数
unsigned int nPCMBitSize = 16; // 单样本位数
unsigned long nInputSamples = 0;
unsigned long nMaxOutputBytes = 0;
int nRet;
faacEncHandle hEncoder;
faacEncConfigurationPtr pConfiguration;
int nBytesRead;
int nPCMBufferSize;
unsigned char* pbPCMBuffer;
unsigned char* pbAACBuffer;
FILE* fpIn; // WAV file for input
FILE* fpOut; // AAC file for output
fpIn = fopen("in.wav", "rb");
fpOut = fopen("out.aac", "wb");
// (1) Open FAAC engine
hEncoder = faacEncOpen(nSampleRate, nChannels, &nInputSamples, &nMaxOutputBytes);
if(hEncoder == NULL) {
printf("[ERROR] Failed to call faacEncOpen()\n");
return -1;
}
nPCMBufferSize = nInputSamples * nPCMBitSize / 8;
pbPCMBuffer = new unsigned char [nPCMBufferSize];
pbAACBuffer = new unsigned char [nMaxOutputBytes];
// (2.1) Get current encoding configuration
pConfiguration = faacEncGetCurrentConfiguration(hEncoder);
pConfiguration->inputFormat = FAAC_INPUT_16BIT;
// (2.2) Set encoding configuration
nRet = faacEncSetConfiguration(hEncoder, pConfiguration);
for(int i = 0; 1; i++) {
// 读入的实际字节数，最大不会超过nPCMBufferSize，一般只有读到文件尾时才不是这个值
nBytesRead = fread(pbPCMBuffer, 1, nPCMBufferSize, fpIn);
// 输入样本数，用实际读入字节数计算，一般只有读到文件尾时才不是nPCMBufferSize/(nPCMBitSize/8);
nInputSamples = nBytesRead / (nPCMBitSize / 8);
// (3) Encode
nRet = faacEncEncode(
hEncoder, (int*) pbPCMBuffer, nInputSamples, pbAACBuffer, nMaxOutputBytes);
fwrite(pbAACBuffer, 1, nRet, fpOut);
printf("%d: faacEncEncode returns %d\n", i, nRet);
if(nBytesRead <= 0) {
break;
}
}
// (4) Close FAAC engine
nRet = faacEncClose(hEncoder);
delete[] pbPCMBuffer;
delete[] pbAACBuffer;
fclose(fpIn);
fclose(fpOut);
//getchar();
return 0;
}
static int Faac_encode_init(AVCodecContext *avctx)
{
FaacAudioContext *s = avctx->priv_data;
faacEncConfigurationPtr faac_cfg;
unsigned long samples_input, max_bytes_output;
/* number of channels */
if (avctx->channels < 1 || avctx->channels > 6)
return -1;
s->faac_handle = faacEncOpen(avctx->sample_rate,
avctx->channels,
&samples_input, &max_bytes_output);
/* check faac version */
faac_cfg = faacEncGetCurrentConfiguration(s->faac_handle);
if (faac_cfg->version != FAAC_CFG_VERSION) {
av_log(avctx, AV_LOG_ERROR, "wrong libfaac version (compiled for: %d, using %d)\n", FAAC_CFG_VERSION, faac_cfg->version);
faacEncClose(s->faac_handle);
return -1;
}
/* put the options in the configuration struct */
faac_cfg->aacObjectType = LOW;
faac_cfg->mpegVersion = MPEG4;
faac_cfg->useTns = 0;
faac_cfg->allowMidside = 1;
faac_cfg->bitRate = avctx->bit_rate / avctx->channels;
if(avctx->flags & CODEC_FLAG_QSCALE) {
faac_cfg->bitRate = 0;
faac_cfg->quantqual = avctx->global_quality / FF_QP2LAMBDA;
}
faac_cfg->outputFormat = 0;
faac_cfg->inputFormat = FAAC_INPUT_16BIT;
if (!faacEncSetConfiguration(s->faac_handle, faac_cfg)) {
av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
return -1;
}
avctx->frame_size = samples_input / avctx->channels;
avctx->coded_frame= avcodec_alloc_frame();
avctx->coded_frame->key_frame= 1;
/* Set decoder specific info */
avctx->extradata_size = 0;
if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
unsigned char *buffer;
unsigned long decoder_specific_info_size;
if (!faacEncGetDecoderSpecificInfo(s->faac_handle, &buffer,
&decoder_specific_info_size)) {
avctx->extradata = buffer;
avctx->extradata_size = decoder_specific_info_size;
}
}
return 0;
}
int main(int argc, char *argv[])
{
int frames, currentFrame;
faacEncHandle hEncoder;
pcmfile_t *infile = NULL;
unsigned long samplesInput, maxBytesOutput, totalBytesWritten=0;
faacEncConfigurationPtr myFormat;
unsigned int mpegVersion = MPEG2;
unsigned int objectType = LOW;
unsigned int useMidSide = 1;
static unsigned int useTns = DEFAULT_TNS;
enum container_format container = NO_CONTAINER;
int optimizeFlag = 0;
enum stream_format stream = ADTS_STREAM;
int cutOff = -1;
int bitRate = 0;
unsigned long quantqual = 0;
int chanC = 3;
int chanLF = 4;
char *audioFileName = NULL;
char *aacFileName = NULL;
char *aacFileExt = NULL;
int aacFileNameGiven = 0;
float *pcmbuf;
int *chanmap = NULL;
unsigned char *bitbuf;
int samplesRead = 0;
const char *dieMessage = NULL;
int rawChans = 0; // disabled by default
int rawBits = 16;
int rawRate = 44100;
int rawEndian = 1;
int shortctl = SHORTCTL_NORMAL;
FILE *outfile = NULL;
#ifdef HAVE_LIBMP4V2
MP4FileHandle MP4hFile = MP4_INVALID_FILE_HANDLE;
MP4TrackId MP4track = 0;
unsigned int ntracks = 0, trackno = 0;
unsigned int ndiscs = 0, discno = 0;
u_int8_t compilation = 0;
const char *artist = NULL, *title = NULL, *album = NULL, *year = NULL,
*genre = NULL, *comment = NULL, *writer = NULL;
u_int8_t *art = NULL;
u_int64_t artSize = 0;
u_int64_t total_samples = 0;
u_int64_t encoded_samples = 0;
unsigned int delay_samples;
unsigned int frameSize;
#endif
char *faac_id_string;
char *faac_copyright_string;
#ifndef _WIN32
// install signal handler
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
#endif
// get faac version
if (faacEncGetVersion(&faac_id_string, &faac_copyright_string) == FAAC_CFG_VERSION)
{
fprintf(stderr, "Freeware Advanced Audio Coder\nFAAC %s\n\n", faac_id_string);
}
else
{
fprintf(stderr, __FILE__ "(%d): wrong libfaac version\n", __LINE__);
return 1;
}
/* begin process command line */
progName = argv[0];
while (1) {
static struct option long_options[] = {
{ "help", 0, 0, 'h'},
{ "long-help", 0, 0, 'H'},
{ "raw", 0, 0, 'r'},
{ "no-midside", 0, 0, NO_MIDSIDE_FLAG},
{ "cutoff", 1, 0, 'c'},
{ "quality", 1, 0, 'q'},
{ "pcmraw", 0, 0, 'P'},
{ "pcmsamplerate", 1, 0, 'R'},
{ "pcmsamplebits", 1, 0, 'B'},
{ "pcmchannels", 1, 0, 'C'},
{ "shortctl", 1, 0, SHORTCTL_FLAG},
{ "tns", 0, 0, TNS_FLAG},
{ "no-tns", 0, 0, NO_TNS_FLAG},
{ "mpeg-version", 1, 0, MPEGVERS_FLAG},
{ "obj-type", 1, 0, OBJTYPE_FLAG},
{ "license", 0, 0, 'L'},
#ifdef HAVE_LIBMP4V2
{ "createmp4", 0, 0, 'w'},
{ "optimize", 0, 0, 's'},
{ "artist", 1, 0, ARTIST_FLAG},
{ "title", 1, 0, TITLE_FLAG},
{ "album", 1, 0, ALBUM_FLAG},
{ "track", 1, 0, TRACK_FLAG},
{ "disc", 1, 0, DISC_FLAG},
{ "genre", 1, 0, GENRE_FLAG},
{ "year", 1, 0, YEAR_FLAG},
{ "cover-art", 1, 0, COVER_ART_FLAG},
{ "comment", 1, 0, COMMENT_FLAG},
{ "writer", 1, 0, WRITER_FLAG},
{ "compilation", 0, 0, COMPILATION_FLAG},
#endif
{ "pcmswapbytes", 0, 0, 'X'},
{ 0, 0, 0, 0}
};
int c = -1;
int option_index = 0;
c = getopt_long(argc, argv, "Hhb:m:o:rnc:q:PR:B:C:I:X"
#ifdef HAVE_LIBMP4V2
"ws"
#endif
,long_options, &option_index);
if (c == -1)
break;
if (!c)
{
dieMessage = usage;
break;
}
switch (c) {
case 'o':
{
int l = strlen(optarg);
aacFileName = malloc(l+1);
memcpy(aacFileName, optarg, l);
aacFileName[l] = '\0';
aacFileNameGiven = 1;
}
break;
case 'r': {
stream = RAW_STREAM;
break;
}
case NO_MIDSIDE_FLAG: {
useMidSide = 0;
break;
}
case 'c': {
unsigned int i;
if (sscanf(optarg, "%u", &i) > 0) {
cutOff = i;
}
break;
}
case 'b': {
unsigned int i;
if (sscanf(optarg, "%u", &i) > 0)
{
bitRate = 1000 * i;
}
break;
}
case 'q':
{
unsigned int i;
if (sscanf(optarg, "%u", &i) > 0)
{
if (i > 0 && i < 1000)
quantqual = i;
}
break;
}
case 'I':
sscanf(optarg, "%d,%d", &chanC, &chanLF);
break;
case 'P':
rawChans = 2; // enable raw input
break;
case 'R':
{
unsigned int i;
if (sscanf(optarg, "%u", &i) > 0)
{
rawRate = i;
rawChans = (rawChans > 0) ? rawChans : 2;
}
break;
}
case 'B':
{
unsigned int i;
if (sscanf(optarg, "%u", &i) > 0)
{
if (i > 32)
i = 32;
if (i < 8)
i = 8;
rawBits = i;
rawChans = (rawChans > 0) ? rawChans : 2;
}
break;
}
case 'C':
{
unsigned int i;
if (sscanf(optarg, "%u", &i) > 0)
rawChans = i;
break;
}
#ifdef HAVE_LIBMP4V2
case 'w':
container = MP4_CONTAINER;
break;
case 's':
optimizeFlag = 1;
break;
case ARTIST_FLAG:
artist = optarg;
break;
case WRITER_FLAG:
writer = optarg;
break;
case TITLE_FLAG:
title = optarg;
break;
case ALBUM_FLAG:
album = optarg;
break;
case TRACK_FLAG:
sscanf(optarg, "%d/%d", &trackno, &ntracks);
break;
case DISC_FLAG:
sscanf(optarg, "%d/%d", &discno, &ndiscs);
break;
case COMPILATION_FLAG:
compilation = 0x1;
break;
case GENRE_FLAG:
genre = optarg;
break;
case YEAR_FLAG:
year = optarg;
break;
case COMMENT_FLAG:
comment = optarg;
break;
case COVER_ART_FLAG: {
FILE *artFile = fopen(optarg, "rb");
if(artFile) {
u_int64_t r;
fseek(artFile, 0, SEEK_END);
artSize = ftell(artFile);
art = malloc(artSize);
fseek(artFile, 0, SEEK_SET);
clearerr(artFile);
r = fread(art, artSize, 1, artFile);
if (r != 1) {
dieMessage = "Error reading cover art file!\n";
free(art);
art = NULL;
} else if (artSize < 12 || !check_image_header(art)) {
/* the above expression checks the image signature */
dieMessage = "Unsupported cover image file format!\n";
free(art);
art = NULL;
}
fclose(artFile);
} else {
dieMessage = "Error opening cover art file!\n";
}
break;
}
#endif
case SHORTCTL_FLAG:
shortctl = atoi(optarg);
break;
case TNS_FLAG:
useTns = 1;
break;
case NO_TNS_FLAG:
useTns = 0;
break;
case MPEGVERS_FLAG:
mpegVersion = atoi(optarg);
switch(mpegVersion)
{
case 2:
mpegVersion = MPEG2;
break;
case 4:
mpegVersion = MPEG4;
break;
default:
dieMessage = "Unrecognised MPEG version!\n";
}
break;
#if 0
case OBJTYPE_FLAG:
if (!strcasecmp(optarg, "LC"))
objectType = LOW;
else if (!strcasecmp(optarg, "Main"))
objectType = MAIN;
else if (!strcasecmp(optarg, "LTP")) {
mpegVersion = MPEG4;
objectType = LTP;
} else
dieMessage = "Unrecognised object type!\n";
break;
#endif
case 'L':
fprintf(stderr, faac_copyright_string);
dieMessage = license;
break;
case 'X':
rawEndian = 0;
break;
case 'H':
dieMessage = long_help;
break;
case 'h':
dieMessage = short_help;
break;
case '?':
default:
dieMessage = usage;
break;
}
}
/* check that we have at least one non-option arguments */
if (!dieMessage && (argc - optind) > 1 && aacFileNameGiven)
dieMessage = "Cannot encode several input files to one output file.\n";
if (argc - optind < 1 || dieMessage)
{
fprintf(stderr, dieMessage ? dieMessage : usage,
progName, progName, progName, progName);
return 1;
}
while (argc - optind > 0) {
/* get the input file name */
audioFileName = argv[optind++];
/* generate the output file name, if necessary */
if (!aacFileNameGiven) {
char *t = strrchr(audioFileName, '.');
int l = t ? strlen(audioFileName) - strlen(t) : strlen(audioFileName);
#ifdef HAVE_LIBMP4V2
aacFileExt = container == MP4_CONTAINER ? ".m4a" : ".aac";
#else
aacFileExt = ".aac";
#endif
aacFileName = malloc(l+1+4);
memcpy(aacFileName, audioFileName, l);
memcpy(aacFileName + l, aacFileExt, 4);
aacFileName[l+4] = '\0';
} else {
aacFileExt = strrchr(aacFileName, '.');
if (aacFileExt && (!strcmp(".m4a", aacFileExt) || !strcmp(".m4b", aacFileExt) || !strcmp(".mp4", aacFileExt)))
#ifndef HAVE_LIBMP4V2
fprintf(stderr, "WARNING: MP4 support unavailable!\n");
#else
container = MP4_CONTAINER;
#endif
}
/* open the audio input file */
if (rawChans > 0) // use raw input
{
infile = wav_open_read(audioFileName, 1);
if (infile)
{
infile->bigendian = rawEndian;
infile->channels = rawChans;
infile->samplebytes = rawBits / 8;
infile->samplerate = rawRate;
infile->samples /= (infile->channels * infile->samplebytes);
}
}
else // header input
infile = wav_open_read(audioFileName, 0);
if (infile == NULL)
{
fprintf(stderr, "Couldn't open input file %s\n", audioFileName);
return 1;
}
/* open the encoder library */
hEncoder = faacEncOpen(infile->samplerate, infile->channels,
&samplesInput, &maxBytesOutput);
#ifdef HAVE_LIBMP4V2
if (container != MP4_CONTAINER && (ntracks || trackno || artist ||
title || album || year || art ||
genre || comment || discno || ndiscs ||
writer || compilation))
{
fprintf(stderr, "Metadata requires MP4 output!\n");
return 1;
}
if (container == MP4_CONTAINER)
{
mpegVersion = MPEG4;
stream = RAW_STREAM;
}
frameSize = samplesInput/infile->channels;
delay_samples = frameSize; // encoder delay 1024 samples
#endif
pcmbuf = (float *)malloc(samplesInput*sizeof(float));
bitbuf = (unsigned char*)malloc(maxBytesOutput*sizeof(unsigned char));
chanmap = mkChanMap(infile->channels, chanC, chanLF);
if (chanmap)
{
fprintf(stderr, "Remapping input channels: Center=%d, LFE=%d\n",
chanC, chanLF);
}
if (cutOff <= 0)
{
if (cutOff < 0) // default
cutOff = 0;
else // disabled
cutOff = infile->samplerate / 2;
}
if (cutOff > (infile->samplerate / 2))
cutOff = infile->samplerate / 2;
/* put the options in the configuration struct */
myFormat = faacEncGetCurrentConfiguration(hEncoder);
myFormat->aacObjectType = objectType;
myFormat->mpegVersion = mpegVersion;
myFormat->useTns = useTns;
switch (shortctl)
{
case SHORTCTL_NOSHORT:
fprintf(stderr, "disabling short blocks\n");
myFormat->shortctl = shortctl;
break;
case SHORTCTL_NOLONG:
fprintf(stderr, "disabling long blocks\n");
myFormat->shortctl = shortctl;
break;
}
if (infile->channels >= 6)
myFormat->useLfe = 1;
myFormat->allowMidside = useMidSide;
if (bitRate)
myFormat->bitRate = bitRate / infile->channels;
myFormat->bandWidth = cutOff;
if (quantqual > 0)
myFormat->quantqual = quantqual;
myFormat->outputFormat = stream;
myFormat->inputFormat = FAAC_INPUT_FLOAT;
if (!faacEncSetConfiguration(hEncoder, myFormat)) {
fprintf(stderr, "Unsupported output format!\n");
#ifdef HAVE_LIBMP4V2
if (container == MP4_CONTAINER) MP4Close(MP4hFile);
#endif
return 1;
}
#ifdef HAVE_LIBMP4V2
/* initialize MP4 creation */
if (container == MP4_CONTAINER) {
unsigned char *ASC = 0;
unsigned long ASCLength = 0;
char *version_string;
#ifdef MP4_CREATE_EXTENSIBLE_FORMAT
/* hack to compile against libmp4v2 >= 1.0RC3
* why is there no version identifier in mp4.h? */
MP4hFile = MP4Create(aacFileName, MP4_DETAILS_ERROR, 0);
#else
MP4hFile = MP4Create(aacFileName, MP4_DETAILS_ERROR, 0, 0);
#endif
if (!MP4_IS_VALID_FILE_HANDLE(MP4hFile)) {
fprintf(stderr, "Couldn't create output file %s\n", aacFileName);
return 1;
}
MP4SetTimeScale(MP4hFile, 90000);
MP4track = MP4AddAudioTrack(MP4hFile, infile->samplerate, MP4_INVALID_DURATION, MP4_MPEG4_AUDIO_TYPE);
MP4SetAudioProfileLevel(MP4hFile, 0x0F);
faacEncGetDecoderSpecificInfo(hEncoder, &ASC, &ASCLength);
MP4SetTrackESConfiguration(MP4hFile, MP4track, ASC, ASCLength);
free(ASC);
/* set metadata */
version_string = malloc(strlen(faac_id_string) + 6);
strcpy(version_string, "FAAC ");
strcpy(version_string + 5, faac_id_string);
MP4SetMetadataTool(MP4hFile, version_string);
free(version_string);
if (artist) MP4SetMetadataArtist(MP4hFile, artist);
if (writer) MP4SetMetadataWriter(MP4hFile, writer);
if (title) MP4SetMetadataName(MP4hFile, title);
if (album) MP4SetMetadataAlbum(MP4hFile, album);
if (trackno > 0) MP4SetMetadataTrack(MP4hFile, trackno, ntracks);
if (discno > 0) MP4SetMetadataDisk(MP4hFile, discno, ndiscs);
if (compilation) MP4SetMetadataCompilation(MP4hFile, compilation);
if (year) MP4SetMetadataYear(MP4hFile, year);
if (genre) MP4SetMetadataGenre(MP4hFile, genre);
if (comment) MP4SetMetadataComment(MP4hFile, comment);
if (artSize) {
MP4SetMetadataCoverArt(MP4hFile, art, artSize);
free(art);
}
}
else
{
#endif
/* open the aac output file */
if (!strcmp(aacFileName, "-"))
{
outfile = stdout;
}
else
{
outfile = fopen(aacFileName, "wb");
}
if (!outfile)
{
fprintf(stderr, "Couldn't create output file %s\n", aacFileName);
return 1;
}
#ifdef HAVE_LIBMP4V2
}
#endif
cutOff = myFormat->bandWidth;
quantqual = myFormat->quantqual;
bitRate = myFormat->bitRate;
if (bitRate)
fprintf(stderr, "Average bitrate: %d kbps\n",
(bitRate + 500)/1000*infile->channels);
fprintf(stderr, "Quantization quality: %ld\n", quantqual);
fprintf(stderr, "Bandwidth: %d Hz\n", cutOff);
fprintf(stderr, "Object type: ");
switch(objectType)
{
case LOW:
fprintf(stderr, "Low Complexity");
break;
case MAIN:
fprintf(stderr, "Main");
break;
case LTP:
fprintf(stderr, "LTP");
break;
}
fprintf(stderr, "(MPEG-%d)", (mpegVersion == MPEG4) ? 4 : 2);
if (myFormat->useTns)
fprintf(stderr, " + TNS");
if (myFormat->allowMidside)
fprintf(stderr, " + M/S");
fprintf(stderr, "\n");
fprintf(stderr, "Container format: ");
switch(container)
{
case NO_CONTAINER:
switch(stream)
{
case RAW_STREAM:
fprintf(stderr, "Headerless AAC (RAW)\n");
break;
case ADTS_STREAM:
fprintf(stderr, "Transport Stream (ADTS)\n");
break;
}
break;
#ifdef HAVE_LIBMP4V2
case MP4_CONTAINER:
fprintf(stderr, "MPEG-4 File Format (MP4)\n");
break;
#endif
}
if (outfile
#ifdef HAVE_LIBMP4V2
|| MP4hFile != MP4_INVALID_FILE_HANDLE
#endif
)
{
int showcnt = 0;
#ifdef _WIN32
long begin = GetTickCount();
#endif
if (infile->samples)
frames = ((infile->samples + 1023) / 1024) + 1;
else
frames = 0;
currentFrame = 0;
fprintf(stderr, "Encoding %s to %s\n", audioFileName, aacFileName);
if (frames != 0)
fprintf(stderr, " frame | bitrate | elapsed/estim | "
"play/CPU | ETA\n");
else
fprintf(stderr, " frame | elapsed | play/CPU\n");
/* encoding loop */
#ifdef _WIN32
for (;;)
#else
while (running)
#endif
{
int bytesWritten;
samplesRead = wav_read_float32(infile, pcmbuf, samplesInput, chanmap);
#ifdef HAVE_LIBMP4V2
total_samples += samplesRead / infile->channels;
#endif
/* call the actual encoding routine */
bytesWritten = faacEncEncode(hEncoder,
(int32_t *)pcmbuf,
samplesRead,
bitbuf,
maxBytesOutput);
if (bytesWritten)
{
currentFrame++;
showcnt--;
totalBytesWritten += bytesWritten;
}
if ((showcnt <= 0) || !bytesWritten)
{
double timeused;
#ifdef __unix__
struct rusage usage;
#endif
#ifdef _WIN32
char percent[MAX_PATH + 20];
timeused = (GetTickCount() - begin) * 1e-3;
#else
#ifdef __unix__
if (getrusage(RUSAGE_SELF, &usage) == 0) {
timeused = (double)usage.ru_utime.tv_sec +
(double)usage.ru_utime.tv_usec * 1e-6;
}
else
timeused = 0;
#else
timeused = (double)clock() * (1.0 / CLOCKS_PER_SEC);
#endif
#endif
if (currentFrame && (timeused > 0.1))
{
showcnt += 50;
if (frames != 0)
fprintf(stderr,
"\r%5d/%-5d (%3d%%)| %5.1f | %6.1f/%-6.1f | %7.2fx | %.1f ",
currentFrame, frames, currentFrame*100/frames,
((double)totalBytesWritten * 8.0 / 1000.0) /
((double)infile->samples / infile->samplerate * currentFrame / frames),
timeused,
timeused * frames / currentFrame,
(1024.0 * currentFrame / infile->samplerate) / timeused,
timeused * (frames - currentFrame) / currentFrame);
else
fprintf(stderr,
"\r %5d | %6.1f | %7.2fx ",
currentFrame,
timeused,
(1024.0 * currentFrame / infile->samplerate) / timeused);
fflush(stderr);
#ifdef _WIN32
if (frames != 0)
{
sprintf(percent, "%.2f%% encoding %s",
100.0 * currentFrame / frames, audioFileName);
SetConsoleTitle(percent);
}
#endif
}
}
/* all done, bail out */
if (!samplesRead && !bytesWritten)
break ;
if (bytesWritten < 0)
{
fprintf(stderr, "faacEncEncode() failed\n");
break ;
}
if (bytesWritten > 0)
{
#ifdef HAVE_LIBMP4V2
u_int64_t samples_left = total_samples - encoded_samples + delay_samples;
MP4Duration dur = samples_left > frameSize ? frameSize : samples_left;
MP4Duration ofs = encoded_samples > 0 ? 0 : delay_samples;
if (container == MP4_CONTAINER)
{
/* write bitstream to mp4 file */
MP4WriteSample(MP4hFile, MP4track, bitbuf, bytesWritten, dur, ofs, 1);
}
else
{
#endif
/* write bitstream to aac file */
fwrite(bitbuf, 1, bytesWritten, outfile);
#ifdef HAVE_LIBMP4V2
}
encoded_samples += dur;
#endif
}
}
#ifdef HAVE_LIBMP4V2
/* clean up */
if (container == MP4_CONTAINER)
{
MP4Close(MP4hFile);
if (optimizeFlag == 1)
{
fprintf(stderr, "\n\nMP4 format optimization... ");
MP4Optimize(aacFileName, NULL, 0);
fprintf(stderr, "Done!");
}
} else
#endif
fclose(outfile);
fprintf(stderr, "\n\n");
}
faacEncClose(hEncoder);
wav_close(infile);
if (pcmbuf) free(pcmbuf);
if (bitbuf) free(bitbuf);
if (aacFileNameGiven) free(aacFileName);
}
return 0;
}
main(int argc, char **argv) {
int quality = atol(argv[1]);
int type = atol(argv[2]);
long samplerate = 16000;
long channels = 1;
long samples_input;
long max_bytes_output;
faacEncHandle hEncoder;
faacEncConfigurationPtr mformat;
hEncoder = faacEncOpen(samplerate, channels, &samples_input, &max_bytes_output);
printf("Samples input: %ld max_bytes: %ld\n", samples_input, max_bytes_output);
uint16_t big_input[4096];
uint16_t input[samples_input];
char output[max_bytes_output];
mformat = faacEncGetCurrentConfiguration(hEncoder);
printf("aacObjectType %d, bitRate %ld, inputFormat %d, outputFormat %d, quantqual %ld, useTns %d, bandWidth %d\n", mformat->aacObjectType, mformat->bitRate, mformat->inputFormat, mformat->outputFormat, mformat->quantqual, mformat->useTns, mformat->bandWidth);
mformat->inputFormat = FAAC_INPUT_16BIT;
mformat->outputFormat = 1; // ADTP format
mformat->quantqual = quality;
mformat->aacObjectType = type;
if (! faacEncSetConfiguration(hEncoder, mformat)) {
puts("Don't accept");
exit(1);
}
printf("aacObjectType %d, bitRate %ld, inputFormat %d, outputFormat %d, quantqual %ld, useTns %d, bandWidth %d\n", mformat->aacObjectType, mformat->bitRate, mformat->inputFormat, mformat->outputFormat, mformat->quantqual, mformat->useTns, mformat->bandWidth);
int written, r, file;
int ofile = creat("out.aac", 00600);
while( (r = read(0, input, samples_input * sizeof(uint16_t))) > 0 ) {
written = faacEncEncode(hEncoder, (short *) input, r/sizeof(uint16_t), output, max_bytes_output);
if (written > 0) {
write(ofile, output, written);
}
}
// Save last frames
while ((written = faacEncEncode(hEncoder, (short *) input, 0, output, max_bytes_output)) > 0) {
write(ofile, output, written);
}
faacEncClose(hEncoder);
close(ofile);
}
