@@ -2086,9 +2086,6 @@ pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.

 @item n

 the number of input frame, starting from 0

-@item pos

-the position in the file of the input frame, NAN if unknown

-

 @item t

 timestamp expressed in seconds, NAN if the input timestamp is unknown

@@ -1627,8 +1627,8 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

                                               (AVRational){1, ist->st->codec->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,

                                               (AVRational){1, ist->st->codec->sample_rate});

     for (i = 0; i < ist->nb_filters; i++)

-        av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame,

-                               AV_BUFFERSRC_FLAG_PUSH);

+        av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);

+        /* TODO re-add AV_BUFFERSRC_FLAG_PUSH */

     decoded_frame->pts = AV_NOPTS_VALUE;

@@ -1737,7 +1737,7 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)

                                  AV_BUFFERSRC_FLAG_NO_COPY |

                                  AV_BUFFERSRC_FLAG_PUSH);

         } else

-        if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, AV_BUFFERSRC_FLAG_PUSH)<0) {

+        if(av_buffersrc_add_frame_flags(ist->filters[i]->filter, decoded_frame, AV_BUFFERSRC_FLAG_PUSH)<0) {

             av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");

             exit(1);

         }

@@ -33,7 +33,6 @@ OBJS = allfilters.o                                                     \

        avfilter.o                                                       \

        avfiltergraph.o                                                  \

        buffer.o                                                         \

-       buffersink.o                                                     \

        buffersrc.o                                                      \

        drawutils.o                                                      \

        fifo.o                                                           \

@@ -41,7 +40,6 @@ OBJS = allfilters.o                                                     \

        graphdump.o                                                      \

        graphparser.o                                                    \

        sink_buffer.o                                                    \

-       src_buffer.o                                                     \

        transform.o                                                      \

        video.o                                                          \

@@ -135,23 +135,23 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static int  filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

+static int  filter_frame(AVFilterLink *inlink, AVFrame *insamplesref)

 {

     AConvertContext *aconvert = inlink->dst->priv;

-    const int n = insamplesref->audio->nb_samples;

+    const int n = insamplesref->nb_samples;

     AVFilterLink *const outlink = inlink->dst->outputs[0];

-    AVFilterBufferRef *outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n);

+    AVFrame *outsamplesref = ff_get_audio_buffer(outlink, n);

     int ret;

-    swr_convert(aconvert->swr, outsamplesref->data, n,

-                        (void *)insamplesref->data, n);

+    swr_convert(aconvert->swr, outsamplesref->extended_data, n,

+                        (void *)insamplesref->extended_data, n);

-    avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);

-    outsamplesref->audio->channels       = outlink->channels;

-    outsamplesref->audio->channel_layout = outlink->channel_layout;

+    av_frame_copy_props(outsamplesref, insamplesref);

+    outsamplesref->channels       = outlink->channels;

+    outsamplesref->channel_layout = outlink->channel_layout;

     ret = ff_filter_frame(outlink, outsamplesref);

-    avfilter_unref_buffer(insamplesref);

+    av_frame_free(&insamplesref);

     return ret;

 }

@@ -160,7 +160,6 @@ static const AVFilterPad aconvert_inputs[] = {

         .name         = "default",

         .type         = AVMEDIA_TYPE_AUDIO,

         .filter_frame = filter_frame,

-        .min_perms    = AV_PERM_READ,

     },

     { NULL }

 };

@@ -232,22 +232,22 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

 {

     AudioFadeContext *afade = inlink->dst->priv;

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

-    int nb_samples          = buf->audio->nb_samples;

-    AVFilterBufferRef *out_buf;

+    int nb_samples          = buf->nb_samples;

+    AVFrame *out_buf;

     int64_t cur_sample = av_rescale_q(buf->pts, (AVRational){1, outlink->sample_rate}, outlink->time_base);

     if ((!afade->type && (afade->start_sample + afade->nb_samples < cur_sample)) ||

         ( afade->type && (cur_sample + afade->nb_samples < afade->start_sample)))

         return ff_filter_frame(outlink, buf);

-    if (buf->perms & AV_PERM_WRITE) {

+    if (av_frame_is_writable(buf)) {

         out_buf = buf;

     } else {

-        out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples);

+        out_buf = ff_get_audio_buffer(inlink, nb_samples);

         if (!out_buf)

             return AVERROR(ENOMEM);

         out_buf->pts = buf->pts;

@@ -256,7 +256,7 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

     if ((!afade->type && (cur_sample + nb_samples < afade->start_sample)) ||

         ( afade->type && (afade->start_sample + afade->nb_samples < cur_sample))) {

         av_samples_set_silence(out_buf->extended_data, 0, nb_samples,

-                               out_buf->audio->channels, out_buf->format);

+                               out_buf->channels, out_buf->format);

     } else {

         int64_t start;

@@ -266,13 +266,13 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

             start = afade->start_sample + afade->nb_samples - cur_sample;

         afade->fade_samples(out_buf->extended_data, buf->extended_data,

-                            nb_samples, buf->audio->channels,

+                            nb_samples, buf->channels,

                             afade->type ? -1 : 1, start,

                             afade->nb_samples, afade->curve);

     }

     if (buf != out_buf)

-        avfilter_unref_buffer(buf);

+        av_frame_free(&buf);

     return ff_filter_frame(outlink, out_buf);

 }

@@ -219,14 +219,14 @@ static inline void copy_samples(int nb_inputs, struct amerge_input in[],

     }

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)

 {

     AVFilterContext *ctx = inlink->dst;

     AMergeContext *am = ctx->priv;

     AVFilterLink *const outlink = ctx->outputs[0];

     int input_number;

     int nb_samples, ns, i;

-    AVFilterBufferRef *outbuf, *inbuf[SWR_CH_MAX];

+    AVFrame *outbuf, *inbuf[SWR_CH_MAX];

     uint8_t *ins[SWR_CH_MAX], *outs;

     for (input_number = 0; input_number < am->nb_inputs; input_number++)

@@ -235,39 +235,40 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)

     av_assert1(input_number < am->nb_inputs);

     if (ff_bufqueue_is_full(&am->in[input_number].queue)) {

         av_log(ctx, AV_LOG_ERROR, "Buffer queue overflow\n");

-        avfilter_unref_buffer(insamples);

+        av_frame_free(&insamples);

         return AVERROR(ENOMEM);

     }

-    ff_bufqueue_add(ctx, &am->in[input_number].queue, insamples);

-    am->in[input_number].nb_samples += insamples->audio->nb_samples;

+    ff_bufqueue_add(ctx, &am->in[input_number].queue, av_frame_clone(insamples));

+    am->in[input_number].nb_samples += insamples->nb_samples;

+    av_frame_free(&insamples);

     nb_samples = am->in[0].nb_samples;

     for (i = 1; i < am->nb_inputs; i++)

         nb_samples = FFMIN(nb_samples, am->in[i].nb_samples);

     if (!nb_samples)

         return 0;

-    outbuf = ff_get_audio_buffer(ctx->outputs[0], AV_PERM_WRITE, nb_samples);

+    outbuf = ff_get_audio_buffer(ctx->outputs[0], nb_samples);

     outs = outbuf->data[0];

     for (i = 0; i < am->nb_inputs; i++) {

         inbuf[i] = ff_bufqueue_peek(&am->in[i].queue, 0);

         ins[i] = inbuf[i]->data[0] +

                  am->in[i].pos * am->in[i].nb_ch * am->bps;

     }

-    avfilter_copy_buffer_ref_props(outbuf, inbuf[0]);

+    av_frame_copy_props(outbuf, inbuf[0]);

     outbuf->pts = inbuf[0]->pts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :

                   inbuf[0]->pts +

                   av_rescale_q(am->in[0].pos,

                                (AVRational){ 1, ctx->inputs[0]->sample_rate },

                                ctx->outputs[0]->time_base);

-    outbuf->audio->nb_samples     = nb_samples;

-    outbuf->audio->channel_layout = outlink->channel_layout;

-    outbuf->audio->channels       = outlink->channels;

+    outbuf->nb_samples     = nb_samples;

+    outbuf->channel_layout = outlink->channel_layout;

+    outbuf->channels       = outlink->channels;

     while (nb_samples) {

         ns = nb_samples;

         for (i = 0; i < am->nb_inputs; i++)

-            ns = FFMIN(ns, inbuf[i]->audio->nb_samples - am->in[i].pos);

+            ns = FFMIN(ns, inbuf[i]->nb_samples - am->in[i].pos);

         /* Unroll the most common sample formats: speed +~350% for the loop,

            +~13% overall (including two common decoders) */

         switch (am->bps) {

@@ -289,9 +290,9 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)

         for (i = 0; i < am->nb_inputs; i++) {

             am->in[i].nb_samples -= ns;

             am->in[i].pos += ns;

-            if (am->in[i].pos == inbuf[i]->audio->nb_samples) {

+            if (am->in[i].pos == inbuf[i]->nb_samples) {

                 am->in[i].pos = 0;

-                avfilter_unref_buffer(inbuf[i]);

+                av_frame_free(&inbuf[i]);

                 ff_bufqueue_get(&am->in[i].queue);

                 inbuf[i] = ff_bufqueue_peek(&am->in[i].queue, 0);

                 ins[i] = inbuf[i] ? inbuf[i]->data[0] : NULL;

@@ -322,7 +323,6 @@ static av_cold int init(AVFilterContext *ctx, const char *args)

             .name             = name,

             .type             = AVMEDIA_TYPE_AUDIO,

             .filter_frame     = filter_frame,

-            .min_perms        = AV_PERM_READ | AV_PERM_PRESERVE,

         };

         if (!name)

             return AVERROR(ENOMEM);

@@ -270,18 +270,18 @@ static int output_frame(AVFilterLink *outlink, int nb_samples)

 {

     AVFilterContext *ctx = outlink->src;

     MixContext      *s = ctx->priv;

-    AVFilterBufferRef *out_buf, *in_buf;

+    AVFrame *out_buf, *in_buf;

     int i;

     calculate_scales(s, nb_samples);

-    out_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);

+    out_buf = ff_get_audio_buffer(outlink, nb_samples);

     if (!out_buf)

         return AVERROR(ENOMEM);

-    in_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);

+    in_buf = ff_get_audio_buffer(outlink, nb_samples);

     if (!in_buf) {

-        avfilter_unref_buffer(out_buf);

+        av_frame_free(&out_buf);

         return AVERROR(ENOMEM);

     }

@@ -303,7 +303,7 @@ static int output_frame(AVFilterLink *outlink, int nb_samples)

             }

         }

     }

-    avfilter_unref_buffer(in_buf);

+    av_frame_free(&in_buf);

     out_buf->pts = s->next_pts;

     if (s->next_pts != AV_NOPTS_VALUE)

@@ -450,7 +450,7 @@ static int request_frame(AVFilterLink *outlink)

     return output_frame(outlink, available_samples);

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

 {

     AVFilterContext  *ctx = inlink->dst;

     MixContext       *s = ctx->priv;

@@ -469,16 +469,16 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

     if (i == 0) {

         int64_t pts = av_rescale_q(buf->pts, inlink->time_base,

                                    outlink->time_base);

-        ret = frame_list_add_frame(s->frame_list, buf->audio->nb_samples, pts);

+        ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts);

         if (ret < 0)

             goto fail;

     }

     ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,

-                              buf->audio->nb_samples);

+                              buf->nb_samples);

 fail:

-    avfilter_unref_buffer(buf);

+    av_frame_free(&buf);

     return ret;

 }

@@ -77,15 +77,15 @@ static av_cold int init(AVFilterContext *ctx, const char *args)

     return 0;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *frame)

+static int filter_frame(AVFilterLink *inlink, AVFrame *frame)

 {

     AVFilterContext *ctx = inlink->dst;

     APadContext *apad = ctx->priv;

     if (apad->whole_len)

-        apad->whole_len -= frame->audio->nb_samples;

+        apad->whole_len -= frame->nb_samples;

-    apad->next_pts = frame->pts + av_rescale_q(frame->audio->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);

+    apad->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);

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

 }

@@ -99,7 +99,7 @@ static int request_frame(AVFilterLink *outlink)

     if (ret == AVERROR_EOF) {

         int n_out = apad->packet_size;

-        AVFilterBufferRef *outsamplesref;

+        AVFrame *outsamplesref;

         if (apad->whole_len > 0) {

             apad->pad_len = apad->whole_len;

@@ -113,16 +113,16 @@ static int request_frame(AVFilterLink *outlink)

         if(!n_out)

             return AVERROR_EOF;

-        outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);

+        outsamplesref = ff_get_audio_buffer(outlink, n_out);

         if (!outsamplesref)

             return AVERROR(ENOMEM);

-        av_assert0(outsamplesref->audio->sample_rate == outlink->sample_rate);

-        av_assert0(outsamplesref->audio->nb_samples  == n_out);

+        av_assert0(outsamplesref->sample_rate == outlink->sample_rate);

+        av_assert0(outsamplesref->nb_samples  == n_out);

         av_samples_set_silence(outsamplesref->extended_data, 0,

                                n_out,

-                               outsamplesref->audio->channels,

+                               outsamplesref->channels,

                                outsamplesref->format);

         outsamplesref->pts = apad->next_pts;

@@ -174,23 +174,23 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

+static int filter_frame(AVFilterLink *inlink, AVFrame *insamplesref)

 {

     AResampleContext *aresample = inlink->dst->priv;

-    const int n_in  = insamplesref->audio->nb_samples;

+    const int n_in  = insamplesref->nb_samples;

     int n_out       = n_in * aresample->ratio * 2 + 256;

     AVFilterLink *const outlink = inlink->dst->outputs[0];

-    AVFilterBufferRef *outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);

+    AVFrame *outsamplesref = ff_get_audio_buffer(outlink, n_out);

     int ret;

     if(!outsamplesref)

         return AVERROR(ENOMEM);

-    avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);

+    av_frame_copy_props(outsamplesref, insamplesref);

     outsamplesref->format                = outlink->format;

-    outsamplesref->audio->channels       = outlink->channels;

-    outsamplesref->audio->channel_layout = outlink->channel_layout;

-    outsamplesref->audio->sample_rate    = outlink->sample_rate;

+    outsamplesref->channels              = outlink->channels;

+    outsamplesref->channel_layout        = outlink->channel_layout;

+    outsamplesref->sample_rate           = outlink->sample_rate;

     if(insamplesref->pts != AV_NOPTS_VALUE) {

         int64_t inpts = av_rescale(insamplesref->pts, inlink->time_base.num * (int64_t)outlink->sample_rate * inlink->sample_rate, inlink->time_base.den);

@@ -203,16 +203,16 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

     n_out = swr_convert(aresample->swr, outsamplesref->extended_data, n_out,

                                  (void *)insamplesref->extended_data, n_in);

     if (n_out <= 0) {

-        avfilter_unref_buffer(outsamplesref);

-        avfilter_unref_buffer(insamplesref);

+        av_frame_free(&outsamplesref);

+        av_frame_free(&insamplesref);

         return 0;

     }

-    outsamplesref->audio->nb_samples  = n_out;

+    outsamplesref->nb_samples  = n_out;

     ret = ff_filter_frame(outlink, outsamplesref);

     aresample->req_fullfilled= 1;

-    avfilter_unref_buffer(insamplesref);

+    av_frame_free(&insamplesref);

     return ret;

 }

@@ -229,20 +229,20 @@ static int request_frame(AVFilterLink *outlink)

     }while(!aresample->req_fullfilled && ret>=0);

     if (ret == AVERROR_EOF) {

-        AVFilterBufferRef *outsamplesref;

+        AVFrame *outsamplesref;

         int n_out = 4096;

-        outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);

+        outsamplesref = ff_get_audio_buffer(outlink, n_out);

         if (!outsamplesref)

             return AVERROR(ENOMEM);

         n_out = swr_convert(aresample->swr, outsamplesref->extended_data, n_out, 0, 0);

         if (n_out <= 0) {

-            avfilter_unref_buffer(outsamplesref);

+            av_frame_free(&outsamplesref);

             return (n_out == 0) ? AVERROR_EOF : n_out;

         }

-        outsamplesref->audio->sample_rate = outlink->sample_rate;

-        outsamplesref->audio->nb_samples  = n_out;

+        outsamplesref->sample_rate = outlink->sample_rate;

+        outsamplesref->nb_samples  = n_out;

 #if 0

         outsamplesref->pts = aresample->next_pts;

         if(aresample->next_pts != AV_NOPTS_VALUE)

@@ -263,7 +263,6 @@ static const AVFilterPad aresample_inputs[] = {

         .name         = "default",

         .type         = AVMEDIA_TYPE_AUDIO,

         .filter_frame = filter_frame,

-        .min_perms    = AV_PERM_READ,

     },

     { NULL },

 };

@@ -93,7 +93,7 @@ static int config_props_output(AVFilterLink *outlink)

 static int push_samples(AVFilterLink *outlink)

 {

     ASNSContext *asns = outlink->src->priv;

-    AVFilterBufferRef *outsamples = NULL;

+    AVFrame *outsamples = NULL;

     int nb_out_samples, nb_pad_samples;

     if (asns->pad) {

@@ -107,7 +107,7 @@ static int push_samples(AVFilterLink *outlink)

     if (!nb_out_samples)

         return 0;

-    outsamples = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_out_samples);

+    outsamples = ff_get_audio_buffer(outlink, nb_out_samples);

     av_assert0(outsamples);

     av_audio_fifo_read(asns->fifo,

@@ -117,9 +117,9 @@ static int push_samples(AVFilterLink *outlink)

         av_samples_set_silence(outsamples->extended_data, nb_out_samples - nb_pad_samples,

                                nb_pad_samples, av_get_channel_layout_nb_channels(outlink->channel_layout),

                                outlink->format);

-    outsamples->audio->nb_samples     = nb_out_samples;

-    outsamples->audio->channel_layout = outlink->channel_layout;

-    outsamples->audio->sample_rate    = outlink->sample_rate;

+    outsamples->nb_samples     = nb_out_samples;

+    outsamples->channel_layout = outlink->channel_layout;

+    outsamples->sample_rate    = outlink->sample_rate;

     outsamples->pts = asns->next_out_pts;

     if (asns->next_out_pts != AV_NOPTS_VALUE)

@@ -130,13 +130,13 @@ static int push_samples(AVFilterLink *outlink)

     return nb_out_samples;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)

 {

     AVFilterContext *ctx = inlink->dst;

     ASNSContext *asns = ctx->priv;

     AVFilterLink *outlink = ctx->outputs[0];

     int ret;

-    int nb_samples = insamples->audio->nb_samples;

+    int nb_samples = insamples->nb_samples;

     if (av_audio_fifo_space(asns->fifo) < nb_samples) {

         av_log(ctx, AV_LOG_DEBUG, "No space for %d samples, stretching audio fifo\n", nb_samples);

@@ -150,7 +150,7 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)

     av_audio_fifo_write(asns->fifo, (void **)insamples->extended_data, nb_samples);

     if (asns->next_out_pts == AV_NOPTS_VALUE)

         asns->next_out_pts = insamples->pts;

-    avfilter_unref_buffer(insamples);

+    av_frame_free(&insamples);

     while (av_audio_fifo_size(asns->fifo) >= asns->nb_out_samples)

         push_samples(outlink);

@@ -177,10 +177,10 @@ static int request_frame(AVFilterLink *outlink)

 static const AVFilterPad asetnsamples_inputs[] = {

     {

-        .name         = "default",

-        .type         = AVMEDIA_TYPE_AUDIO,

-        .filter_frame = filter_frame,

-        .min_perms    = AV_PERM_READ | AV_PERM_WRITE,

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .filter_frame   = filter_frame,

+        .needs_writable = 1,

     },

     {  NULL }

 };

@@ -55,16 +55,16 @@ static void uninit(AVFilterContext *ctx)

     av_freep(&s->plane_checksums);

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

 {

     AVFilterContext *ctx = inlink->dst;

     AShowInfoContext *s  = ctx->priv;

     char chlayout_str[128];

     uint32_t checksum = 0;

-    int channels    = av_get_channel_layout_nb_channels(buf->audio->channel_layout);

+    int channels    = av_get_channel_layout_nb_channels(buf->channel_layout);

     int planar      = av_sample_fmt_is_planar(buf->format);

     int block_align = av_get_bytes_per_sample(buf->format) * (planar ? 1 : channels);

-    int data_size   = buf->audio->nb_samples * block_align;

+    int data_size   = buf->nb_samples * block_align;

     int planes      = planar ? channels : 1;

     int i;

     void *tmp_ptr = av_realloc(s->plane_checksums, channels * sizeof(*s->plane_checksums));

@@ -82,7 +82,7 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

     }

     av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,

-                                 buf->audio->channel_layout);

+                                 buf->channel_layout);

     av_log(ctx, AV_LOG_INFO,

            "n:%"PRIu64" pts:%s pts_time:%s pos:%"PRId64" "

@@ -90,9 +90,9 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

            "checksum:%08X ",

            s->frame,

            av_ts2str(buf->pts), av_ts2timestr(buf->pts, &inlink->time_base),

-           buf->pos,

-           av_get_sample_fmt_name(buf->format), buf->audio->channels, chlayout_str,

-           buf->audio->sample_rate, buf->audio->nb_samples,

+           av_frame_get_pkt_pos(buf),

+           av_get_sample_fmt_name(buf->format), av_frame_get_channels(buf), chlayout_str,

+           buf->sample_rate, buf->nb_samples,

            checksum);

     av_log(ctx, AV_LOG_INFO, "plane_checksums: [ ");

@@ -110,7 +110,6 @@ static const AVFilterPad inputs[] = {

         .type             = AVMEDIA_TYPE_AUDIO,

         .get_audio_buffer = ff_null_get_audio_buffer,

         .filter_frame     = filter_frame,

-        .min_perms        = AV_PERM_READ,

     },

     { NULL },

 };

@@ -48,7 +48,7 @@ typedef struct {

     AVExpr *expr;

     double var_values[VAR_NB];

     struct buf_queue {

-        AVFilterBufferRef *buf[QUEUE_SIZE];

+        AVFrame *buf[QUEUE_SIZE];

         unsigned tail, nb;

         /* buf[tail] is the oldest,

            buf[(tail + nb) % QUEUE_SIZE] is where the next is added */

@@ -111,16 +111,16 @@ static int send_out(AVFilterContext *ctx, int out_id)

 {

     AStreamSyncContext *as = ctx->priv;

     struct buf_queue *queue = &as->queue[out_id];

-    AVFilterBufferRef *buf = queue->buf[queue->tail];

+    AVFrame *buf = queue->buf[queue->tail];

     int ret;

     queue->buf[queue->tail] = NULL;

     as->var_values[VAR_B1 + out_id]++;

-    as->var_values[VAR_S1 + out_id] += buf->audio->nb_samples;

+    as->var_values[VAR_S1 + out_id] += buf->nb_samples;

     if (buf->pts != AV_NOPTS_VALUE)

         as->var_values[VAR_T1 + out_id] =

             av_q2d(ctx->outputs[out_id]->time_base) * buf->pts;

-    as->var_values[VAR_T1 + out_id] += buf->audio->nb_samples /

+    as->var_values[VAR_T1 + out_id] += buf->nb_samples /

                                    (double)ctx->inputs[out_id]->sample_rate;

     ret = ff_filter_frame(ctx->outputs[out_id], buf);

     queue->nb--;

@@ -167,7 +167,7 @@ static int request_frame(AVFilterLink *outlink)

     return 0;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)

 {

     AVFilterContext *ctx = inlink->dst;

     AStreamSyncContext *as = ctx->priv;

@@ -185,12 +185,10 @@ static const AVFilterPad astreamsync_inputs[] = {

         .name         = "in1",

         .type         = AVMEDIA_TYPE_AUDIO,

         .filter_frame = filter_frame,

-        .min_perms    = AV_PERM_READ | AV_PERM_PRESERVE,

     },{

         .name         = "in2",

         .type         = AVMEDIA_TYPE_AUDIO,

         .filter_frame = filter_frame,

-        .min_perms    = AV_PERM_READ | AV_PERM_PRESERVE,

     },

     { NULL }

 };

@@ -152,14 +152,13 @@ static int request_frame(AVFilterLink *link)

             handle_trimming(ctx);

         if (nb_samples = get_delay(s)) {

-            AVFilterBufferRef *buf = ff_get_audio_buffer(link, AV_PERM_WRITE,

-                                                         nb_samples);

+            AVFrame *buf = ff_get_audio_buffer(link, nb_samples);

             if (!buf)

                 return AVERROR(ENOMEM);

             ret = avresample_convert(s->avr, buf->extended_data,

                                      buf->linesize[0], nb_samples, NULL, 0, 0);

             if (ret <= 0) {

-                avfilter_unref_bufferp(&buf);

+                av_frame_free(&buf);

                 return (ret < 0) ? ret : AVERROR_EOF;

             }

@@ -171,20 +170,20 @@ static int request_frame(AVFilterLink *link)

     return ret;

 }

-static int write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)

+static int write_to_fifo(ASyncContext *s, AVFrame *buf)

 {

     int ret = avresample_convert(s->avr, NULL, 0, 0, buf->extended_data,

-                                 buf->linesize[0], buf->audio->nb_samples);

-    avfilter_unref_buffer(buf);

+                                 buf->linesize[0], buf->nb_samples);

+    av_frame_free(&buf);

     return ret;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

 {

     AVFilterContext  *ctx = inlink->dst;

     ASyncContext       *s = ctx->priv;

     AVFilterLink *outlink = ctx->outputs[0];

-    int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);

+    int nb_channels = av_get_channel_layout_nb_channels(buf->channel_layout);

     int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :

                   av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);

     int out_size, ret;

@@ -223,8 +222,7 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

     }

     if (out_size > 0) {

-        AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,

-                                                         out_size);

+        AVFrame *buf_out = ff_get_audio_buffer(outlink, out_size);

         if (!buf_out) {

             ret = AVERROR(ENOMEM);

             goto fail;

@@ -266,11 +264,11 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

     s->pts = pts - avresample_get_delay(s->avr);

     ret = avresample_convert(s->avr, NULL, 0, 0, buf->extended_data,

-                             buf->linesize[0], buf->audio->nb_samples);

+                             buf->linesize[0], buf->nb_samples);

     s->first_frame = 0;

 fail:

-    avfilter_unref_buffer(buf);

+    av_frame_free(&buf);

     return ret;

 }

@@ -140,7 +140,7 @@ typedef struct {

     // for managing AVFilterPad.request_frame and AVFilterPad.filter_frame

     int request_fulfilled;

-    AVFilterBufferRef *dst_buffer;

+    AVFrame *dst_buffer;

     uint8_t *dst;

     uint8_t *dst_end;

     uint64_t nsamples_in;

@@ -177,7 +177,7 @@ static void yae_clear(ATempoContext *atempo)

     atempo->frag[0].position[0] = -(int64_t)(atempo->window / 2);

     atempo->frag[0].position[1] = -(int64_t)(atempo->window / 2);

-    avfilter_unref_bufferp(&atempo->dst_buffer);

+    av_frame_free(&atempo->dst_buffer);

     atempo->dst     = NULL;

     atempo->dst_end = NULL;

@@ -1024,8 +1024,8 @@ static void push_samples(ATempoContext *atempo,

                          AVFilterLink *outlink,

                          int n_out)

 {

-    atempo->dst_buffer->audio->sample_rate = outlink->sample_rate;

-    atempo->dst_buffer->audio->nb_samples  = n_out;

+    atempo->dst_buffer->sample_rate = outlink->sample_rate;

+    atempo->dst_buffer->nb_samples  = n_out;

     // adjust the PTS:

     atempo->dst_buffer->pts =

@@ -1041,14 +1041,13 @@ static void push_samples(ATempoContext *atempo,

     atempo->nsamples_out += n_out;

 }

-static int filter_frame(AVFilterLink *inlink,

-                           AVFilterBufferRef *src_buffer)

+static int filter_frame(AVFilterLink *inlink, AVFrame *src_buffer)

 {

     AVFilterContext  *ctx = inlink->dst;

     ATempoContext *atempo = ctx->priv;

     AVFilterLink *outlink = ctx->outputs[0];

-    int n_in = src_buffer->audio->nb_samples;

+    int n_in = src_buffer->nb_samples;

     int n_out = (int)(0.5 + ((double)n_in) / atempo->tempo);

     const uint8_t *src = src_buffer->data[0];

@@ -1056,10 +1055,8 @@ static int filter_frame(AVFilterLink *inlink,

     while (src < src_end) {

         if (!atempo->dst_buffer) {

-            atempo->dst_buffer = ff_get_audio_buffer(outlink,

-                                                     AV_PERM_WRITE,

-                                                     n_out);

-            avfilter_copy_buffer_ref_props(atempo->dst_buffer, src_buffer);

+            atempo->dst_buffer = ff_get_audio_buffer(outlink, n_out);

+            av_frame_copy_props(atempo->dst_buffer, src_buffer);

             atempo->dst = atempo->dst_buffer->data[0];

             atempo->dst_end = atempo->dst + n_out * atempo->stride;

@@ -1074,7 +1071,7 @@ static int filter_frame(AVFilterLink *inlink,

     }

     atempo->nsamples_in += n_in;

-    avfilter_unref_bufferp(&src_buffer);

+    av_frame_free(&src_buffer);

     return 0;

 }

@@ -1098,9 +1095,7 @@ static int request_frame(AVFilterLink *outlink)

         while (err == AVERROR(EAGAIN)) {

             if (!atempo->dst_buffer) {

-                atempo->dst_buffer = ff_get_audio_buffer(outlink,

-                                                         AV_PERM_WRITE,

-                                                         n_max);

+                atempo->dst_buffer = ff_get_audio_buffer(outlink, n_max);

                 atempo->dst = atempo->dst_buffer->data[0];

                 atempo->dst_end = atempo->dst + n_max * atempo->stride;

@@ -1116,7 +1111,7 @@ static int request_frame(AVFilterLink *outlink)

             }

         }

-        avfilter_unref_bufferp(&atempo->dst_buffer);

+        av_frame_free(&atempo->dst_buffer);

         atempo->dst     = NULL;

         atempo->dst_end = NULL;

@@ -1142,7 +1137,6 @@ static const AVFilterPad atempo_inputs[] = {

         .type         = AVMEDIA_TYPE_AUDIO,

         .filter_frame = filter_frame,

         .config_props = config_props,

-        .min_perms    = AV_PERM_READ,

     },

     { NULL }

 };

@@ -392,24 +392,24 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

 {

     BiquadsContext *p       = inlink->dst->priv;

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

-    AVFilterBufferRef *out_buf;

-    int nb_samples = buf->audio->nb_samples;

+    AVFrame *out_buf;

+    int nb_samples = buf->nb_samples;

     int ch;

-    if (buf->perms & AV_PERM_WRITE) {

+    if (av_frame_is_writable(buf)) {

         out_buf = buf;

     } else {

-        out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples);

+        out_buf = ff_get_audio_buffer(inlink, nb_samples);

         if (!out_buf)

             return AVERROR(ENOMEM);

         out_buf->pts = buf->pts;

     }

-    for (ch = 0; ch < buf->audio->channels; ch++)

+    for (ch = 0; ch < buf->channels; ch++)

         p->filter(buf->extended_data[ch],

                   out_buf->extended_data[ch], nb_samples,

                   &p->cache[ch].i1, &p->cache[ch].i2,

@@ -417,7 +417,7 @@ static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

                   p->b0, p->b1, p->b2, p->a1, p->a2);

     if (buf != out_buf)

-        avfilter_unref_buffer(buf);

+        av_frame_free(&buf);

     return ff_filter_frame(outlink, out_buf);

 }

@@ -312,7 +312,7 @@ static int channelmap_query_formats(AVFilterContext *ctx)

     return 0;

 }

-static int channelmap_filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)

 {

     AVFilterContext  *ctx = inlink->dst;

     AVFilterLink *outlink = ctx->outputs[0];

@@ -330,7 +330,7 @@ static int channelmap_filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)

             uint8_t **new_extended_data =

                 av_mallocz(nch_out * sizeof(*buf->extended_data));

             if (!new_extended_data) {

-                avfilter_unref_buffer(buf);

+                av_frame_free(&buf);

                 return AVERROR(ENOMEM);