X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavfilter%2Favfilter.c;h=99ed8fab3b818e64b3dabef8b9e11fe9e352270f;hb=801ab9808863415a80a576b26c45cb06187cc239;hp=a7a009f085b5e1e2e183e6168ffa4eaead59ce59;hpb=999c23a13aaf8b2f773d56ccafd38290fc5f7af0;p=ffmpeg diff --git a/libavfilter/avfilter.c b/libavfilter/avfilter.c index a7a009f085b..99ed8fab3b8 100644 --- a/libavfilter/avfilter.c +++ b/libavfilter/avfilter.c @@ -21,8 +21,11 @@ /* #define DEBUG */ -#include "libavcodec/imgconvert.h" +#include "libavcodec/audioconvert.c" +#include "libavutil/pixdesc.h" +#include "libavcore/imgutils.h" #include "avfilter.h" +#include "internal.h" unsigned avfilter_version(void) { return LIBAVFILTER_VERSION_INT; @@ -43,19 +46,38 @@ const char *avfilter_license(void) #define link_dpad(link) link->dst-> input_pads[link->dstpad] #define link_spad(link) link->src->output_pads[link->srcpad] -AVFilterPicRef *avfilter_ref_pic(AVFilterPicRef *ref, int pmask) +AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask) { - AVFilterPicRef *ret = av_malloc(sizeof(AVFilterPicRef)); + AVFilterBufferRef *ret = av_malloc(sizeof(AVFilterBufferRef)); + if (!ret) + return NULL; *ret = *ref; + if (ref->type == AVMEDIA_TYPE_VIDEO) { + ret->video = av_malloc(sizeof(AVFilterBufferRefVideoProps)); + if (!ret->video) { + av_free(ret); + return NULL; + } + *ret->video = *ref->video; + } else if (ref->type == AVMEDIA_TYPE_AUDIO) { + ret->audio = av_malloc(sizeof(AVFilterBufferRefAudioProps)); + if (!ret->audio) { + av_free(ret); + return NULL; + } + *ret->audio = *ref->audio; + } ret->perms &= pmask; - ret->pic->refcount ++; + ret->buf->refcount ++; return ret; } -void avfilter_unref_pic(AVFilterPicRef *ref) +void avfilter_unref_buffer(AVFilterBufferRef *ref) { - if(!(--ref->pic->refcount)) - ref->pic->free(ref->pic); + if (!(--ref->buf->refcount)) + ref->buf->free(ref->buf); + av_free(ref->video); + av_free(ref->audio); av_free(ref); } @@ -74,10 +96,10 @@ void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, memcpy(*pads+idx, newpad, sizeof(AVFilterPad)); (*links)[idx] = NULL; - (*count) ++; - for(i = idx+1; i < *count; i ++) - if(*links[i]) - (*(unsigned *)((uint8_t *) *links[i] + padidx_off)) ++; + (*count)++; + for (i = idx+1; i < *count; i++) + if (*links[i]) + (*(unsigned *)((uint8_t *) *links[i] + padidx_off))++; } int avfilter_link(AVFilterContext *src, unsigned srcpad, @@ -85,8 +107,8 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad, { AVFilterLink *link; - if(src->output_count <= srcpad || dst->input_count <= dstpad || - src->outputs[srcpad] || dst->inputs[dstpad]) + if (src->output_count <= srcpad || dst->input_count <= dstpad || + src->outputs[srcpad] || dst->inputs[dstpad]) return -1; src->outputs[srcpad] = @@ -96,7 +118,9 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad, link->dst = dst; link->srcpad = srcpad; link->dstpad = dstpad; - link->format = PIX_FMT_NONE; + link->type = src->output_pads[srcpad].type; + assert(PIX_FMT_NONE == -1 && SAMPLE_FMT_NONE == -1); + link->format = -1; return 0; } @@ -104,11 +128,12 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad, int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, unsigned in, unsigned out) { - av_log(link->dst, AV_LOG_INFO, "auto-inserting filter '%s'\n", - filt->name); + av_log(link->dst, AV_LOG_INFO, "auto-inserting filter '%s' " + "between the filter '%s' and the filter '%s'\n", + filt->name, link->src->name, link->dst->name); link->dst->inputs[link->dstpad] = NULL; - if(avfilter_link(filt, out, link->dst, link->dstpad)) { + if (avfilter_link(filt, out, link->dst, link->dstpad)) { /* failed to link output filter to new filter */ link->dst->inputs[link->dstpad] = link; return -1; @@ -119,9 +144,9 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, link->dstpad = in; filt->inputs[in] = link; - /* if any information on supported colorspaces already exists on the + /* if any information on supported media formats already exists on the * link, we need to preserve that */ - if(link->out_formats) + if (link->out_formats) avfilter_formats_changeref(&link->out_formats, &filt->outputs[out]->out_formats); @@ -133,12 +158,12 @@ int avfilter_config_links(AVFilterContext *filter) int (*config_link)(AVFilterLink *); unsigned i; - for(i = 0; i < filter->input_count; i ++) { + for (i = 0; i < filter->input_count; i ++) { AVFilterLink *link = filter->inputs[i]; - if(!link) continue; + if (!link) continue; - switch(link->init_state) { + switch (link->init_state) { case AVLINK_INIT: continue; case AVLINK_STARTINIT: @@ -147,16 +172,16 @@ int avfilter_config_links(AVFilterContext *filter) case AVLINK_UNINIT: link->init_state = AVLINK_STARTINIT; - if(avfilter_config_links(link->src)) + if (avfilter_config_links(link->src)) return -1; - if(!(config_link = link_spad(link).config_props)) + if (!(config_link = link_spad(link).config_props)) config_link = avfilter_default_config_output_link; - if(config_link(link)) + if (config_link(link)) return -1; - if((config_link = link_dpad(link).config_props)) - if(config_link(link)) + if ((config_link = link_dpad(link).config_props)) + if (config_link(link)) return -1; link->init_state = AVLINK_INIT; @@ -166,68 +191,95 @@ int avfilter_config_links(AVFilterContext *filter) return 0; } -static void dprintf_picref(void *ctx, AVFilterPicRef *picref, int end) +void ff_dprintf_picref(void *ctx, AVFilterBufferRef *picref, int end) { dprintf(ctx, - "picref[%p data[%p, %p, %p, %p] linesize[%d, %d, %d, %d] pts:%"PRId64" s:%dx%d]%s", + "picref[%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64, picref, - picref->data [0], picref->data [1], picref->data [2], picref->data [3], + picref->data[0], picref->linesize[0], picref->linesize[1], picref->linesize[2], picref->linesize[3], - picref->pts, picref->w, picref->h, - end ? "\n" : ""); + picref->pts, picref->pos); + + if (picref->video) { + dprintf(ctx, " a:%d/%d s:%dx%d i:%c", + picref->video->pixel_aspect.num, picref->video->pixel_aspect.den, + picref->video->w, picref->video->h, + !picref->video->interlaced ? 'P' : /* Progressive */ + picref->video->top_field_first ? 'T' : 'B'); /* Top / Bottom */ + } + dprintf(ctx, "]%s", end ? "\n" : ""); } -static void dprintf_link(void *ctx, AVFilterLink *link, int end) +void ff_dprintf_link(void *ctx, AVFilterLink *link, int end) { dprintf(ctx, "link[%p s:%dx%d fmt:%-16s %-16s->%-16s]%s", link, link->w, link->h, - avcodec_get_pix_fmt_name(link->format), + av_pix_fmt_descriptors[link->format].name, link->src ? link->src->filter->name : "", link->dst ? link->dst->filter->name : "", end ? "\n" : ""); } -#define DPRINTF_START(ctx, func) dprintf(NULL, "%-16s: ", #func) - -AVFilterPicRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h) +AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h) { - AVFilterPicRef *ret = NULL; + AVFilterBufferRef *ret = NULL; - DPRINTF_START(NULL, get_video_buffer); dprintf_link(NULL, link, 0); dprintf(NULL, " perms:%d w:%d h:%d\n", perms, w, h); + FF_DPRINTF_START(NULL, get_video_buffer); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " perms:%d w:%d h:%d\n", perms, w, h); - if(link_dpad(link).get_video_buffer) + if (link_dpad(link).get_video_buffer) ret = link_dpad(link).get_video_buffer(link, perms, w, h); - if(!ret) + if (!ret) ret = avfilter_default_get_video_buffer(link, perms, w, h); - DPRINTF_START(NULL, get_video_buffer); dprintf_link(NULL, link, 0); dprintf(NULL, " returning "); dprintf_picref(NULL, ret, 1); + if (ret) + ret->type = AVMEDIA_TYPE_VIDEO; + + FF_DPRINTF_START(NULL, get_video_buffer); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " returning "); ff_dprintf_picref(NULL, ret, 1); + + return ret; +} + +AVFilterBufferRef *avfilter_get_audio_buffer(AVFilterLink *link, int perms, + enum SampleFormat sample_fmt, int size, + int64_t channel_layout, int planar) +{ + AVFilterBufferRef *ret = NULL; + + if (link_dpad(link).get_audio_buffer) + ret = link_dpad(link).get_audio_buffer(link, perms, sample_fmt, size, channel_layout, planar); + + if (!ret) + ret = avfilter_default_get_audio_buffer(link, perms, sample_fmt, size, channel_layout, planar); + + if (ret) + ret->type = AVMEDIA_TYPE_AUDIO; return ret; } int avfilter_request_frame(AVFilterLink *link) { - DPRINTF_START(NULL, request_frame); dprintf_link(NULL, link, 1); + FF_DPRINTF_START(NULL, request_frame); ff_dprintf_link(NULL, link, 1); - if(link_spad(link).request_frame) + if (link_spad(link).request_frame) return link_spad(link).request_frame(link); - else if(link->src->inputs[0]) + else if (link->src->inputs[0]) return avfilter_request_frame(link->src->inputs[0]); else return -1; } int avfilter_poll_frame(AVFilterLink *link) { - int i, min=INT_MAX; + int i, min = INT_MAX; - if(link_spad(link).poll_frame) + if (link_spad(link).poll_frame) return link_spad(link).poll_frame(link); - for (i=0; isrc->input_count; i++) { + for (i = 0; i < link->src->input_count; i++) { int val; - if(!link->src->inputs[i]) + if (!link->src->inputs[i]) return -1; val = avfilter_poll_frame(link->src->inputs[i]); min = FFMIN(min, val); @@ -238,96 +290,126 @@ int avfilter_poll_frame(AVFilterLink *link) /* XXX: should we do the duplicating of the picture ref here, instead of * forcing the source filter to do it? */ -void avfilter_start_frame(AVFilterLink *link, AVFilterPicRef *picref) +void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref) { - void (*start_frame)(AVFilterLink *, AVFilterPicRef *); + void (*start_frame)(AVFilterLink *, AVFilterBufferRef *); AVFilterPad *dst = &link_dpad(link); - DPRINTF_START(NULL, start_frame); dprintf_link(NULL, link, 0); dprintf(NULL, " "); dprintf_picref(NULL, picref, 1); + FF_DPRINTF_START(NULL, start_frame); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " "); ff_dprintf_picref(NULL, picref, 1); - if(!(start_frame = dst->start_frame)) + if (!(start_frame = dst->start_frame)) start_frame = avfilter_default_start_frame; /* prepare to copy the picture if it has insufficient permissions */ - if((dst->min_perms & picref->perms) != dst->min_perms || - dst->rej_perms & picref->perms) { - /* - av_log(link->dst, AV_LOG_INFO, + if ((dst->min_perms & picref->perms) != dst->min_perms || + dst->rej_perms & picref->perms) { + av_log(link->dst, AV_LOG_DEBUG, "frame copy needed (have perms %x, need %x, reject %x)\n", picref->perms, link_dpad(link).min_perms, link_dpad(link).rej_perms); - */ - link->cur_pic = avfilter_default_get_video_buffer(link, dst->min_perms, link->w, link->h); - link->srcpic = picref; - link->cur_pic->pts = link->srcpic->pts; - link->cur_pic->pixel_aspect = link->srcpic->pixel_aspect; + link->cur_buf = avfilter_default_get_video_buffer(link, dst->min_perms, link->w, link->h); + link->src_buf = picref; + avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf); } else - link->cur_pic = picref; + link->cur_buf = picref; - start_frame(link, link->cur_pic); + start_frame(link, link->cur_buf); } void avfilter_end_frame(AVFilterLink *link) { void (*end_frame)(AVFilterLink *); - if(!(end_frame = link_dpad(link).end_frame)) + if (!(end_frame = link_dpad(link).end_frame)) end_frame = avfilter_default_end_frame; end_frame(link); /* unreference the source picture if we're feeding the destination filter * a copied version dues to permission issues */ - if(link->srcpic) { - avfilter_unref_pic(link->srcpic); - link->srcpic = NULL; + if (link->src_buf) { + avfilter_unref_buffer(link->src_buf); + link->src_buf = NULL; } - } void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { uint8_t *src[4], *dst[4]; - int i, j, hsub, vsub; + int i, j, vsub; void (*draw_slice)(AVFilterLink *, int, int, int); - DPRINTF_START(NULL, draw_slice); dprintf_link(NULL, link, 0); dprintf(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir); + FF_DPRINTF_START(NULL, draw_slice); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir); /* copy the slice if needed for permission reasons */ - if(link->srcpic) { - avcodec_get_chroma_sub_sample(link->format, &hsub, &vsub); - - for(i = 0; i < 4; i ++) { - if(link->srcpic->data[i]) { - src[i] = link->srcpic-> data[i] + - (y >> (i==0 ? 0 : vsub)) * link->srcpic-> linesize[i]; - dst[i] = link->cur_pic->data[i] + - (y >> (i==0 ? 0 : vsub)) * link->cur_pic->linesize[i]; + if (link->src_buf) { + vsub = av_pix_fmt_descriptors[link->format].log2_chroma_h; + + for (i = 0; i < 4; i++) { + if (link->src_buf->data[i]) { + src[i] = link->src_buf-> data[i] + + (y >> (i==0 ? 0 : vsub)) * link->src_buf-> linesize[i]; + dst[i] = link->cur_buf->data[i] + + (y >> (i==0 ? 0 : vsub)) * link->cur_buf->linesize[i]; } else src[i] = dst[i] = NULL; } - for(i = 0; i < 4; i ++) { + for (i = 0; i < 4; i++) { int planew = - ff_get_plane_bytewidth(link->format, link->cur_pic->w, i); + av_get_image_linesize(link->format, link->cur_buf->video->w, i); - if(!src[i]) continue; + if (!src[i]) continue; - for(j = 0; j < h >> (i==0 ? 0 : vsub); j ++) { + for (j = 0; j < h >> (i==0 ? 0 : vsub); j++) { memcpy(dst[i], src[i], planew); - src[i] += link->srcpic ->linesize[i]; - dst[i] += link->cur_pic->linesize[i]; + src[i] += link->src_buf->linesize[i]; + dst[i] += link->cur_buf->linesize[i]; } } } - if(!(draw_slice = link_dpad(link).draw_slice)) + if (!(draw_slice = link_dpad(link).draw_slice)) draw_slice = avfilter_default_draw_slice; draw_slice(link, y, h, slice_dir); } +void avfilter_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref) +{ + void (*filter_samples)(AVFilterLink *, AVFilterBufferRef *); + AVFilterPad *dst = &link_dpad(link); + + if (!(filter_samples = dst->filter_samples)) + filter_samples = avfilter_default_filter_samples; + + /* prepare to copy the samples if the buffer has insufficient permissions */ + if ((dst->min_perms & samplesref->perms) != dst->min_perms || + dst->rej_perms & samplesref->perms) { + + av_log(link->dst, AV_LOG_DEBUG, + "Copying audio data in avfilter (have perms %x, need %x, reject %x)\n", + samplesref->perms, link_dpad(link).min_perms, link_dpad(link).rej_perms); + + link->cur_buf = avfilter_default_get_audio_buffer(link, dst->min_perms, + samplesref->format, + samplesref->audio->size, + samplesref->audio->channel_layout, + samplesref->audio->planar); + link->cur_buf->pts = samplesref->pts; + link->cur_buf->audio->sample_rate = samplesref->audio->sample_rate; + + /* Copy actual data into new samples buffer */ + memcpy(link->cur_buf->data[0], samplesref->data[0], samplesref->audio->size); + + avfilter_unref_buffer(samplesref); + } else + link->cur_buf = samplesref; + + filter_samples(link, link->cur_buf); +} + #define MAX_REGISTERED_AVFILTERS_NB 64 static AVFilter *registered_avfilters[MAX_REGISTERED_AVFILTERS_NB + 1]; @@ -381,15 +463,18 @@ static const char *filter_name(void *p) static const AVClass avfilter_class = { "AVFilter", - filter_name + filter_name, + NULL, + LIBAVUTIL_VERSION_INT, }; -AVFilterContext *avfilter_open(AVFilter *filter, const char *inst_name) +int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name) { AVFilterContext *ret; + *filter_ctx = NULL; if (!filter) - return 0; + return AVERROR(EINVAL); ret = av_mallocz(sizeof(AVFilterContext)); @@ -412,24 +497,33 @@ AVFilterContext *avfilter_open(AVFilter *filter, const char *inst_name) ret->outputs = av_mallocz(sizeof(AVFilterLink*) * ret->output_count); } - return ret; + *filter_ctx = ret; + return 0; } void avfilter_destroy(AVFilterContext *filter) { int i; - if(filter->filter->uninit) + if (filter->filter->uninit) filter->filter->uninit(filter); - for(i = 0; i < filter->input_count; i ++) { - if(filter->inputs[i]) - filter->inputs[i]->src->outputs[filter->inputs[i]->srcpad] = NULL; + for (i = 0; i < filter->input_count; i++) { + if (filter->inputs[i]) { + if (filter->inputs[i]->src) + filter->inputs[i]->src->outputs[filter->inputs[i]->srcpad] = NULL; + avfilter_formats_unref(&filter->inputs[i]->in_formats); + avfilter_formats_unref(&filter->inputs[i]->out_formats); + } av_freep(&filter->inputs[i]); } - for(i = 0; i < filter->output_count; i ++) { - if(filter->outputs[i]) - filter->outputs[i]->dst->inputs[filter->outputs[i]->dstpad] = NULL; + for (i = 0; i < filter->output_count; i++) { + if (filter->outputs[i]) { + if (filter->outputs[i]->dst) + filter->outputs[i]->dst->inputs[filter->outputs[i]->dstpad] = NULL; + avfilter_formats_unref(&filter->outputs[i]->in_formats); + avfilter_formats_unref(&filter->outputs[i]->out_formats); + } av_freep(&filter->outputs[i]); } @@ -446,7 +540,7 @@ int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque { int ret=0; - if(filter->filter->init) + if (filter->filter->init) ret = filter->filter->init(filter, args, opaque); return ret; }