/**
* Initialize the audio resampler based on the input and output codec settings.
* If the input and output sample formats differ, a conversion is required
* libswresample takes care of this, but requires initialization.
*/
int AudioDecoder::init_resampler(AVCodecContext *input_codec_context,
AVCodecContext *output_codec_context)
{
int error;
/**
* Create a resampler context for the conversion.
* Set the conversion parameters.
* Default channel layouts based on the number of channels
* are assumed for simplicity (they are sometimes not detected
* properly by the demuxer and/or decoder).
*/
resample_context = swr_alloc_set_opts(NULL,
av_get_default_channel_layout(output_codec_context->channels),
output_codec_context->sample_fmt,
output_codec_context->sample_rate,
av_get_default_channel_layout(input_codec_context->channels),
input_codec_context->sample_fmt,
input_codec_context->sample_rate,
0, NULL);
if (!resample_context) {
ELOG_WARN( "Could not allocate resample context\n");
return AVERROR(ENOMEM);
}
/**
* Perform a sanity check so that the number of converted samples is
* not greater than the number of samples to be converted.
* If the sample rates differ, this case has to be handled differently
*/
ELOG_DEBUG( "audio input sample_rate = %d, out %d", input_codec_context->sample_rate, output_codec_context->sample_rate);
/** Open the resampler with the specified parameters. */
if ((error = swr_init(resample_context)) < 0) {
ELOG_WARN( "Could not open resample context");
swr_free(&resample_context);
return error;
}
/** Open the resampler with the specified parameters. */
if ((error = swr_init(resample_context)) < 0) {
ELOG_DEBUG( "Could not open resample context");
swr_free(&resample_context);
return error;
}
ELOG_DEBUG( "swr_init done");
return 0;
}
kxMovieError openAudioStream(size_t audioStream)
{
AVCodecContext *codecCtx = _formatCtx->streams[audioStream]->codec;
SwrContext *swrContext = NULL;
AVCodec *codec = avcodec_find_decoder(codecCtx->codec_id);
if(!codec)
return kxMovieErrorCodecNotFound;
if (avcodec_open2(codecCtx, codec, NULL) < 0)
return kxMovieErrorOpenCodec;
if (!audioCodecIsSupported(codecCtx))
{
swrContext = swr_alloc_set_opts(NULL,
av_get_default_channel_layout(codecCtx->channels),
AV_SAMPLE_FMT_S16,
codecCtx->sample_rate,
av_get_default_channel_layout(codecCtx->channels),
codecCtx->sample_fmt,
codecCtx->sample_rate,
0,
NULL);
if (!swrContext ||
swr_init(swrContext)) {
if (swrContext)
swr_free(&swrContext);
avcodec_close(codecCtx);
return kxMovieErroReSampler;
}
}
_audioFrame = av_frame_alloc();
if (!_audioFrame) {
if (swrContext)
swr_free(&swrContext);
avcodec_close(codecCtx);
return kxMovieErrorAllocateFrame;
}
_audioStream = audioStream;
_audioCodecCtx = codecCtx;
_swrContext = swrContext;
return kxMovieErrorNone;
}
void render_close(void *hrender)
{
RENDER *render = (RENDER*)hrender;
// wait visual effect thread exit
render->render_status = RENDER_CLOSE;
#if CONFIG_ENABLE_VEFFECT
pthread_join(render->veffect_thread, NULL);
veffect_destroy(render->veffect_context);
#endif
//++ audio ++//
// destroy adev
adev_destroy(render->adev);
// free swr context
swr_free(&render->swr_context);
//-- audio --//
//++ video ++//
// destroy vdev
vdev_destroy(render->vdev);
// free sws context
if (render->sws_context) {
sws_freeContext(render->sws_context);
}
//-- video --//
// free context
free(render);
}
void FFmpeg_Decoder::close()
{
if(mStream)
avcodec_close((*mStream)->codec);
mStream = NULL;
av_free_packet(&mPacket);
av_freep(&mFrame);
swr_free(&mSwr);
av_freep(&mDataBuf);
if(mFormatCtx)
{
if (mFormatCtx->pb != NULL)
{
// mFormatCtx->pb->buffer must be freed by hand,
// if not, valgrind will show memleak, see:
//
// https://trac.ffmpeg.org/ticket/1357
//
if (mFormatCtx->pb->buffer != NULL)
{
av_free(mFormatCtx->pb->buffer);
mFormatCtx->pb->buffer = NULL;
}
av_free(mFormatCtx->pb);
mFormatCtx->pb = NULL;
}
avformat_close_input(&mFormatCtx);
}
mDataStream.reset();
}
void render_close(void *hrender)
{
RENDER *render = (RENDER*)hrender;
//++ audio ++//
// destroy adev
adev_destroy(render->adev);
// free swr context
swr_free(&render->pSWRContext);
//-- audio --//
//++ video ++//
// destroy vdev
vdev_destroy(render->vdev);
// free sws context
if (render->pSWSContext) {
sws_freeContext(render->pSWSContext);
}
//-- video --//
// free context
free(render);
}
void COMXAudioCodecOMX::Dispose()
{
av_frame_free(&m_pFrame1);
swr_free(&m_pConvert);
avcodec_free_context(&m_pCodecContext);
m_bGotFrame = false;
}
void closeAudioStream()
{
_audioStream = -1;
if (_swrContext) {
swr_free(&_swrContext);
_swrContext = NULL;
}
if (_audioFrame) {
av_free(_audioFrame);
_audioFrame = NULL;
}
if (_audioCodecCtx) {
avcodec_close(_audioCodecCtx);
_audioCodecCtx = NULL;
}
avformat_close_input(&_formatCtx);
//av_register_all();
}
void FFMPEGer::close_stream(AVFormatContext *oc, OutputStream *ost){
if(ost->st->codec != NULL){
avcodec_close(ost->st->codec);
}
if(ost->frame != NULL){
av_frame_free(&ost->frame);
ost->frame = NULL;
}
if(ost->tmp_frame != NULL){
av_frame_free(&ost->tmp_frame);
ost->tmp_frame = NULL;
}
if(ost->sws_ctx != NULL){
sws_freeContext(ost->sws_ctx);
ost->sws_ctx = NULL;
}
if(ost->swr_ctx != NULL){
swr_free(&ost->swr_ctx);
ost->swr_ctx = NULL;
}
}
void AudioLoader::closeAudioFile() {
if (!_demuxCtx) {
return;
}
#if HAVE_AVRESAMPLE
if (_convertCtxAv) {
avresample_close(_convertCtxAv);
avresample_free(&_convertCtxAv);
}
#elif HAVE_SWRESAMPLE
if (_convertCtx) {
swr_free(&_convertCtx);
}
#endif
// Close the codec
avcodec_close(_audioCtx);
// Close the audio file
avformat_close_input(&_demuxCtx);
// free AVPacket
av_free_packet(&_packet);
_demuxCtx = 0;
_audioCtx = 0;
}
static av_cold int opus_decode_close(AVCodecContext *avctx)
{
OpusContext *c = avctx->priv_data;
int i;
for (i = 0; i < c->nb_streams; i++) {
OpusStreamContext *s = &c->streams[i];
ff_silk_free(&s->silk);
ff_celt_free(&s->celt);
av_freep(&s->out_dummy);
s->out_dummy_allocated_size = 0;
av_audio_fifo_free(s->celt_delay);
swr_free(&s->swr);
}
av_freep(&c->streams);
c->nb_streams = 0;
av_freep(&c->channel_maps);
return 0;
}
VideoDecoder::~VideoDecoder() {
//Take care of cleanup
if(swrContext != NULL) {
swr_free(&swrContext);
}
if(swsContext != NULL) {
sws_freeContext(swsContext);
}
if(videoBuffer != NULL) {
delete[] videoBuffer;
}
if(audioCodecContext != NULL) {
avcodec_close(audioCodecContext);
}
if(videoCodecContext != NULL) {
avcodec_close(videoCodecContext);
}
av_frame_free(&audioFrame);
for(int i = 0; i < VIDEOPLAYER_VIDEO_NUM_BUFFERED_FRAMES; i++) {
av_frame_free(rgbFrames + i);
}
av_frame_free(&frame);
avformat_close_input(&formatContext);
if(avioContext != NULL) {
av_free(avioContext);
}
}
MediaThread::Pcm::~Pcm()
{
free(buf_);
if (swr_) {
swr_free(&swr_);
}
}
void COMXAudioCodecOMX::Dispose()
{
if (m_pFrame1)
{
av_free(m_pFrame1);
m_pFrame1 = NULL;
}
if (m_pConvert)
{
swr_free(&m_pConvert);
}
if (m_pCodecContext)
{
if (m_bOpenedCodec)
{
avcodec_close(m_pCodecContext);
}
m_bOpenedCodec = false;
av_free(m_pCodecContext);
m_pCodecContext = NULL;
}
m_iBufferSize1 = 0;
m_iBufferSize2 = 0;
m_iBuffered = 0;
}
Swr::~Swr()
{
if (this->context != nullptr) {
swr_free(&this->context);
}
assert(this->context == nullptr);
}
static void close_stream(AVFormatContext *oc, OutputStream *ost)
{
avcodec_close(ost->st->codec);
av_frame_free(&ost->frame);
sws_freeContext(ost->sws_ctx);
swr_free(&ost->swr_ctx);
}
// Initialization and runtime control
static int control(struct af_instance_s* af, int cmd, void* arg)
{
af_resample_t* s = (af_resample_t*)af->setup;
af_data_t *data= (af_data_t*)arg;
int out_rate, test_output_res; // helpers for checking input format
switch(cmd){
case AF_CONTROL_REINIT:
if((af->data->rate == data->rate) || (af->data->rate == 0))
return AF_DETACH;
af->data->nch = data->nch;
if (af->data->nch > AF_NCH) af->data->nch = AF_NCH;
af->data->format = AF_FORMAT_S16_NE;
af->data->bps = 2;
af->mul = (double)af->data->rate / data->rate;
af->delay = af->data->nch * s->filter_length / FFMIN(af->mul, 1); // *bps*.5
if (s->ctx_out_rate != af->data->rate || s->ctx_in_rate != data->rate || s->ctx_filter_size != s->filter_length ||
s->ctx_phase_shift != s->phase_shift || s->ctx_linear != s->linear || s->ctx_cutoff != s->cutoff) {
swr_free(&s->swrctx);
if((s->swrctx=swr_alloc()) == NULL) return AF_ERROR;
av_opt_set_int(s->swrctx, "out_sample_rate", af->data->rate, 0);
av_opt_set_int(s->swrctx, "in_sample_rate", data->rate, 0);
av_opt_set_int(s->swrctx, "filter_size", s->filter_length, 0);
av_opt_set_int(s->swrctx, "phase_shift", s->phase_shift, 0);
av_opt_set_int(s->swrctx, "linear_interp", s->linear, 0);
av_opt_set_double(s->swrctx, "cutoff", s->cutoff, 0);
av_opt_set_sample_fmt(s->swrctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
av_opt_set_sample_fmt(s->swrctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
av_opt_set_int(s->swrctx, "in_channel_count", af->data->nch, 0);
av_opt_set_int(s->swrctx, "out_channel_count", af->data->nch, 0);
if(swr_init(s->swrctx) < 0) return AF_ERROR;
s->ctx_out_rate = af->data->rate;
s->ctx_in_rate = data->rate;
s->ctx_filter_size = s->filter_length;
s->ctx_phase_shift = s->phase_shift;
s->ctx_linear = s->linear;
s->ctx_cutoff = s->cutoff;
}
// hack to make af_test_output ignore the samplerate change
out_rate = af->data->rate;
af->data->rate = data->rate;
test_output_res = af_test_output(af, (af_data_t*)arg);
af->data->rate = out_rate;
return test_output_res;
case AF_CONTROL_COMMAND_LINE:{
s->cutoff= 0.0;
sscanf((char*)arg,"%d:%d:%d:%d:%lf", &af->data->rate, &s->filter_length, &s->linear, &s->phase_shift, &s->cutoff);
if(s->cutoff <= 0.0) s->cutoff= FFMAX(1.0 - 6.5/(s->filter_length+8), 0.80);
return AF_OK;
}
case AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET:
af->data->rate = *(int*)arg;
return AF_OK;
}
return AF_UNKNOWN;
}
CAEEncoderFFmpeg::~CAEEncoderFFmpeg()
{
Reset();
av_freep(&m_CodecCtx);
av_freep(&m_ResampBuffer);
if (m_SwrCtx)
swr_free(&m_SwrCtx);
}
AudioDecoder::~AudioDecoder() {
if (m_outData) {
av_freep(&m_outData[0]);
}
av_freep(&m_outData);
swr_free(&m_resampleCtx);
}
static void ffFreeAVCtx(AVCtx *ctx)
{
if (ctx->frame)
av_frame_free(&ctx->frame);
if (ctx->swr_ctx)
swr_free(&ctx->swr_ctx);
if (ctx->sws_ctx)
sws_freeContext(ctx->sws_ctx);
}
void AudioController::uninit(af_instance *af) {
auto ac = priv(af); auto d = ac->d;
Q_ASSERT(ac != nullptr);
d->af = nullptr;
if (d->swr)
swr_free(&d->swr);
talloc_free(d->resampled);
d->resampled = nullptr;
}
static void audio_convert(dtaudio_decoder_t *decoder, AVFrame * dst,
AVFrame * src)
{
int nb_sample;
int dst_buf_size;
int out_channels;
//for audio post processor
//struct SwsContext *m_sws_ctx = NULL;
struct SwrContext *m_swr_ctx = NULL;
//ResampleContext *m_resample_ctx=NULL;
enum AVSampleFormat src_fmt = avctxp->sample_fmt;
enum AVSampleFormat dst_fmt = AV_SAMPLE_FMT_S16;
dst->linesize[0] = src->linesize[0];
*dst = *src;
dst->data[0] = NULL;
out_channels = decoder->para.dst_channels;
nb_sample = frame->nb_samples;
dst_buf_size = nb_sample * av_get_bytes_per_sample(dst_fmt) * out_channels;
dst->data[0] = (uint8_t *) av_malloc(dst_buf_size);
avcodec_fill_audio_frame(dst, out_channels, dst_fmt, dst->data[0], dst_buf_size,
0);
dt_debug(TAG, "SRCFMT:%d dst_fmt:%d \n", src_fmt, dst_fmt);
/* resample toAV_SAMPLE_FMT_S16 */
if (src_fmt != dst_fmt || out_channels != decoder->para.channels) {
if (!m_swr_ctx) {
uint64_t in_channel_layout = av_get_default_channel_layout(avctxp->channels);
uint64_t out_channel_layout = av_get_default_channel_layout(out_channels);
m_swr_ctx = swr_alloc_set_opts(NULL, out_channel_layout, dst_fmt,
avctxp->sample_rate, in_channel_layout, src_fmt, avctxp->sample_rate, 0, NULL);
swr_init(m_swr_ctx);
}
uint8_t **out = (uint8_t **) & dst->data;
const uint8_t **in = (const uint8_t **) src->extended_data;
if (m_swr_ctx) {
int ret, out_count;
out_count = nb_sample;
ret = swr_convert(m_swr_ctx, out, out_count, in, nb_sample);
if (ret < 0) {
//set audio mute
memset(dst->data[0], 0, dst_buf_size);
printf("audio convert failed, set mute data\n");
}
}
} else { // no need to convert ,just copy
memcpy(dst->data[0], src->data[0], src->linesize[0]);
}
//free context
if (m_swr_ctx != NULL) {
swr_free(&m_swr_ctx);
}
//if(m_resample_ctx!=NULL)
// audio_resample_close(m_resample_ctx);
}
SimpleAT3::~SimpleAT3() {
if (frame_)
av_frame_free(&frame_);
if (codecCtx_)
avcodec_close(codecCtx_);
codecCtx_ = 0;
codec_ = 0;
if (swrCtx_)
swr_free(&swrCtx_);
}
void uninit_opts(void)
{
#if CONFIG_SWSCALE
sws_freeContext(sws_opts);
sws_opts = NULL;
#endif
swr_free(&swr_opts);
av_dict_free(&format_opts);
av_dict_free(&codec_opts);
}
FFMpegLoader::~FFMpegLoader() {
if (codecContext) avcodec_free_context(&codecContext);
if (swrContext) swr_free(&swrContext);
if (dstSamplesData) {
if (dstSamplesData[0]) {
av_freep(&dstSamplesData[0]);
}
av_freep(&dstSamplesData);
}
av_frame_free(&frame);
}
void hb_audio_resample_free(hb_audio_resample_t *resample)
{
if (resample != NULL)
{
if (resample->swresample != NULL)
{
swr_free(&resample->swresample);
}
free(resample);
}
}
CVideoLivRecord::~CVideoLivRecord(void)
{
av_write_trailer(m_pAVFormatContext);
if (m_bHasVideo){
avcodec_close(m_pVideoStream->codec);
av_frame_free(&m_pVideoFrame);
av_frame_free(&m_pVideoBkFrame);
sws_freeContext(m_pVideoSwsctx);
swr_free(&m_pVideoSwrctx);
}
if (m_bHasAudio){
avcodec_close(m_pAudioStream->codec);
av_frame_free(&m_pVideoFrame);
av_frame_free(&m_pVideoBkFrame);
swr_free(&m_pAudioSwrctx);
}
if (!(m_pAVFormatContext->oformat->flags & AVFMT_NOFILE))
avio_close(m_pAVFormatContext->pb);
avformat_free_context(m_pAVFormatContext);
}
void release(JNIEnv *env,jclass clz){
if(i==0)
return;
LOGI("%s","release");
pause=1;
usleep(10000);
swr_free(&au_convert_ctx);
av_free(pFrame);
avcodec_close(pCodecCtx);
avformat_close_input(&pFormatCtx);
i=0;
}
AudioResamplerFfmpeg::~AudioResamplerFfmpeg() {
if (_context) {
#ifdef HAVE_SWRESAMPLE_H
swr_free(&_context);
#elif HAVE_AVRESAMPLE_H
avresample_close(_context);
avresample_free(&_context);
#else
audio_resample_close(_context);
#endif
}
}
void Parser::EndProcess()
{
try
{
if (frame_in)
{
av_frame_free(&frame_in);
frame_in = NULL;
}
if (frame_out)
{
av_frame_free(&frame_out);
frame_out = NULL;
}
for (int i = 0; i < (int)vetAux.size(); i++)
if (vetAux[i].size() > 0)
vetAux[i].clear();
if (vetAux.size() > 0)
vetAux.clear();
for (int idxFrame = 0; idxFrame < (int)this->bufFrames.size(); idxFrame++)
{
for (int i = 0; i < (int)bufFrames[idxFrame].size(); i++)
if (bufFrames[idxFrame][i].size() > 0)
bufFrames[idxFrame][i].clear();
if (bufFrames[idxFrame].size() > 0)
bufFrames[idxFrame].clear();
}
if (bufFrames.size() > 0)
bufFrames.clear();
if (dic)
av_freep(dic);
if (fmt_ctx_out->pb)
avio_close(fmt_ctx_out->pb);
if (swr_ctx)
swr_free(&swr_ctx);
if (fmt_ctx_out)
avformat_free_context(fmt_ctx_out);
if (cdc_ctx_out)
avcodec_close(cdc_ctx_out);
}
catch (SignalException& err)
{
objLog->mr_printf(MR_LOG_ERROR, idRadio, "Destructor Parser: %s\n", err.what());
}
catch(...)
{
objLog->mr_printf(MR_LOG_ERROR, idRadio, "Destructor Parser: General erros\n");
}
}
// Deallocate memory
static void uninit(struct af_instance_s* af)
{
if(af->data)
free(af->data->audio);
free(af->data);
if(af->setup){
af_resample_t *s = af->setup;
swr_free(&s->swrctx);
av_free(s->in[0]);
av_free(s->tmp[0]);
free(s);
}
}
