@@ -179,114 +179,3 @@ AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,

                                                               nb_samples, sample_fmt,

                                                               channels, channel_layout);

 }

-

-static int default_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)

-{

-    return ff_filter_frame(link->dst->outputs[0], frame);

-}

-

-int ff_filter_samples_framed(AVFilterLink *link, AVFilterBufferRef *samplesref)

-{

-    int (*filter_frame)(AVFilterLink *, AVFilterBufferRef *);

-    AVFilterPad *src = link->srcpad;

-    AVFilterPad *dst = link->dstpad;

-    int64_t pts;

-    AVFilterBufferRef *buf_out;

-    int ret;

-

-    FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1);

-

-    if (link->closed) {

-        avfilter_unref_buffer(samplesref);

-        return AVERROR_EOF;

-    }

-

-    if (!(filter_frame = dst->filter_frame))

-        filter_frame = default_filter_frame;

-

-    av_assert1((samplesref->perms & src->min_perms) == src->min_perms);

-    samplesref->perms &= ~ src->rej_perms;

-

-    /* 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->dstpad->min_perms, link->dstpad->rej_perms);

-

-        buf_out = ff_default_get_audio_buffer(link, dst->min_perms,

-                                              samplesref->audio->nb_samples);

-        if (!buf_out) {

-            avfilter_unref_buffer(samplesref);

-            return AVERROR(ENOMEM);

-        }

-        buf_out->pts                = samplesref->pts;

-        buf_out->audio->sample_rate = samplesref->audio->sample_rate;

-

-        /* Copy actual data into new samples buffer */

-        av_samples_copy(buf_out->extended_data, samplesref->extended_data,

-                        0, 0, samplesref->audio->nb_samples,

-                        av_get_channel_layout_nb_channels(link->channel_layout),

-                        link->format);

-

-        avfilter_unref_buffer(samplesref);

-    } else

-        buf_out = samplesref;

-

-    link->cur_buf = buf_out;

-    pts = buf_out->pts;

-    ret = filter_frame(link, buf_out);

-    ff_update_link_current_pts(link, pts);

-    return ret;

-}

-

-int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)

-{

-    int insamples = samplesref->audio->nb_samples, inpos = 0, nb_samples;

-    AVFilterBufferRef *pbuf = link->partial_buf;

-    int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);

-    int ret = 0;

-

-    av_assert1(samplesref->format                == link->format);

-    av_assert1(samplesref->audio->channels       == link->channels);

-    av_assert1(samplesref->audio->channel_layout == link->channel_layout);

-    av_assert1(samplesref->audio->sample_rate    == link->sample_rate);

-

-    if (!link->min_samples ||

-        (!pbuf &&

-         insamples >= link->min_samples && insamples <= link->max_samples)) {

-        return ff_filter_samples_framed(link, samplesref);

-    }

-    /* Handle framing (min_samples, max_samples) */

-    while (insamples) {

-        if (!pbuf) {

-            AVRational samples_tb = { 1, link->sample_rate };

-            int perms = link->dstpad->min_perms | AV_PERM_WRITE;

-            pbuf = ff_get_audio_buffer(link, perms, link->partial_buf_size);

-            if (!pbuf) {

-                av_log(link->dst, AV_LOG_WARNING,

-                       "Samples dropped due to memory allocation failure.\n");

-                return 0;

-            }

-            avfilter_copy_buffer_ref_props(pbuf, samplesref);

-            pbuf->pts = samplesref->pts +

-                        av_rescale_q(inpos, samples_tb, link->time_base);

-            pbuf->audio->nb_samples = 0;

-        }

-        nb_samples = FFMIN(insamples,

-                           link->partial_buf_size - pbuf->audio->nb_samples);

-        av_samples_copy(pbuf->extended_data, samplesref->extended_data,

-                        pbuf->audio->nb_samples, inpos,

-                        nb_samples, nb_channels, link->format);

-        inpos                   += nb_samples;

-        insamples               -= nb_samples;

-        pbuf->audio->nb_samples += nb_samples;

-        if (pbuf->audio->nb_samples >= link->min_samples) {

-            ret = ff_filter_samples_framed(link, pbuf);

-            pbuf = NULL;

-        }

-    }

-    avfilter_unref_buffer(samplesref);

-    link->partial_buf = pbuf;

-    return ret;

-}

@@ -34,6 +34,8 @@

 #include "internal.h"

 #include "audio.h"

+static int ff_filter_frame_framed(AVFilterLink *link, AVFilterBufferRef *frame);

+

 char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms)

 {

     snprintf(buf, buf_size, "%s%s%s%s%s%s",

@@ -342,7 +344,7 @@ int ff_request_frame(AVFilterLink *link)

     if (ret == AVERROR_EOF && link->partial_buf) {

         AVFilterBufferRef *pbuf = link->partial_buf;

         link->partial_buf = NULL;

-        ff_filter_samples_framed(link, pbuf);

+        ff_filter_frame_framed(link, pbuf);

         return 0;

     }

     if (ret == AVERROR_EOF)

@@ -631,22 +633,161 @@ enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)

     return pads[pad_idx].type;

 }

+static int default_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)

+{

+    return ff_filter_frame(link->dst->outputs[0], frame);

+}

+

+static int ff_filter_frame_framed(AVFilterLink *link, AVFilterBufferRef *frame)

+{

+    int (*filter_frame)(AVFilterLink *, AVFilterBufferRef *);

+    AVFilterPad *src = link->srcpad;

+    AVFilterPad *dst = link->dstpad;

+    AVFilterBufferRef *out;

+    int perms, ret;

+    AVFilterCommand *cmd= link->dst->command_queue;

+    int64_t pts;

+

+    if (link->closed) {

+        avfilter_unref_buffer(frame);

+        return AVERROR_EOF;

+    }

+

+    if (!(filter_frame = dst->filter_frame))

+        filter_frame = default_filter_frame;

+

+    av_assert1((frame->perms & src->min_perms) == src->min_perms);

+    frame->perms &= ~ src->rej_perms;

+    perms = frame->perms;

+

+    if (frame->linesize[0] < 0)

+        perms |= AV_PERM_NEG_LINESIZES;

+

+    /* prepare to copy the frame if the buffer has insufficient permissions */

+    if ((dst->min_perms & perms) != dst->min_perms ||

+        dst->rej_perms & perms) {

+        av_log(link->dst, AV_LOG_DEBUG,

+               "Copying data in avfilter (have perms %x, need %x, reject %x)\n",

+               perms, link->dstpad->min_perms, link->dstpad->rej_perms);

+

+        /* Maybe use ff_copy_buffer_ref instead? */

+        switch (link->type) {

+        case AVMEDIA_TYPE_VIDEO:

+            out = ff_get_video_buffer(link, dst->min_perms,

+                                      link->w, link->h);

+            break;

+        case AVMEDIA_TYPE_AUDIO:

+            out = ff_get_audio_buffer(link, dst->min_perms,

+                                      frame->audio->nb_samples);

+            break;

+        default: return AVERROR(EINVAL);

+        }

+        if (!out) {

+            avfilter_unref_buffer(frame);

+            return AVERROR(ENOMEM);

+        }

+        avfilter_copy_buffer_ref_props(out, frame);

+

+        switch (link->type) {

+        case AVMEDIA_TYPE_VIDEO:

+            av_image_copy(out->data, out->linesize, frame->data, frame->linesize,

+                          frame->format, frame->video->w, frame->video->h);

+            break;

+        case AVMEDIA_TYPE_AUDIO:

+            av_samples_copy(out->extended_data, frame->extended_data,

+                            0, 0, frame->audio->nb_samples,

+                            av_get_channel_layout_nb_channels(frame->audio->channel_layout),

+                            frame->format);

+            break;

+        default: return AVERROR(EINVAL);

+        }

+

+        avfilter_unref_buffer(frame);

+    } else

+        out = frame;

+

+    while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){

+        av_log(link->dst, AV_LOG_DEBUG,

+               "Processing command time:%f command:%s arg:%s\n",

+               cmd->time, cmd->command, cmd->arg);

+        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);

+        ff_command_queue_pop(link->dst);

+        cmd= link->dst->command_queue;

+    }

+

+    pts = out->pts;

+    ret = filter_frame(link, out);

+    ff_update_link_current_pts(link, pts);

+    return ret;

+}

+

+static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFilterBufferRef *frame)

+{

+    int insamples = frame->audio->nb_samples, inpos = 0, nb_samples;

+    AVFilterBufferRef *pbuf = link->partial_buf;

+    int nb_channels = frame->audio->channels;

+    int ret = 0;

+

+    /* Handle framing (min_samples, max_samples) */

+    while (insamples) {

+        if (!pbuf) {

+            AVRational samples_tb = { 1, link->sample_rate };

+            int perms = link->dstpad->min_perms | AV_PERM_WRITE;

+            pbuf = ff_get_audio_buffer(link, perms, link->partial_buf_size);

+            if (!pbuf) {

+                av_log(link->dst, AV_LOG_WARNING,

+                       "Samples dropped due to memory allocation failure.\n");

+                return 0;

+            }

+            avfilter_copy_buffer_ref_props(pbuf, frame);

+            pbuf->pts = frame->pts +

+                        av_rescale_q(inpos, samples_tb, link->time_base);

+            pbuf->audio->nb_samples = 0;

+        }

+        nb_samples = FFMIN(insamples,

+                           link->partial_buf_size - pbuf->audio->nb_samples);

+        av_samples_copy(pbuf->extended_data, frame->extended_data,

+                        pbuf->audio->nb_samples, inpos,

+                        nb_samples, nb_channels, link->format);

+        inpos                   += nb_samples;

+        insamples               -= nb_samples;

+        pbuf->audio->nb_samples += nb_samples;

+        if (pbuf->audio->nb_samples >= link->min_samples) {

+            ret = ff_filter_frame_framed(link, pbuf);

+            pbuf = NULL;

+        }

+    }

+    avfilter_unref_buffer(frame);

+    link->partial_buf = pbuf;

+    return ret;

+}

+

 int ff_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)

 {

-    int ret;

     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);

-    switch (link->type) {

-    case AVMEDIA_TYPE_VIDEO:

-        if((ret = ff_start_frame(link, frame)) < 0)

-            return ret;

-        if((ret = ff_draw_slice(link, 0, frame->video->h, 1)) < 0)

-            return ret;

-        if((ret = ff_end_frame(link)) < 0)

-            return ret;

-        return ret;

-    case AVMEDIA_TYPE_AUDIO:

-        return ff_filter_samples(link, frame);

-    default: return AVERROR(EINVAL);

+    /* Consistency checks */

+    if (link->type == AVMEDIA_TYPE_VIDEO) {

+        if (strcmp(link->dst->filter->name, "scale")) {

+            av_assert1(frame->format                 == link->format);

+            av_assert1(frame->video->w               == link->w);

+            av_assert1(frame->video->h               == link->h);

+        }

+    } else {

+        av_assert1(frame->format                == link->format);

+        av_assert1(frame->audio->channels       == link->channels);

+        av_assert1(frame->audio->channel_layout == link->channel_layout);

+        av_assert1(frame->audio->sample_rate    == link->sample_rate);

+    }

+

+    /* Go directly to actual filtering if possible */

+    if (link->type == AVMEDIA_TYPE_AUDIO &&

+        link->min_samples &&

+        (link->partial_buf ||

+         frame->audio->nb_samples < link->min_samples ||

+         frame->audio->nb_samples > link->max_samples)) {

+        return ff_filter_frame_needs_framing(link, frame);

+    } else {

+        return ff_filter_frame_framed(link, frame);

     }

 }

@@ -158,204 +158,3 @@ AVFilterBufferRef *ff_get_video_buffer(AVFilterLink *link, int perms, int w, int

     return ret;

 }

-

-static int default_start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)

-{

-    AVFilterLink *outlink = NULL;

-

-    if (inlink->dstpad->filter_frame)

-        return 0;

-

-    if (inlink->dst->nb_outputs)

-        outlink = inlink->dst->outputs[0];

-

-    if (outlink && (inlink->dstpad->start_frame || inlink->dstpad->end_frame)) {

-        AVFilterBufferRef *buf_out;

-        outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);

-        if (!outlink->out_buf)

-            return AVERROR(ENOMEM);

-

-        avfilter_copy_buffer_ref_props(outlink->out_buf, picref);

-        outlink->out_buf->video->w = outlink->w;

-        outlink->out_buf->video->h = outlink->h;

-        buf_out = avfilter_ref_buffer(outlink->out_buf, ~0);

-        if (!buf_out)

-            return AVERROR(ENOMEM);

-

-        return ff_start_frame(outlink, buf_out);

-    }

-    return 0;

-}

-

-static void clear_link(AVFilterLink *link)

-{

-    avfilter_unref_bufferp(&link->cur_buf);

-    avfilter_unref_bufferp(&link->src_buf);

-    avfilter_unref_bufferp(&link->out_buf);

-    link->cur_buf_copy = NULL; /* we do not own the reference */

-}

-

-/* XXX: should we do the duplicating of the picture ref here, instead of

- * forcing the source filter to do it? */

-int ff_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)

-{

-    int (*start_frame)(AVFilterLink *, AVFilterBufferRef *);

-    AVFilterPad *src = link->srcpad;

-    AVFilterPad *dst = link->dstpad;

-    int ret, perms;

-    AVFilterCommand *cmd= link->dst->command_queue;

-    int64_t pts;

-

-    FF_TPRINTF_START(NULL, start_frame); ff_tlog_link(NULL, link, 0); ff_tlog(NULL, " "); ff_tlog_ref(NULL, picref, 1);

-

-    if (strcmp(link->dst->filter->name, "scale")) {

-        av_assert1(picref->format                     == link->format);

-        av_assert1(picref->video->w                   == link->w);

-        av_assert1(picref->video->h                   == link->h);

-    }

-

-    if (link->closed) {

-        avfilter_unref_buffer(picref);

-        return AVERROR_EOF;

-    }

-

-    if (!(start_frame = dst->start_frame))

-        start_frame = default_start_frame;

-

-    av_assert1((picref->perms & src->min_perms) == src->min_perms);

-    picref->perms &= ~ src->rej_perms;

-    perms = picref->perms;

-

-    if (picref->linesize[0] < 0)

-        perms |= AV_PERM_NEG_LINESIZES;

-    /* prepare to copy the picture if it has insufficient permissions */

-    if ((dst->min_perms & perms) != dst->min_perms || dst->rej_perms & perms) {

-        av_log(link->dst, AV_LOG_DEBUG,

-                "frame copy needed (have perms %x, need %x, reject %x)\n",

-                picref->perms,

-                link->dstpad->min_perms, link->dstpad->rej_perms);

-

-        link->cur_buf = ff_get_video_buffer(link, dst->min_perms, link->w, link->h);

-        if (!link->cur_buf) {

-            avfilter_unref_bufferp(&picref);

-            return AVERROR(ENOMEM);

-        }

-

-        link->src_buf = picref;

-        avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf);

-

-        /* copy palette if required */

-        if (av_pix_fmt_desc_get(link->format)->flags & PIX_FMT_PAL)

-            memcpy(link->cur_buf->data[1], link->src_buf-> data[1], AVPALETTE_SIZE);

-    }

-    else

-        link->cur_buf = picref;

-

-    link->cur_buf_copy = link->cur_buf;

-

-    while(cmd && cmd->time <= picref->pts * av_q2d(link->time_base)){

-        av_log(link->dst, AV_LOG_DEBUG,

-               "Processing command time:%f command:%s arg:%s\n",

-               cmd->time, cmd->command, cmd->arg);

-        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);

-        ff_command_queue_pop(link->dst);

-        cmd= link->dst->command_queue;

-    }

-    pts = link->cur_buf->pts;

-    ret = start_frame(link, link->cur_buf);

-    ff_update_link_current_pts(link, pts);

-    if (ret < 0)

-        clear_link(link);

-    else

-        /* incoming buffers must not be freed in start frame,

-           because they can still be in use by the automatic copy mechanism */

-        av_assert1(link->cur_buf_copy->buf->refcount > 0);

-

-    return ret;

-}

-

-static int default_end_frame(AVFilterLink *inlink)

-{

-    AVFilterLink *outlink = NULL;

-

-    if (inlink->dstpad->filter_frame) {

-        int ret = inlink->dstpad->filter_frame(inlink, inlink->cur_buf);

-        inlink->cur_buf = NULL;

-        return ret;

-    }

-

-    if (inlink->dst->nb_outputs)

-        outlink = inlink->dst->outputs[0];

-

-    if (outlink) {

-        if (inlink->dstpad->filter_frame) {

-            int ret = inlink->dstpad->filter_frame(inlink, inlink->cur_buf);

-            inlink->cur_buf = NULL;

-            return ret;

-        } else if (inlink->dstpad->start_frame || inlink->dstpad->end_frame){

-            return ff_end_frame(outlink);

-        } else {

-            int ret = ff_filter_frame(outlink, inlink->cur_buf);

-            inlink->cur_buf = NULL;

-            return ret;

-        }

-    }

-    return 0;

-}

-

-int ff_end_frame(AVFilterLink *link)

-{

-    int (*end_frame)(AVFilterLink *);

-    int ret;

-

-    if (!(end_frame = link->dstpad->end_frame))

-        end_frame = default_end_frame;

-

-    ret = end_frame(link);

-

-    clear_link(link);

-

-    return ret;

-}

-

-int ff_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)

-{

-    uint8_t *src[4], *dst[4];

-    int i, j, vsub;

-

-    FF_TPRINTF_START(NULL, draw_slice); ff_tlog_link(NULL, link, 0); ff_tlog(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);

-

-    /* copy the slice if needed for permission reasons */

-    if (link->src_buf) {

-        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);

-        vsub = desc->log2_chroma_h;

-

-        for (i = 0; i < 4; i++) {

-            if (link->src_buf->data[i]) {

-                src[i] = link->src_buf-> data[i] +

-                    (y >> (i==1 || i==2 ? vsub : 0)) * link->src_buf-> linesize[i];

-                dst[i] = link->cur_buf_copy->data[i] +

-                    (y >> (i==1 || i==2 ? vsub : 0)) * link->cur_buf_copy->linesize[i];

-            } else

-                src[i] = dst[i] = NULL;

-        }

-

-        for (i = 0; i < 4; i++) {

-            int planew =

-                av_image_get_linesize(link->format, link->cur_buf_copy->video->w, i);

-

-            if (!src[i]) continue;

-

-            for (j = 0; j < h >> (i==1 || i==2 ? vsub : 0); j++) {

-                memcpy(dst[i], src[i], planew);

-                src[i] += link->src_buf->linesize[i];

-                dst[i] += link->cur_buf_copy->linesize[i];

-            }

-        }

-    }

-

-        /* incoming buffers must not be freed in start frame,

-           because they can still be in use by the automatic copy mechanism */

-        av_assert1(link->cur_buf_copy->buf->refcount > 0);

-    return 0;

-}