int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx) { AVBSFContext *ctx; int ret; ctx = av_mallocz(sizeof(*ctx)); if (!ctx) return AVERROR(ENOMEM); ctx->av_class = &bsf_class; ctx->filter = filter; ctx->par_in = avcodec_parameters_alloc(); ctx->par_out = avcodec_parameters_alloc(); if (!ctx->par_in || !ctx->par_out) { ret = AVERROR(ENOMEM); goto fail; } ctx->internal = av_mallocz(sizeof(*ctx->internal)); if (!ctx->internal) { ret = AVERROR(ENOMEM); goto fail; } ctx->internal->buffer_pkt = av_packet_alloc(); if (!ctx->internal->buffer_pkt) { ret = AVERROR(ENOMEM); goto fail; } av_opt_set_defaults(ctx); /* allocate priv data and init private options */ if (filter->priv_data_size) { ctx->priv_data = av_mallocz(filter->priv_data_size); if (!ctx->priv_data) { ret = AVERROR(ENOMEM); goto fail; } if (filter->priv_class) { *(const AVClass **)ctx->priv_data = filter->priv_class; av_opt_set_defaults(ctx->priv_data); } } *pctx = ctx; return 0; fail: av_bsf_free(&ctx); return ret; }
BVDeviceContext *bv_device_alloc_context(const BVDevice * dev) { BVDeviceContext *devctx = av_malloc(sizeof(BVDeviceContext)); if (!devctx) { av_log(NULL, AV_LOG_ERROR, "malloc BVDeviceContext error"); return NULL; } devctx->device = dev; devctx->priv_data = NULL; if (dev) { if (dev->priv_data_size > 0) { devctx->priv_data = av_mallocz(dev->priv_data_size); if (!devctx->priv_data) goto nomem; if (dev->priv_class) { *(const AVClass **) devctx->priv_data = dev->priv_class; av_opt_set_defaults(devctx->priv_data); } } } return devctx; nomem: av_log(devctx, AV_LOG_ERROR, "Out of memory"); bv_device_free_context(&devctx); return NULL; }
int avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec) { /* 参数: 1、 返回: 1、 说明: 1、 */ avcodec_get_context_defaults2(s, codec ? codec->type : AVMEDIA_TYPE_UNKNOWN); if(codec && codec->priv_data_size) { if(!s->priv_data) { s->priv_data= av_mallocz(codec->priv_data_size); if (!s->priv_data) { return AVERROR(ENOMEM); } } if(codec->priv_class) { *(AVClass**)s->priv_data= codec->priv_class; av_opt_set_defaults(s->priv_data); } } return 0; }
int avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec){ avcodec_get_context_defaults2(s, codec ? codec->type : AVMEDIA_TYPE_UNKNOWN); if(codec && codec->priv_data_size){ if(!s->priv_data){ s->priv_data= av_mallocz(codec->priv_data_size); if (!s->priv_data) { return AVERROR(ENOMEM); } } if(codec->priv_class){ *(AVClass**)s->priv_data= codec->priv_class; av_opt_set_defaults(s->priv_data); } } if (codec && codec->defaults) { int ret; AVCodecDefault *d = codec->defaults; while (d->key) { ret = av_set_string3(s, d->key, d->value, 0, NULL); av_assert0(ret >= 0); d++; } } return 0; }
static const AVClass * app_class(void) { static const AVClass g_class = { .class_name = "FFVADemo", .item_name = av_default_item_name, .option = app_options, .version = LIBAVUTIL_VERSION_INT, }; return &g_class; } static App * app_new(void) { App *app; app = calloc(1, sizeof(*app)); if (!app) return NULL; app->klass = app_class(); av_opt_set_defaults(app); ffva_surface_init_defaults(&app->filter_surface); return app; }
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; }
static int chunk_mux_init(AVFormatContext *s) { WebMChunkContext *wc = s->priv_data; AVFormatContext *oc; int ret; ret = avformat_alloc_output_context2(&wc->avf, wc->oformat, NULL, NULL); if (ret < 0) return ret; oc = wc->avf; oc->interrupt_callback = s->interrupt_callback; oc->max_delay = s->max_delay; av_dict_copy(&oc->metadata, s->metadata, 0); *(const AVClass**)oc->priv_data = oc->oformat->priv_class; av_opt_set_defaults(oc->priv_data); av_opt_set_int(oc->priv_data, "dash", 1, 0); av_opt_set_int(oc->priv_data, "cluster_time_limit", wc->chunk_duration, 0); av_opt_set_int(oc->priv_data, "live", 1, 0); oc->streams = s->streams; oc->nb_streams = s->nb_streams; return 0; }
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec) { int flags=0; memset(s, 0, sizeof(AVCodecContext)); s->av_class = &av_codec_context_class; s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN; if (codec) s->codec_id = codec->id; if(s->codec_type == AVMEDIA_TYPE_AUDIO) flags= AV_OPT_FLAG_AUDIO_PARAM; else if(s->codec_type == AVMEDIA_TYPE_VIDEO) flags= AV_OPT_FLAG_VIDEO_PARAM; else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE) flags= AV_OPT_FLAG_SUBTITLE_PARAM; av_opt_set_defaults2(s, flags, flags); s->time_base = (AVRational){0,1}; s->get_buffer2 = avcodec_default_get_buffer2; s->get_format = avcodec_default_get_format; s->execute = avcodec_default_execute; s->execute2 = avcodec_default_execute2; s->sample_aspect_ratio = (AVRational){0,1}; s->pix_fmt = AV_PIX_FMT_NONE; s->sample_fmt = AV_SAMPLE_FMT_NONE; s->timecode_frame_start = -1; s->reordered_opaque = AV_NOPTS_VALUE; if(codec && codec->priv_data_size){ if(!s->priv_data){ s->priv_data= av_mallocz(codec->priv_data_size); if (!s->priv_data) { return AVERROR(ENOMEM); } } if(codec->priv_class){ *(const AVClass**)s->priv_data = codec->priv_class; av_opt_set_defaults(s->priv_data); } } if (codec && codec->defaults) { int ret; const AVCodecDefault *d = codec->defaults; while (d->key) { ret = av_opt_set(s, d->key, d->value, 0); av_assert0(ret >= 0); d++; } } // ==> Start patch MPC s->using_dxva = 0; s->entangled_thread_counter = 0; s->ff_avcodec_locked = 0; // ==> End patch MPC return 0; }
struct SwrContext *swr_alloc(void){ SwrContext *s= av_mallocz(sizeof(SwrContext)); if(s){ s->av_class= &av_class; av_opt_set_defaults(s); } return s; }
static void avformat_get_context_defaults(AVFormatContext *s) { memset(s, 0, sizeof(AVFormatContext)); s->av_class = &av_format_context_class; av_opt_set_defaults(s); }
int avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec){ memset(s, 0, sizeof(AVCodecContext)); s->av_class = &av_codec_context_class; s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN; s->codec = codec; av_opt_set_defaults(s); s->time_base = (AVRational){0,1}; s->get_buffer = avcodec_default_get_buffer; s->release_buffer = avcodec_default_release_buffer; s->get_format = avcodec_default_get_format; s->execute = avcodec_default_execute; s->execute2 = avcodec_default_execute2; s->sample_aspect_ratio = (AVRational){0,1}; s->pix_fmt = PIX_FMT_NONE; s->sample_fmt = AV_SAMPLE_FMT_S16; // fixme, ac3 encoder crashes if set to none s->request_sample_fmt = AV_SAMPLE_FMT_FLT; // todo: set this value in ffdshow s->reget_buffer = avcodec_default_reget_buffer; s->reordered_opaque = AV_NOPTS_VALUE; if(codec && codec->priv_data_size){ if(!s->priv_data){ s->priv_data= av_mallocz(codec->priv_data_size); if (!s->priv_data) { return AVERROR(ENOMEM); } } if(codec->priv_class){ *(const AVClass**)s->priv_data = codec->priv_class; av_opt_set_defaults(s->priv_data); } } if (codec && codec->defaults) { int ret; const AVCodecDefault *d = codec->defaults; while (d->key) { ret = av_opt_set(s, d->key, d->value, 0); av_assert0(ret >= 0); d++; } } return 0; }
static void avformat_get_context_defaults(AVFormatContext *s) { memset(s, 0, sizeof(AVFormatContext)); s->av_class = &av_format_context_class; s->interrupt_callback.ioparams = NULL;//add by fxw for http persist connection av_opt_set_defaults(s); }
AVDCT *avcodec_dct_alloc(void) { AVDCT *dsp = av_mallocz(sizeof(AVDCT)); if (!dsp) return NULL; dsp->av_class = &avdct_class; av_opt_set_defaults(dsp); return dsp; }
int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat, const char *format, const char *filename) { AVFormatContext *s = avformat_alloc_context(); int ret = 0; *avctx = NULL; if (!s) goto nomem; if (!oformat) { if (format) { oformat = av_guess_format(format, NULL, NULL); if (!oformat) { av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format); ret = AVERROR(EINVAL); goto error; } } else { oformat = av_guess_format(NULL, filename, NULL); if (!oformat) { ret = AVERROR(EINVAL); av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n", filename); goto error; } } } s->oformat = oformat; if (s->oformat->priv_data_size > 0) { s->priv_data = av_mallocz(s->oformat->priv_data_size); if (!s->priv_data) goto nomem; if (s->oformat->priv_class) { *(const AVClass**)s->priv_data= s->oformat->priv_class; av_opt_set_defaults(s->priv_data); } } else s->priv_data = NULL; if (filename) av_strlcpy(s->filename, filename, sizeof(s->filename)); *avctx = s; return 0; nomem: av_log(s, AV_LOG_ERROR, "Out of memory\n"); ret = AVERROR(ENOMEM); error: avformat_free_context(s); return ret; }
AVAudioResampleContext *avresample_alloc_context(void) { AVAudioResampleContext *avr; avr = av_mallocz(sizeof(*avr)); if (!avr) return NULL; avr->av_class = &av_resample_context_class; av_opt_set_defaults(avr); return avr; }
static int url_alloc_for_protocol(URLContext **puc, struct URLProtocol *up, const char *filename, int flags, const AVIOInterruptCB *int_cb) { URLContext *uc; int err; #if CONFIG_NETWORK if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init()) return AVERROR(EIO); #endif uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1); if (!uc) { err = AVERROR(ENOMEM); goto fail; } uc->av_class = &ffurl_context_class; uc->filename = (char *)&uc[1]; strcpy(uc->filename, filename); uc->prot = up; uc->flags = flags; uc->is_streamed = 0; /* default = not streamed */ uc->max_packet_size = 0; /* default: stream file */ if (up->priv_data_size) { uc->priv_data = av_mallocz(up->priv_data_size); if (!uc->priv_data) { err = AVERROR(ENOMEM); goto fail; } if (up->priv_data_class) { *(const AVClass **)uc->priv_data = up->priv_data_class; av_opt_set_defaults(uc->priv_data); } } if (int_cb) uc->interrupt_callback = *int_cb; *puc = uc; return 0; fail: *puc = NULL; if (uc) av_freep(&uc->priv_data); av_freep(&uc); #if CONFIG_NETWORK if (up->flags & URL_PROTOCOL_FLAG_NETWORK) ff_network_close(); #endif return err; }
int test_http(char *url) { int err = 0; URLContext *uc = NULL; uc = (URLContext*)malloc(sizeof(URLContext) + strlen(url) + 1); if(uc == NULL) { printf("Allocate for http context failed.\n"); return 0; } uc->filename = (char *) &uc[1]; strcpy(uc->filename, url); uc->prot = &ff_http_protocol; uc->flags = AVIO_RDONLY; uc->is_streamed = 0; /* default = not streamed */ uc->max_packet_size = 0; /* default: stream file */ if (uc->prot->priv_data_size) { uc->priv_data = malloc(uc->prot->priv_data_size); if (uc->prot->priv_data_class) { *(const AVClass**)uc->priv_data = uc->prot->priv_data_class; av_opt_set_defaults(uc->priv_data); } } err = uc->prot->url_open(uc, uc->filename, uc->flags); if (err) return err; uc->is_connected = 1; FILE *fp = fopen("httpstream.dat", "wb"); if(fp == NULL) return 0; uint8_t buffer[2048]; int len = 0; while(1) { len = uc->prot->url_read(uc, buffer, 2048); if (len == 0) break; fwrite(buffer, 1, len, fp); printf("recev %d byte from httpserver.\n", len); } fclose(fp); uc->prot->url_close(uc); free(uc); return 1; }
static int open_encoder(struct videnc_state *st, const struct vidsz *size, enum AVPixelFormat pix_fmt) { int ret, err = 0; if (st->ctx) avcodec_free_context(&st->ctx); st->ctx = avcodec_alloc_context3(h265_encoder); if (!st->ctx) { err = ENOMEM; goto out; } av_opt_set_defaults(st->ctx); st->ctx->bit_rate = st->bitrate; st->ctx->width = size->w; st->ctx->height = size->h; st->ctx->pix_fmt = pix_fmt; st->ctx->time_base.num = 1; st->ctx->time_base.den = st->fps; st->ctx->gop_size = 10 * st->fps; if (0 == strcmp(h265_encoder->name, "libx265")) { av_opt_set(st->ctx->priv_data, "profile", "main444-8", 0); av_opt_set(st->ctx->priv_data, "preset", "ultrafast", 0); av_opt_set(st->ctx->priv_data, "tune", "zerolatency", 0); } ret = avcodec_open2(st->ctx, h265_encoder, NULL); if (ret < 0) { warning("h265: encoder: avcodec open failed ret=%d\n", ret); err = ENOENT; goto out; } out: if (err) { if (st->ctx) avcodec_free_context(&st->ctx); } return err; }
AVFilterGraph *avfilter_graph_alloc(void) { AVFilterGraph *ret = av_mallocz(sizeof(*ret)); if (!ret) return NULL; ret->internal = av_mallocz(sizeof(*ret->internal)); if (!ret->internal) { av_freep(&ret); return NULL; } ret->av_class = &filtergraph_class; av_opt_set_defaults(ret); return ret; }
/*************************初始化输出视频*************************/ int init_output(const videoFile* inVideo,const char* filename,videoFile* pOutVideo) { pOutVideo->video_st = av_new_stream(pOutVideo->pFormatCtx, 0); if (pOutVideo->video_st==NULL) { return -1; } AVOutputFormat* fmt = pOutVideo->pFormatCtx->oformat; pOutVideo->pCodecCtx = pOutVideo->video_st->codec; pOutVideo->pCodecCtx->codec_id = fmt->video_codec; pOutVideo->pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO; pOutVideo->pCodecCtx->pix_fmt=PIX_FMT_YUV420P; pOutVideo->pCodecCtx->width = inVideo->pCodecCtx->width; pOutVideo->pCodecCtx->height = inVideo->pCodecCtx->height; pOutVideo->pCodecCtx->time_base.num = 1; pOutVideo->pCodecCtx->time_base.den =25; //pOutVideo->pCodecCtx->bit_rate = inVideo->pCodecCtx->bit_rate; //pOutVideo->pCodecCtx->gop_size=inVideo->pCodecCtx->gop_size; //pOutVideo->pCodecCtx->qmin = inVideo->pCodecCtx->qmin; //pOutVideo->pCodecCtx->qmax = inVideo->pCodecCtx->qmax; //pOutVideo->pCodecCtx->qcompress = 0; //pOutVideo->pCodecCtx->max_b_frames=0; //H264 pOutVideo->pCodecCtx->me_range=1; pOutVideo->pCodecCtx->max_qdiff = 4; av_opt_set_defaults(&pOutVideo->pCodecCtx->priv_data); AVDictionary* codec_options=NULL; set_opt(&codec_options); pOutVideo->pCodec = avcodec_find_encoder(AV_CODEC_ID_H264); if (avcodec_open2(pOutVideo->pCodecCtx, pOutVideo->pCodec,&codec_options) < 0) { fprintf(stderr,"编码器打开失败!\n"); return -1; } //av_opt_set(pOutVideo->pCodecCtx->priv_data, "preset","ultrafast", 0); //av_opt_set_defaults(pOutVideo->pCodecCtx->priv_data); }
static int url_alloc_for_protocol (URLContext **puc, struct URLProtocol *up, const char *filename, int flags) { URLContext *uc; int err; #if CONFIG_NETWORK if (!ff_network_init()) return AVERROR(EIO); #endif uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1); if (!uc) { err = AVERROR(ENOMEM); goto fail; } #if FF_API_URL_CLASS uc->av_class = &urlcontext_class; #endif uc->filename = (char *) &uc[1]; strcpy(uc->filename, filename); uc->prot = up; uc->flags = flags; uc->is_streamed = 0; /* default = not streamed */ uc->max_packet_size = 0; /* default: stream file */ if (up->priv_data_size) { uc->priv_data = av_mallocz(up->priv_data_size); if (up->priv_data_class) { *(const AVClass**)uc->priv_data = up->priv_data_class; av_opt_set_defaults(uc->priv_data); } } *puc = uc; return 0; fail: *puc = NULL; #if CONFIG_NETWORK ff_network_close(); #endif return err; }
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; }
AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name) { AVFilterContext *ret; if (!filter) return NULL; ret = av_mallocz(sizeof(AVFilterContext)); if (!ret) return NULL; ret->av_class = &avfilter_class; ret->filter = filter; ret->name = inst_name ? av_strdup(inst_name) : NULL; if (filter->priv_size) { ret->priv = av_mallocz(filter->priv_size); if (!ret->priv) goto err; } if (filter->priv_class) { *(const AVClass**)ret->priv = filter->priv_class; av_opt_set_defaults(ret->priv); } ret->nb_inputs = avfilter_pad_count(filter->inputs); if (ret->nb_inputs ) { ret->input_pads = av_malloc(sizeof(AVFilterPad) * ret->nb_inputs); if (!ret->input_pads) goto err; memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs); ret->inputs = av_mallocz(sizeof(AVFilterLink*) * ret->nb_inputs); if (!ret->inputs) goto err; } ret->nb_outputs = avfilter_pad_count(filter->outputs); if (ret->nb_outputs) { ret->output_pads = av_malloc(sizeof(AVFilterPad) * ret->nb_outputs); if (!ret->output_pads) goto err; memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs); ret->outputs = av_mallocz(sizeof(AVFilterLink*) * ret->nb_outputs); if (!ret->outputs) goto err; } #if FF_API_FOO_COUNT ret->output_count = ret->nb_outputs; ret->input_count = ret->nb_inputs; #endif return ret; err: av_freep(&ret->inputs); av_freep(&ret->input_pads); ret->nb_inputs = 0; av_freep(&ret->outputs); av_freep(&ret->output_pads); ret->nb_outputs = 0; av_freep(&ret->priv); av_free(ret); return NULL; }
static int process_options(AVFilterContext *ctx, AVDictionary **options, const char *args) { const AVOption *o = NULL; int ret, count = 0; char *av_uninit(parsed_key), *av_uninit(value); const char *key; int offset= -1; av_opt_set_defaults(ctx); if (!args) return 0; while (*args) { const char *shorthand = NULL; o = av_opt_next(ctx->priv, o); if (o) { if (o->type == AV_OPT_TYPE_CONST || o->offset == offset) continue; offset = o->offset; shorthand = o->name; } ret = av_opt_get_key_value(&args, "=", ":", shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0, &parsed_key, &value); if (ret < 0) { if (ret == AVERROR(EINVAL)) av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args); else av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args, av_err2str(ret)); return ret; } if (*args) args++; if (parsed_key) { key = parsed_key; while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */ } else { key = shorthand; } av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value); if (av_opt_find(ctx, key, NULL, 0, 0)) { ret = av_opt_set(ctx, key, value, 0); if (ret < 0) return ret; } else { av_dict_set(options, key, value, 0); if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) { if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) { if (ret == AVERROR_OPTION_NOT_FOUND) av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key); av_free(value); av_free(parsed_key); return ret; } } } av_free(value); av_free(parsed_key); count++; } if (ctx->enable_str) { ret = set_enable_expr(ctx, ctx->enable_str); if (ret < 0) return ret; } return count; }
void VideoStream::SetupFormat( ) { /* allocate the output media context */ ofc = NULL; #if ((LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53, 5, 0)) && (LIBAVFORMAT_VERSION_MICRO >= 100)) avformat_alloc_output_context2( &ofc, NULL, format, filename ); #else AVFormatContext *s= avformat_alloc_context(); if(!s) { Fatal( "avformat_alloc_context failed %d \"%s\"", (size_t)ofc, av_err2str((size_t)ofc) ); } AVOutputFormat *oformat; if (format) { #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52, 45, 0) oformat = av_guess_format(format, NULL, NULL); #else oformat = guess_format(format, NULL, NULL); #endif if (!oformat) { Fatal( "Requested output format '%s' is not a suitable output format", format ); } } else { #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52, 45, 0) oformat = av_guess_format(NULL, filename, NULL); #else oformat = guess_format(NULL, filename, NULL); #endif if (!oformat) { Fatal( "Unable to find a suitable output format for '%s'", format ); } } s->oformat = oformat; if (s->oformat->priv_data_size > 0) { s->priv_data = av_mallocz(s->oformat->priv_data_size); if (!s->priv_data) { Fatal( "Could not allocate private data for output format." ); } #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52, 92, 0) if (s->oformat->priv_class) { *(const AVClass**)s->priv_data = s->oformat->priv_class; av_opt_set_defaults(s->priv_data); } #endif } else { s->priv_data = NULL; } if(filename) { snprintf( s->filename, sizeof(s->filename), filename ); } ofc = s; #endif if ( !ofc ) { Fatal( "avformat_alloc_..._context failed: %d", ofc ); } of = ofc->oformat; Debug( 1, "Using output format: %s (%s)", of->name, of->long_name ); }
int FrameScaler::SetResize(int srcWidth,int srcHeight,int srcLineWidth,int dstWidth,int dstHeight,int dstLineWidth) { // Check Size if (!srcWidth || !srcHeight || !srcLineWidth || !dstWidth || !dstHeight || !dstLineWidth) { //If we got a context if (resizeCtx) //Closse context sws_freeContext(resizeCtx); // No valid context resizeCtx = NULL; //Exit return 0; } // Check if we already have a scaler for this if (resizeCtx && (resizeWidth==srcWidth) && (srcHeight==resizeHeight) && (dstWidth==resizeDstWidth) && (dstHeight==resizeDstHeight)) //Done return 1; //If we already got a context if (resizeCtx) //Closse context sws_freeContext(resizeCtx); // Create new context if (!(resizeCtx = sws_alloc_context())) // Exit return 0; // Set property's of context av_opt_set_defaults(resizeCtx); av_opt_set_int(resizeCtx, "srcw", srcWidth ,AV_OPT_SEARCH_CHILDREN); av_opt_set_int(resizeCtx, "srch", srcHeight ,AV_OPT_SEARCH_CHILDREN); av_opt_set_int(resizeCtx, "src_format", PIX_FMT_YUV420P ,AV_OPT_SEARCH_CHILDREN); av_opt_set_int(resizeCtx, "dstw", dstWidth ,AV_OPT_SEARCH_CHILDREN); av_opt_set_int(resizeCtx, "dsth", dstHeight ,AV_OPT_SEARCH_CHILDREN); av_opt_set_int(resizeCtx, "dst_format", PIX_FMT_YUV420P ,AV_OPT_SEARCH_CHILDREN); av_opt_set_int(resizeCtx, "sws_flags", resizeFlags ,AV_OPT_SEARCH_CHILDREN); // Init context if (sws_init_context(resizeCtx, NULL, NULL) < 0) { //Free context sws_freeContext(resizeCtx); //Nullify it resizeCtx = NULL; // Exit return Error("Couldn't init sws context"); } // Set values resizeWidth = srcWidth; resizeHeight = srcHeight; resizeDstWidth = dstWidth; resizeDstHeight = dstHeight; resizeDstLineWidth = dstLineWidth; //to use MM2 we need the width and heinght to be multiple of 32 tmpWidth = (resizeDstWidth/32 +1)*32; tmpHeight = (resizeDstHeight/32 +1)*32; //Get tmp buffer size tmpBufferSize = tmpWidth*tmpHeight*3/2+FF_INPUT_BUFFER_PADDING_SIZE+32; //Check if we had it already if (tmpBuffer) //Free it free(tmpBuffer); //Allocate it tmpBuffer = (BYTE*)malloc(tmpBufferSize); // Set values for line sizes resizeSrc[0] = srcLineWidth; resizeSrc[1] = srcLineWidth/2; resizeSrc[2] = srcLineWidth/2; /*resizeDst[0] = dstLineWidth; resizeDst[1] = dstLineWidth/2; resizeDst[2] = dstLineWidth/2;*/ resizeDst[0] = tmpWidth; resizeDst[1] = tmpWidth/2; resizeDst[2] = tmpWidth/2; //Get tmp planes tmpY = ALIGNTO32(tmpBuffer); tmpU = tmpY+tmpWidth*tmpHeight; tmpV = tmpU+tmpWidth*tmpHeight/4; // exit return 1; }
static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up, const char *filename, int flags, const AVIOInterruptCB *int_cb) { URLContext *uc; int err; #if CONFIG_NETWORK if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init()) return AVERROR(EIO); #endif if ((flags & AVIO_FLAG_READ) && !up->url_read) { av_log(NULL, AV_LOG_ERROR, "Impossible to open the '%s' protocol for reading\n", up->name); return AVERROR(EIO); } if ((flags & AVIO_FLAG_WRITE) && !up->url_write) { av_log(NULL, AV_LOG_ERROR, "Impossible to open the '%s' protocol for writing\n", up->name); return AVERROR(EIO); } uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1); if (!uc) { err = AVERROR(ENOMEM); goto fail; } uc->av_class = &ffurl_context_class; uc->filename = (char *)&uc[1]; strcpy(uc->filename, filename); uc->prot = up; uc->flags = flags; uc->is_streamed = 0; /* default = not streamed */ uc->max_packet_size = 0; /* default: stream file */ if (up->priv_data_size) { uc->priv_data = av_mallocz(up->priv_data_size); if (!uc->priv_data) { err = AVERROR(ENOMEM); goto fail; } if (up->priv_data_class) { int proto_len= strlen(up->name); char *start = strchr(uc->filename, ','); *(const AVClass **)uc->priv_data = up->priv_data_class; av_opt_set_defaults(uc->priv_data); if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){ int ret= 0; char *p= start; char sep= *++p; char *key, *val; p++; if (strcmp(up->name, "subfile")) ret = AVERROR(EINVAL); while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){ *val= *key= 0; if (strcmp(p, "start") && strcmp(p, "end")) { ret = AVERROR_OPTION_NOT_FOUND; } else ret= av_opt_set(uc->priv_data, p, key+1, 0); if (ret == AVERROR_OPTION_NOT_FOUND) av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p); *val= *key= sep; p= val+1; } if(ret<0 || p!=key){ av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start); av_freep(&uc->priv_data); av_freep(&uc); err = AVERROR(EINVAL); goto fail; } memmove(start, key+1, strlen(key)); } } } if (int_cb) uc->interrupt_callback = *int_cb; *puc = uc; return 0; fail: *puc = NULL; if (uc) av_freep(&uc->priv_data); av_freep(&uc); #if CONFIG_NETWORK if (up->flags & URL_PROTOCOL_FLAG_NETWORK) ff_network_close(); #endif return err; }
QVector<QPair<QString, QString>> CameraDevice::getRawDeviceListGeneric() { QVector<QPair<QString, QString>> devices; if (!getDefaultInputFormat()) return devices; // Alloc an input device context AVFormatContext *s; if (!(s = avformat_alloc_context())) return devices; if (!iformat->priv_class || !AV_IS_INPUT_DEVICE(iformat->priv_class->category)) { avformat_free_context(s); return devices; } s->iformat = iformat; if (s->iformat->priv_data_size > 0) { s->priv_data = av_mallocz(s->iformat->priv_data_size); if (!s->priv_data) { avformat_free_context(s); return devices; } if (s->iformat->priv_class) { *(const AVClass**)s->priv_data= s->iformat->priv_class; av_opt_set_defaults(s->priv_data); } } else { s->priv_data = NULL; } // List the devices for this context AVDeviceInfoList* devlist = nullptr; AVDictionary *tmp = nullptr; av_dict_copy(&tmp, nullptr, 0); if (av_opt_set_dict2(s, &tmp, AV_OPT_SEARCH_CHILDREN) < 0) { av_dict_free(&tmp); avformat_free_context(s); } avdevice_list_devices(s, &devlist); if (!devlist) { qWarning() << "avdevice_list_devices failed"; return devices; } // Convert the list to a QVector devices.resize(devlist->nb_devices); for (int i=0; i<devlist->nb_devices; i++) { AVDeviceInfo* dev = devlist->devices[i]; devices[i].first = dev->device_name; devices[i].second = dev->device_description; } avdevice_free_list_devices(&devlist); return devices; }
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; }
AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name) { AVFilterContext *ret; if (!filter) return NULL; ret = av_mallocz(sizeof(AVFilterContext)); if (!ret) return NULL; ret->av_class = &avfilter_class; ret->filter = filter; ret->name = inst_name ? av_strdup(inst_name) : NULL; if (filter->priv_size) { ret->priv = av_mallocz(filter->priv_size); if (!ret->priv) goto err; } av_opt_set_defaults(ret); if (filter->priv_class) { *(const AVClass**)ret->priv = filter->priv_class; av_opt_set_defaults(ret->priv); } ret->internal = av_mallocz(sizeof(*ret->internal)); if (!ret->internal) goto err; ret->internal->execute = default_execute; ret->nb_inputs = avfilter_pad_count(filter->inputs); if (ret->nb_inputs ) { ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad)); if (!ret->input_pads) goto err; memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs); ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*)); if (!ret->inputs) goto err; } ret->nb_outputs = avfilter_pad_count(filter->outputs); if (ret->nb_outputs) { ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad)); if (!ret->output_pads) goto err; memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs); ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*)); if (!ret->outputs) goto err; } #if FF_API_FOO_COUNT FF_DISABLE_DEPRECATION_WARNINGS ret->output_count = ret->nb_outputs; ret->input_count = ret->nb_inputs; FF_ENABLE_DEPRECATION_WARNINGS #endif return ret; err: av_freep(&ret->inputs); av_freep(&ret->input_pads); ret->nb_inputs = 0; av_freep(&ret->outputs); av_freep(&ret->output_pads); ret->nb_outputs = 0; av_freep(&ret->priv); av_freep(&ret->internal); av_free(ret); return NULL; }