int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
{
int ret = 0;
ret = av_opt_set_dict(ctx, options);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
return ret;
}
if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
ctx->graph->internal->thread_execute) {
ctx->thread_type = AVFILTER_THREAD_SLICE;
ctx->internal->execute = ctx->graph->internal->thread_execute;
} else {
ctx->thread_type = 0;
}
if (ctx->filter->priv_class) {
ret = av_opt_set_dict(ctx->priv, options);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
return ret;
}
}
if (ctx->filter->init)
ret = ctx->filter->init(ctx);
else if (ctx->filter->init_dict)
ret = ctx->filter->init_dict(ctx, options);
return ret;
}
int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
AVDictionary **device_options)
{
int ret;
av_assert0(s && caps);
av_assert0(s->iformat || s->oformat);
if ((s->oformat && !s->oformat->create_device_capabilities) ||
(s->iformat && !s->iformat->create_device_capabilities))
return AVERROR(ENOSYS);
*caps = av_mallocz(sizeof(**caps));
if (!(*caps))
return AVERROR(ENOMEM);
(*caps)->device_context = s;
if (((ret = av_opt_set_dict(s->priv_data, device_options)) < 0))
goto fail;
if (s->iformat) {
if ((ret = s->iformat->create_device_capabilities(s, *caps)) < 0)
goto fail;
} else {
if ((ret = s->oformat->create_device_capabilities(s, *caps)) < 0)
goto fail;
}
av_opt_set_defaults(*caps);
return 0;
fail:
av_freep(caps);
return ret;
}
int32_t
Property :: setProperty(void *aContext, IMetaData* aValuesToSet, IMetaData* aValuesNotFound)
{
int32_t retval =-1;
AVDictionary *tmp = 0;
MetaData* valuesToSet = dynamic_cast<MetaData*>(aValuesToSet);
MetaData* valuesNotFound = dynamic_cast<MetaData*>(aValuesNotFound);
AVDictionary *orig = valuesToSet ? valuesToSet->getDictionary() : 0;
try {
if (!aContext)
throw std::runtime_error("no context passed in");
if (orig)
av_dict_copy(&tmp, orig, 0);
// try setting the values.
retval = av_opt_set_dict(aContext, &tmp);
if (retval < 0)
throw std::runtime_error("failed to set options on context");
if (valuesNotFound)
retval = valuesNotFound->copy(tmp);
av_dict_free(&tmp);
retval = 0;
} catch (std::exception &e) {
av_dict_free(&tmp);
retval = -1;
}
return retval;
}
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,
const AVIOInterruptCB *int_cb, AVDictionary **options,
const char *whitelist, const char* blacklist,
URLContext *parent)
{
AVDictionary *tmp_opts = NULL;
AVDictionaryEntry *e;
int ret = ffurl_alloc(puc, filename, flags, int_cb);
if (ret < 0)
return ret;
if (parent)
av_opt_copy(*puc, parent);
if (options &&
(ret = av_opt_set_dict(*puc, options)) < 0)
goto fail;
if (options && (*puc)->prot->priv_data_class &&
(ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
goto fail;
if (!options)
options = &tmp_opts;
av_assert0(!whitelist ||
!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
!strcmp(whitelist, e->value));
av_assert0(!blacklist ||
!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
!strcmp(blacklist, e->value));
if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0)
goto fail;
if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0)
goto fail;
if ((ret = av_opt_set_dict(*puc, options)) < 0)
goto fail;
ret = ffurl_connect(*puc, options);
if (!ret)
return 0;
fail:
ffurl_close(*puc);
*puc = NULL;
return ret;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
ResampleContext *s = ctx->priv;
char buf1[64], buf2[64];
int ret;
if (s->avr) {
avresample_close(s->avr);
avresample_free(&s->avr);
}
if (inlink->channel_layout == outlink->channel_layout &&
inlink->sample_rate == outlink->sample_rate &&
(inlink->format == outlink->format ||
(av_get_channel_layout_nb_channels(inlink->channel_layout) == 1 &&
av_get_channel_layout_nb_channels(outlink->channel_layout) == 1 &&
av_get_planar_sample_fmt(inlink->format) ==
av_get_planar_sample_fmt(outlink->format))))
return 0;
if (!(s->avr = avresample_alloc_context()))
return AVERROR(ENOMEM);
if (s->options) {
AVDictionaryEntry *e = NULL;
while ((e = av_dict_get(s->options, "", e, AV_DICT_IGNORE_SUFFIX)))
av_log(ctx, AV_LOG_VERBOSE, "lavr option: %s=%s\n", e->key, e->value);
av_opt_set_dict(s->avr, &s->options);
}
av_opt_set_int(s->avr, "in_channel_layout", inlink ->channel_layout, 0);
av_opt_set_int(s->avr, "out_channel_layout", outlink->channel_layout, 0);
av_opt_set_int(s->avr, "in_sample_fmt", inlink ->format, 0);
av_opt_set_int(s->avr, "out_sample_fmt", outlink->format, 0);
av_opt_set_int(s->avr, "in_sample_rate", inlink ->sample_rate, 0);
av_opt_set_int(s->avr, "out_sample_rate", outlink->sample_rate, 0);
if ((ret = avresample_open(s->avr)) < 0)
return ret;
outlink->time_base = (AVRational){ 1, outlink->sample_rate };
s->next_pts = AV_NOPTS_VALUE;
s->next_in_pts = AV_NOPTS_VALUE;
av_get_channel_layout_string(buf1, sizeof(buf1),
-1, inlink ->channel_layout);
av_get_channel_layout_string(buf2, sizeof(buf2),
-1, outlink->channel_layout);
av_log(ctx, AV_LOG_VERBOSE,
"fmt:%s srate:%d cl:%s -> fmt:%s srate:%d cl:%s\n",
av_get_sample_fmt_name(inlink ->format), inlink ->sample_rate, buf1,
av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf2);
return 0;
}
int ffurl_open(URLContext **puc, const char *filename, int flags,
const AVIOInterruptCB *int_cb, AVDictionary **options)
{
int ret = ffurl_alloc(puc, filename, flags, int_cb);
if (ret < 0)
return ret;
if (options && (*puc)->prot->priv_data_class &&
(ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
goto fail;
if ((ret = av_opt_set_dict(*puc, options)) < 0)
goto fail;
ret = ffurl_connect(*puc, options);
if (!ret)
return 0;
fail:
ffurl_close(*puc);
*puc = NULL;
return ret;
}
static int url_connect(struct variant *var, AVDictionary *opts)
{
AVDictionary *tmp = NULL;
int ret;
av_dict_copy(&tmp, opts, 0);
if ((ret = av_opt_set_dict(var->input, &tmp)) < 0 ||
(ret = ffurl_connect(var->input, NULL)) < 0) {
ffurl_close(var->input);
var->input = NULL;
}
av_dict_free(&tmp);
return ret;
}
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
{
int ret = 0;
if (ctx->filter->priv_class) {
ret = av_opt_set_dict(ctx->priv, options);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
return ret;
}
}
if (ctx->filter->init_opaque)
ret = ctx->filter->init_opaque(ctx, NULL);
else if (ctx->filter->init)
ret = ctx->filter->init(ctx);
else if (ctx->filter->init_dict)
ret = ctx->filter->init_dict(ctx, options);
return ret;
}
int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
{
URLContext *h = NULL;
AVIODirContext *ctx = NULL;
int ret;
av_assert0(s);
ctx = av_mallocz(sizeof(*ctx));
if (!ctx) {
ret = AVERROR(ENOMEM);
goto fail;
}
if ((ret = ffurl_alloc(&h, url, AVIO_FLAG_READ, NULL)) < 0)
goto fail;
if (h->prot->url_open_dir && h->prot->url_read_dir && h->prot->url_close_dir) {
if (options && h->prot->priv_data_class &&
(ret = av_opt_set_dict(h->priv_data, options)) < 0)
goto fail;
ret = h->prot->url_open_dir(h);
} else
ret = AVERROR(ENOSYS);
if (ret < 0)
goto fail;
h->is_connected = 1;
ctx->url_context = h;
*s = ctx;
return 0;
fail:
av_free(ctx);
*s = NULL;
ffurl_close(h);
return ret;
}
static int init_muxer(AVFormatContext *s, AVDictionary **options)
{
int ret = 0, i;
AVStream *st;
AVDictionary *tmp = NULL;
AVCodecContext *codec = NULL;
AVOutputFormat *of = s->oformat;
const AVCodecDescriptor *desc;
if (options)
av_dict_copy(&tmp, *options, 0);
if ((ret = av_opt_set_dict(s, &tmp)) < 0)
goto fail;
#if FF_API_LAVF_BITEXACT
if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT)
s->flags |= AVFMT_FLAG_BITEXACT;
#endif
// some sanity checks
if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
av_log(s, AV_LOG_ERROR, "no streams\n");
ret = AVERROR(EINVAL);
goto fail;
}
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
codec = st->codec;
#if FF_API_LAVF_CODEC_TB
FF_DISABLE_DEPRECATION_WARNINGS
if (!st->time_base.num && codec->time_base.num) {
av_log(s, AV_LOG_WARNING, "Using AVStream.codec.time_base as a "
"timebase hint to the muxer is deprecated. Set "
"AVStream.time_base instead.\n");
avpriv_set_pts_info(st, 64, codec->time_base.num, codec->time_base.den);
}
FF_ENABLE_DEPRECATION_WARNINGS
#endif
if (!st->time_base.num) {
/* fall back on the default timebase values */
if (codec->codec_type == AVMEDIA_TYPE_AUDIO && codec->sample_rate)
avpriv_set_pts_info(st, 64, 1, codec->sample_rate);
else
avpriv_set_pts_info(st, 33, 1, 90000);
}
switch (codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
if (codec->sample_rate <= 0) {
av_log(s, AV_LOG_ERROR, "sample rate not set\n");
ret = AVERROR(EINVAL);
goto fail;
}
if (!codec->block_align)
codec->block_align = codec->channels *
av_get_bits_per_sample(codec->codec_id) >> 3;
break;
case AVMEDIA_TYPE_VIDEO:
if ((codec->width <= 0 || codec->height <= 0) &&
!(of->flags & AVFMT_NODIMENSIONS)) {
av_log(s, AV_LOG_ERROR, "dimensions not set\n");
ret = AVERROR(EINVAL);
goto fail;
}
if (av_cmp_q(st->sample_aspect_ratio,
codec->sample_aspect_ratio)) {
if (st->sample_aspect_ratio.num != 0 &&
st->sample_aspect_ratio.den != 0 &&
codec->sample_aspect_ratio.den != 0 &&
codec->sample_aspect_ratio.den != 0) {
av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
"(%d/%d) and encoder layer (%d/%d)\n",
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
codec->sample_aspect_ratio.num,
codec->sample_aspect_ratio.den);
ret = AVERROR(EINVAL);
goto fail;
}
}
break;
}
desc = avcodec_descriptor_get(codec->codec_id);
if (desc && desc->props & AV_CODEC_PROP_REORDER)
st->internal->reorder = 1;
if (of->codec_tag) {
if (codec->codec_tag &&
codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
!av_codec_get_tag(of->codec_tag, codec->codec_id) &&
!validate_codec_tag(s, st)) {
// the current rawvideo encoding system ends up setting
// the wrong codec_tag for avi, we override it here
codec->codec_tag = 0;
}
if (codec->codec_tag) {
if (!validate_codec_tag(s, st)) {
char tagbuf[32];
av_get_codec_tag_string(tagbuf, sizeof(tagbuf), codec->codec_tag);
av_log(s, AV_LOG_ERROR,
"Tag %s/0x%08x incompatible with output codec id '%d'\n",
tagbuf, codec->codec_tag, codec->codec_id);
ret = AVERROR_INVALIDDATA;
goto fail;
}
} else
codec->codec_tag = av_codec_get_tag(of->codec_tag, codec->codec_id);
}
if (of->flags & AVFMT_GLOBALHEADER &&
!(codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
av_log(s, AV_LOG_WARNING,
"Codec for stream %d does not use global headers "
"but container format requires global headers\n", i);
if (codec->codec_type != AVMEDIA_TYPE_ATTACHMENT)
s->internal->nb_interleaved_streams++;
}
if (!s->priv_data && of->priv_data_size > 0) {
s->priv_data = av_mallocz(of->priv_data_size);
if (!s->priv_data) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (of->priv_class) {
*(const AVClass **)s->priv_data = of->priv_class;
av_opt_set_defaults(s->priv_data);
if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
goto fail;
}
}
/* set muxer identification string */
if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
}
if (options) {
av_dict_free(options);
*options = tmp;
}
return 0;
fail:
av_dict_free(&tmp);
return ret;
}
int AudioConvertFunc(const char *outfilename,int sample_rate,int channels,int sec,const char *inputfilename,HWND mParentHwnd,UINT mMsg)
{
AVCodec *aCodec =NULL;
AVPacket *packet = NULL;
AVFormatContext *pFormatCtx =NULL;
AVCodecContext *aCodecCtx= NULL;
ReSampleContext* ResampleCtx=NULL;
AVFrame *decoded_frame = NULL;
int datasize;
//int tempcount = 0;
//long total_out_size=0;
int64_t total_in_convert_size = 0;
int audioConvertProgress = 0;
int tempAudioConvertProgress;
unsigned int i;
int len, ret, buffer_size, count, audio_stream_index = -1, totle_samplenum = 0;
FILE *outfile = NULL;// *infile;
head_pama pt;
int16_t *audio_buffer = NULL;
int16_t *resamplebuff = NULL;
int ResampleChange=0;
int ChannelsChange=0;
int tempret;
packet = (AVPacket*)malloc(sizeof(AVPacket));
if (packet==NULL)
{
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)(-1));
return -1;
}
packet->data=NULL;
buffer_size = AVCODEC_MAX_AUDIO_FRAME_SIZE * 100;
audio_buffer = (int16_t *)av_malloc(buffer_size);
if (audio_buffer==NULL)
{
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)(-2));
return -2;
}
av_register_all();
av_init_packet(packet);
#if 0
/**********尝试分解av_open_input_file函数*************/
int ret = 0;
AVFormatParameters ap = { 0 };
AVDictionary *tmp = NULL;
AVInputFormat *fmt = NULL;
AVDictionary **options = NULL;
if (!pFormatCtx && !(pFormatCtx = avformat_alloc_context()))
return AVERROR(ENOMEM);
if (fmt)
pFormatCtx->iformat = fmt;
if (options)
av_dict_copy(&tmp, *options, 0);
if ((ret = av_opt_set_dict(pFormatCtx, &tmp)) < 0)
goto fail;
AVDictionary *tmp = NULL;
if (!pFormatCtx && !(pFormatCtx = avformat_alloc_context()))
return AVERROR(ENOMEM);
int ret;
AVProbeData pd = {inputfilename, NULL, 0};
if (pFormatCtx->pb) {
pFormatCtx->flags |= AVFMT_FLAG_CUSTOM_IO;
if (!pFormatCtx->iformat)
return av_probe_input_buffer(pFormatCtx->pb, &pFormatCtx->iformat, inputfilename, pFormatCtx, 0, 0);
else if (pFormatCtx->iformat->flags & AVFMT_NOFILE)
av_log(pFormatCtx, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
"will be ignored with AVFMT_NOFILE format.\n");
return 0;
}
if ( (pFormatCtx->iformat && pFormatCtx->iformat->flags & AVFMT_NOFILE) ||
(!pFormatCtx->iformat && (pFormatCtx->iformat = av_probe_input_format(&pd, 0))))
return 0;
URLContext *h;
int err;
err = ffurl_open(&h, inputfilename, AVIO_RDONLY);
if (err < 0)
return err;
err = ffio_fdopen(pFormatCtx, h);
if (err < 0) {
ffurl_close(h);
return err;
}
if (pFormatCtx->iformat)
return 0;
av_probe_input_buffer(pFormatCtx->pb, &pFormatCtx->iformat, inputfilename, pFormatCtx, 0, 0);
if (pFormatCtx->iformat->flags & AVFMT_NEEDNUMBER) {
if (!av_filename_number_test(inputfilename)) {
ret = AVERROR(EINVAL);
goto fail;
}
}
pFormatCtx->duration = pFormatCtx->start_time = AV_NOPTS_VALUE;
av_strlcpy(pFormatCtx->filename, inputfilename ? inputfilename : "", sizeof(pFormatCtx->filename));
/* allocate private data */
if (pFormatCtx->iformat->priv_data_size > 0) {
if (!(pFormatCtx->priv_data = av_mallocz(pFormatCtx->iformat->priv_data_size))) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (pFormatCtx->iformat->priv_class) {
*(const AVClass**)pFormatCtx->priv_data = pFormatCtx->iformat->priv_class;
av_opt_set_defaults(pFormatCtx->priv_data);
if ((ret = av_opt_set_dict(pFormatCtx->priv_data, &tmp)) < 0)
goto fail;
}
}
/* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
if (pFormatCtx->pb)
ff_id3v2_read(pFormatCtx, ID3v2_DEFAULT_MAGIC);
if (!(pFormatCtx->flags&AVFMT_FLAG_PRIV_OPT) && pFormatCtx->iformat->read_header)
if ((ret = pFormatCtx->iformat->read_header(pFormatCtx, &ap)) < 0)
goto fail;
if (!(pFormatCtx->flags&AVFMT_FLAG_PRIV_OPT) && pFormatCtx->pb && !pFormatCtx->data_offset)
pFormatCtx->data_offset = avio_tell(pFormatCtx->pb);
pFormatCtx->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
if (options) {
av_dict_free(options);
*options = tmp;
}
return 0;
fail:
av_dict_free(&tmp);
if (pFormatCtx->pb && !(pFormatCtx->flags & AVFMT_FLAG_CUSTOM_IO))
avio_close(pFormatCtx->pb);
avformat_free_context(pFormatCtx);
pFormatCtx = NULL;
return ret;
return err;
/**********尝试分解av_open_input_file函数*************/
//pFormatCtx = avformat_alloc_context();
#endif
ret = av_open_input_file(&pFormatCtx, inputfilename, NULL,0, NULL);
if(ret < 0)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)1);
return 1;
}
ret = av_find_stream_info(pFormatCtx);
if( ret < 0)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)2);
return 2;
}
audio_stream_index=-1;
for(i=0; i< (signed)pFormatCtx->nb_streams; i++)
{
if(pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO && audio_stream_index < 0)
{
audio_stream_index = i;
break;
}
}
if(audio_stream_index == -1)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)3);
return 3;
}
aCodecCtx = pFormatCtx->streams[audio_stream_index]->codec;
if (aCodecCtx==NULL)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)4);
return 4;
}
aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
if(!aCodec)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
/*if (aCodecCtx!=NULL)
{
avcodec_close(aCodecCtx);
aCodecCtx=NULL;
}*/
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)5);
return 5;
}
//resample init
if (channels==0)
{
channels=aCodecCtx->channels;
}
if (sample_rate==0)
{
sample_rate=aCodecCtx->sample_rate;
}
//if (aCodecCtx->channels!=channels)
//{
// ChannelsChange=1;
// ResampleChange=1;
//}
if (aCodecCtx->sample_rate!=sample_rate||aCodecCtx->channels!=channels)
{
ResampleChange=1;
}
if (ResampleChange==1)
{
ResampleCtx = av_audio_resample_init(channels,aCodecCtx->channels,sample_rate,aCodecCtx->sample_rate,SAMPLE_FMT_S16,SAMPLE_FMT_S16,16,10,0,1.0);
if (ResampleCtx==NULL)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
/*if (aCodecCtx!=NULL)
{
avcodec_close(aCodecCtx);
aCodecCtx=NULL;
}*/
ResampleChange=0;
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)6);
return 6;
}
resamplebuff=(int16_t *)malloc(buffer_size);
if (resamplebuff==NULL)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
/*if (aCodecCtx!=NULL)
{
avcodec_close(aCodecCtx);
aCodecCtx=NULL;
}*/
if (ResampleChange==1&&ResampleCtx!=NULL)
{
audio_resample_close(ResampleCtx);
ResampleCtx=NULL;
}
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)7);
return 7;
}
}
//
datasize=sec*sample_rate;
if(avcodec_open(aCodecCtx, aCodec)<0)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
if (aCodecCtx!=NULL)
{
avcodec_close(aCodecCtx);
aCodecCtx=NULL;
}
if (ResampleChange==1&&ResampleCtx!=NULL&&resamplebuff!=NULL)
{
audio_resample_close(ResampleCtx);
ResampleCtx=NULL;
free(resamplebuff);
resamplebuff=NULL;
}
ResampleChange=0;
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)8);
return 8;
}
pt.bits = 16;
pt.channels = channels;
pt.rate = sample_rate;
outfile = fopen(outfilename, "wb");
if (!outfile)
{
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
if (packet!=NULL)
{
free(packet);
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
if (aCodecCtx!=NULL)
{
avcodec_close(aCodecCtx);
aCodecCtx=NULL;
}
if (ResampleChange==1&&ResampleCtx!=NULL&&resamplebuff!=NULL)
{
audio_resample_close(ResampleCtx);
ResampleCtx=NULL;
free(resamplebuff);
resamplebuff=NULL;
}
ResampleChange=0;
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)9);
return 9;
}
fseek(outfile,44,SEEK_SET);
while(av_read_frame(pFormatCtx, packet) >= 0)
{
CheckMessageQueue();
if(packet->stream_index == audio_stream_index)
{
//while(packet->size > 0)
//{
buffer_size = AVCODEC_MAX_AUDIO_FRAME_SIZE * 100;
len = avcodec_decode_audio3(aCodecCtx, audio_buffer, &buffer_size, packet);
if (len < 0)
{
break;
}
if(buffer_size > 0)
{
//resample
if (ResampleChange==1)
{
int samples=buffer_size/ ((aCodecCtx->channels) * 2);
int resamplenum= 0;
resamplenum = audio_resample(ResampleCtx,
resamplebuff,
audio_buffer,
samples);
count = fwrite(resamplebuff, 2*channels, resamplenum, outfile);
}
else
{
count = fwrite(audio_buffer, 2*aCodecCtx->channels, buffer_size/((aCodecCtx->channels)*2), outfile);
}
totle_samplenum += count;
}
//tempcount++;
//total_out_size += count*2*aCodecCtx->channels;
total_in_convert_size += packet->size;
tempAudioConvertProgress = 100*total_in_convert_size/(pFormatCtx->file_size);
if(tempAudioConvertProgress != audioConvertProgress)
{
if(tempAudioConvertProgress == 100)
tempAudioConvertProgress = 99;
audioConvertProgress = tempAudioConvertProgress;
tempret = PostMessage(mParentHwnd,mMsg,DECING_TAG,audioConvertProgress);
}
if (packet->data!=NULL)
{
av_free_packet(packet);
packet->data=NULL;
}
//packet->size -= len;
//packet->data += len;
//}
if (datasize!=0&&totle_samplenum>=datasize)
{
break;
}
}
}
audioConvertProgress = 100;
PostMessage(mParentHwnd,mMsg,DECING_TAG,audioConvertProgress);
fseek(outfile,0,SEEK_SET);
wav_write_header(outfile, pt, totle_samplenum);
if (outfile!=NULL)
{
fclose(outfile);
outfile=NULL;
}
if (audio_buffer!=NULL)
{
av_free(audio_buffer);
audio_buffer=NULL;
}
if (aCodecCtx!=NULL)
{
avcodec_close(aCodecCtx);
aCodecCtx=NULL;
}
if (packet!=NULL)
{
free(packet);//
packet=NULL;
}
if (pFormatCtx!=NULL)
{
av_close_input_file(pFormatCtx);
pFormatCtx=NULL;
}
if (ResampleChange==1)
{
if (resamplebuff!=NULL)
{
free(resamplebuff);
resamplebuff=NULL;
}
if (ResampleCtx!=NULL)
{
audio_resample_close(ResampleCtx);
ResampleCtx=NULL;
}
}
if (totle_samplenum<=sample_rate*5)
{
PostMessage(mParentHwnd,mMsg,FAILED_TAG,(LPARAM)10);
return 10;
}
PostMessage(mParentHwnd,mMsg,FINISH_TAG,NULL);
return 0;
}