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); }