lavfi: drop planar/packed negotiation support

The planar/packed switch and the packing_formats list is no longer
required, since the planar/packed information is now stored in the sample
format enum.

This is technically a major API break, possibly it should be not too
painful as we marked the audio filtering API as unstable.

23 files changed, 59 insertions, 115 deletions

diff --git a/libavfilter/af_aconvert.c b/libavfilter/af_aconvert.c
index 2b3a330..9e27856 100644
--- a/libavfilter/af_aconvert.c
+++ b/libavfilter/af_aconvert.c
@@ -73,7 +73,6 @@ static int query_formats(AVFilterContext *ctx)
     AConvertContext *aconvert = ctx->priv;
     AVFilterLink *inlink  = ctx->inputs[0];
     AVFilterLink *outlink = ctx->outputs[0];
-    int out_packing = av_sample_fmt_is_planar(aconvert->out_sample_fmt);
     AVFilterChannelLayouts *layouts;
 
     avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),
@@ -96,12 +95,6 @@ static int query_formats(AVFilterContext *ctx)
         ff_channel_layouts_ref(ff_all_channel_layouts(),
                              &outlink->in_channel_layouts);
 
-    avfilter_formats_ref(avfilter_make_all_packing_formats(),
-                         &inlink->out_packing);
-    formats = NULL;
-    avfilter_add_format(&formats, out_packing);
-    avfilter_formats_ref(formats, &outlink->in_packing);
-
     return 0;
 }
 
@@ -134,9 +127,9 @@ static int config_output(AVFilterLink *outlink)
     av_get_channel_layout_string(buf2, sizeof(buf2),
                                  -1, outlink->channel_layout);
     av_log(ctx, AV_LOG_INFO,
-           "fmt:%s cl:%s planar:%i -> fmt:%s cl:%s planar:%i\n",
-           av_get_sample_fmt_name(inlink ->format), buf1, inlink ->planar,
-           av_get_sample_fmt_name(outlink->format), buf2, outlink->planar);
+           "fmt:%s cl:%s -> fmt:%s cl:%s\n",
+           av_get_sample_fmt_name(inlink ->format), buf1,
+           av_get_sample_fmt_name(outlink->format), buf2);
 
     return 0;
 }
@@ -153,7 +146,6 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref
 
     avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);
     outsamplesref->audio->channel_layout = outlink->channel_layout;
-    outsamplesref->audio->planar         = outlink->planar;
 
     ff_filter_samples(outlink, outsamplesref);
     avfilter_unref_buffer(insamplesref);
@@ -161,7 +153,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref
 
 AVFilter avfilter_af_aconvert = {
     .name          = "aconvert",
-    .description   = NULL_IF_CONFIG_SMALL("Convert the input audio to sample_fmt:channel_layout:packed_fmt."),
+    .description   = NULL_IF_CONFIG_SMALL("Convert the input audio to sample_fmt:channel_layout."),
     .priv_size     = sizeof(AConvertContext),
     .init          = init,
     .uninit        = uninit,
diff --git a/libavfilter/af_amerge.c b/libavfilter/af_amerge.c
index fcc1089..18b3046 100644
--- a/libavfilter/af_amerge.c
+++ b/libavfilter/af_amerge.c
@@ -54,7 +54,6 @@ static int query_formats(AVFilterContext *ctx)
 {
     AMergeContext *am = ctx->priv;
     int64_t inlayout[2], outlayout;
-    const int packing_fmts[] = { AVFILTER_PACKED, -1 };
     AVFilterFormats *formats;
     AVFilterChannelLayouts *layouts;
     int i;
@@ -97,10 +96,8 @@ static int query_formats(AVFilterContext *ctx)
                 if ((inlayout[i] >> c) & 1)
                     *(route[i]++) = out_ch_number++;
     }
-    formats = avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO);
+    formats = avfilter_make_format_list(ff_packed_sample_fmts);
     avfilter_set_common_sample_formats(ctx, formats);
-    formats = avfilter_make_format_list(packing_fmts);
-    avfilter_set_common_packing_formats(ctx, formats);
     for (i = 0; i < 2; i++) {
         layouts = NULL;
         ff_add_channel_layout(&layouts, inlayout[i]);
@@ -222,7 +219,6 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)
     avfilter_copy_buffer_ref_props(outbuf, *inbuf[0]);
     outbuf->audio->nb_samples     = nb_samples;
     outbuf->audio->channel_layout = outlink->channel_layout;
-    outbuf->audio->planar         = outlink->planar;
 
     while (nb_samples) {
         ns = nb_samples;
diff --git a/libavfilter/af_ashowinfo.c b/libavfilter/af_ashowinfo.c
index 11d85f0..d4198e9 100644
--- a/libavfilter/af_ashowinfo.c
+++ b/libavfilter/af_ashowinfo.c
@@ -50,7 +50,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
     int linesize =
         samplesref->audio->nb_samples *
         av_get_bytes_per_sample(samplesref->format);
-    if (!samplesref->audio->planar) /* packed layout */
+    if (!av_sample_fmt_is_planar(samplesref->format))
         linesize *= av_get_channel_layout_nb_channels(samplesref->audio->channel_layout);
 
     for (plane = 0; samplesref->data[plane] && plane < 8; plane++) {
@@ -66,7 +66,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
 
     av_log(ctx, AV_LOG_INFO,
            "n:%d pts:%s pts_time:%s pos:%"PRId64" "
-           "fmt:%s chlayout:%s nb_samples:%d rate:%d planar:%d "
+           "fmt:%s chlayout:%s nb_samples:%d rate:%d "
            "checksum:%08X plane_checksum[%08X",
            showinfo->frame,
            av_ts2str(samplesref->pts), av_ts2timestr(samplesref->pts, &inlink->time_base),
@@ -75,7 +75,6 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
            chlayout_str,
            samplesref->audio->nb_samples,
            samplesref->audio->sample_rate,
-           samplesref->audio->planar,
            checksum,
            plane_checksum[0]);
 
diff --git a/libavfilter/af_astreamsync.c b/libavfilter/af_astreamsync.c
index 9f04023..c591293 100644
--- a/libavfilter/af_astreamsync.c
+++ b/libavfilter/af_astreamsync.c
@@ -87,9 +87,6 @@ static int query_formats(AVFilterContext *ctx)
         formats = ctx->inputs[i]->in_formats;
         avfilter_formats_ref(formats, &ctx->inputs[i]->out_formats);
         avfilter_formats_ref(formats, &ctx->outputs[i]->in_formats);
-        formats = ctx->inputs[i]->in_packing;
-        avfilter_formats_ref(formats, &ctx->inputs[i]->out_packing);
-        avfilter_formats_ref(formats, &ctx->outputs[i]->in_packing);
         layouts = ctx->inputs[i]->in_channel_layouts;
         ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
         ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts);
diff --git a/libavfilter/af_earwax.c b/libavfilter/af_earwax.c
index 2ab248f..d4884f0 100644
--- a/libavfilter/af_earwax.c
+++ b/libavfilter/af_earwax.c
@@ -86,9 +86,6 @@ static int query_formats(AVFilterContext *ctx)
     avfilter_set_common_sample_formats(ctx, formats);
     ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
     ff_set_common_channel_layouts(ctx, layout);
-    formats = NULL;
-    avfilter_add_format(&formats, AVFILTER_PACKED);
-    avfilter_set_common_packing_formats(ctx, formats);
     ff_set_common_samplerates(ctx, avfilter_make_format_list(sample_rates));
 
     return 0;
diff --git a/libavfilter/af_pan.c b/libavfilter/af_pan.c
index 3100a14..49f8677 100644
--- a/libavfilter/af_pan.c
+++ b/libavfilter/af_pan.c
@@ -218,7 +218,6 @@ static int query_formats(AVFilterContext *ctx)
     pan->pure_gains = are_gains_pure(pan);
     /* libswr supports any sample and packing formats */
     avfilter_set_common_sample_formats(ctx, avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO));
-    avfilter_set_common_packing_formats(ctx, avfilter_make_all_packing_formats());
 
     // inlink supports any channel layout
     layouts = ff_all_channel_layouts();
@@ -348,7 +347,6 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)
     swr_convert(pan->swr, outsamples->data, n, (void *)insamples->data, n);
     avfilter_copy_buffer_ref_props(outsamples, insamples);
     outsamples->audio->channel_layout = outlink->channel_layout;
-    outsamples->audio->planar         = outlink->planar;
 
     ff_filter_samples(outlink, outsamples);
     avfilter_unref_buffer(insamples);
diff --git a/libavfilter/af_silencedetect.c b/libavfilter/af_silencedetect.c
index 4f5d8e0..76001ce 100644
--- a/libavfilter/af_silencedetect.c
+++ b/libavfilter/af_silencedetect.c
@@ -136,7 +136,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_SAMPLE_FMT_DBL,
         AV_SAMPLE_FMT_NONE
     };
-    int packing_fmts[] = { AVFILTER_PACKED, -1 };
 
     layouts = ff_all_channel_layouts();
     if (!layouts)
@@ -148,11 +147,6 @@ static int query_formats(AVFilterContext *ctx)
         return AVERROR(ENOMEM);
     avfilter_set_common_sample_formats(ctx, formats);
 
-    formats = avfilter_make_format_list(packing_fmts);
-    if (!formats)
-        return AVERROR(ENOMEM);
-    avfilter_set_common_packing_formats(ctx, formats);
-
     formats = ff_all_samplerates();
     if (!formats)
         return AVERROR(ENOMEM);
diff --git a/libavfilter/af_volume.c b/libavfilter/af_volume.c
index 50f3cbd..7c51884 100644
--- a/libavfilter/af_volume.c
+++ b/libavfilter/af_volume.c
@@ -91,7 +91,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_SAMPLE_FMT_DBL,
         AV_SAMPLE_FMT_NONE
     };
-    int packing_fmts[] = { AVFILTER_PACKED, -1 };
 
     layouts = ff_all_channel_layouts();
     if (!layouts)
@@ -103,11 +102,6 @@ static int query_formats(AVFilterContext *ctx)
         return AVERROR(ENOMEM);
     avfilter_set_common_sample_formats(ctx, formats);
 
-    formats = avfilter_make_format_list(packing_fmts);
-    if (!formats)
-        return AVERROR(ENOMEM);
-    avfilter_set_common_packing_formats(ctx, formats);
-
     formats = ff_all_samplerates();
     if (!formats)
         return AVERROR(ENOMEM);
diff --git a/libavfilter/asrc_aevalsrc.c b/libavfilter/asrc_aevalsrc.c
index 94197b2..2078d7f 100644
--- a/libavfilter/asrc_aevalsrc.c
+++ b/libavfilter/asrc_aevalsrc.c
@@ -187,11 +187,9 @@ static int query_formats(AVFilterContext *ctx)
     EvalContext *eval = ctx->priv;
     enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE };
     int64_t chlayouts[] = { eval->chlayout, -1 };
-    int packing_fmts[] = { AVFILTER_PLANAR, -1 };
 
     avfilter_set_common_sample_formats (ctx, avfilter_make_format_list(sample_fmts));
     ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
-    avfilter_set_common_packing_formats(ctx, avfilter_make_format_list(packing_fmts));
 
     return 0;
 }
diff --git a/libavfilter/audio.c b/libavfilter/audio.c
index a3ab0f6..f8b11fc 100644
--- a/libavfilter/audio.c
+++ b/libavfilter/audio.c
@@ -100,9 +100,9 @@ AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
 
     samplesref->audio->nb_samples     = nb_samples;
     samplesref->audio->channel_layout = channel_layout;
-    samplesref->audio->planar         = av_sample_fmt_is_planar(sample_fmt);
 
-    planes = samplesref->audio->planar ? av_get_channel_layout_nb_channels(channel_layout) : 1;
+    planes = av_sample_fmt_is_planar(sample_fmt) ?
+        av_get_channel_layout_nb_channels(channel_layout) : 1;
 
     /* make sure the buffer gets read permission or it's useless for output */
     samplesref->perms = perms | AV_PERM_READ;
diff --git a/libavfilter/audio.h b/libavfilter/audio.h
index 051efb2..b63f85f 100644
--- a/libavfilter/audio.h
+++ b/libavfilter/audio.h
@@ -24,6 +24,23 @@
 
 #include "avfilter.h"
 
+static const enum AVSampleFormat ff_packed_sample_fmts[] = {
+    AV_SAMPLE_FMT_U8,
+    AV_SAMPLE_FMT_S16,
+    AV_SAMPLE_FMT_S32,
+    AV_SAMPLE_FMT_FLT,
+    AV_SAMPLE_FMT_DBL,
+    AV_SAMPLE_FMT_NONE
+};
+
+static const enum AVSampleFormat ff_planar_sample_fmts[] = {
+    AV_SAMPLE_FMT_U8P,
+    AV_SAMPLE_FMT_S16P,
+    AV_SAMPLE_FMT_S32P,
+    AV_SAMPLE_FMT_FLTP,
+    AV_SAMPLE_FMT_DBLP,
+    AV_SAMPLE_FMT_NONE
+};
 
 /** default handler for get_audio_buffer() for audio inputs */
 AVFilterBufferRef *ff_default_get_audio_buffer(AVFilterLink *link, int perms,
diff --git a/libavfilter/avfilter.c b/libavfilter/avfilter.c
index 9704dc0..c6a8594 100644
--- a/libavfilter/avfilter.c
+++ b/libavfilter/avfilter.c
@@ -148,9 +148,6 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
     if (link->out_channel_layouts)
         ff_channel_layouts_changeref(&link->out_channel_layouts,
                                      &filt->outputs[filt_dstpad_idx]->out_channel_layouts);
-    if (link->out_packing)
-        avfilter_formats_changeref(&link->out_packing,
-                                   &filt->outputs[filt_dstpad_idx]->out_packing);
     if (link->out_samplerates)
         avfilter_formats_changeref(&link->out_samplerates,
                                    &filt->outputs[filt_dstpad_idx]->out_samplerates);
diff --git a/libavfilter/avfilter.h b/libavfilter/avfilter.h
index c76c637..124f3e6 100644
--- a/libavfilter/avfilter.h
+++ b/libavfilter/avfilter.h
@@ -121,7 +121,9 @@ typedef struct AVFilterBufferRefAudioProps {
     uint64_t channel_layout;    ///< channel layout of audio buffer
     int nb_samples;             ///< number of audio samples per channel
     int sample_rate;            ///< audio buffer sample rate
+#if FF_API_PACKING
     int planar;                 ///< audio buffer - planar or packed
+#endif
 } AVFilterBufferRefAudioProps;
 
 /**
@@ -303,10 +305,12 @@ AVFilterFormats *avfilter_make_all_formats(enum AVMediaType type);
  */
 extern const int64_t avfilter_all_channel_layouts[];
 
+#if FF_API_PACKING
 /**
  * Return a list of all audio packing formats.
  */
 AVFilterFormats *avfilter_make_all_packing_formats(void);
+#endif
 
 /**
  * Return a format list which contains the intersection of the formats of
@@ -519,7 +523,9 @@ void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
 void avfilter_set_common_pixel_formats(AVFilterContext *ctx, AVFilterFormats *formats);
 void avfilter_set_common_sample_formats(AVFilterContext *ctx, AVFilterFormats *formats);
 void avfilter_set_common_channel_layouts(AVFilterContext *ctx, AVFilterFormats *formats);
+#if FF_API_PACKING
 void avfilter_set_common_packing_formats(AVFilterContext *ctx, AVFilterFormats *formats);
+#endif
 
 /** Default handler for query_formats() */
 int avfilter_default_query_formats(AVFilterContext *ctx);
@@ -616,10 +622,12 @@ struct AVFilterContext {
     struct AVFilterCommand *command_queue;
 };
 
+#if FF_API_PACKING
 enum AVFilterPacking {
     AVFILTER_PACKED = 0,
     AVFILTER_PLANAR,
 };
+#endif
 
 /**
  * A link between two filters. This contains pointers to the source and
@@ -655,7 +663,9 @@ struct AVFilterLink {
 #else
     int sample_rate;            ///< samples per second
 #endif
+#if FF_API_PACKING
     int planar;                 ///< agreed upon packing mode of audio buffers. true if planar.
+#endif
 
     int format;                 ///< agreed upon media format
 
@@ -669,8 +679,10 @@ struct AVFilterLink {
     AVFilterFormats *in_formats;
     AVFilterFormats *out_formats;
 
+#if FF_API_PACKING
     AVFilterFormats *in_packing;
     AVFilterFormats *out_packing;
+#endif
 
     /**
      * The buffer reference currently being sent across the link by the source
diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index 987b024..2286781 100644
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -200,14 +200,12 @@ static int insert_conv_filter(AVFilterGraph *graph, AVFilterLink *link,
 
     if (link->type == AVMEDIA_TYPE_AUDIO &&
          (((link = filt_ctx-> inputs[0]) &&
-           (!ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts) ||
-            !avfilter_merge_formats(link->in_packing,   link->out_packing))) ||
+           !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)) ||
          ((link = filt_ctx->outputs[0]) &&
-           (!ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts) ||
-            !avfilter_merge_formats(link->in_packing,   link->out_packing))))
+           !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)))
        ) {
         av_log(NULL, AV_LOG_ERROR,
-               "Impossible to convert between the channel layouts/packing formats supported by the filter "
+               "Impossible to convert between the channel layouts formats supported by the filter "
                "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
         return AVERROR(EINVAL);
     }
@@ -219,7 +217,7 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
 {
     int i, j, ret;
     char filt_args[128];
-    AVFilterFormats *formats, *packing;
+    AVFilterFormats *formats;
     AVFilterChannelLayouts *chlayouts;
     AVFilterFormats *samplerates;
     int scaler_count = 0, resampler_count = 0;
@@ -254,8 +252,7 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
                     return ret;
             }
             else if (link->type == AVMEDIA_TYPE_AUDIO) {
-                if (!link->in_channel_layouts || !link->out_channel_layouts ||
-                    !link->in_packing   || !link->out_packing)
+                if (!link->in_channel_layouts || !link->out_channel_layouts)
                     return AVERROR(EINVAL);
 
                 /* Merge all three list before checking: that way, in all
@@ -264,9 +261,8 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
                 formats   = avfilter_merge_formats(link->in_formats,   link->out_formats);
                 chlayouts   = ff_merge_channel_layouts(link->in_channel_layouts  , link->out_channel_layouts);
                 samplerates = ff_merge_samplerates    (link->in_samplerates, link->out_samplerates);
-                packing   = avfilter_merge_formats(link->in_packing,   link->out_packing);
 
-                if (!formats || !chlayouts || !packing || !samplerates)
+                if (!formats || !chlayouts || !samplerates)
                     if (ret = insert_conv_filter(graph, link, "aconvert", NULL))
                        return ret;
 #else
diff --git a/libavfilter/buffersink.h b/libavfilter/buffersink.h
index 2ee5294..714fa04 100644
--- a/libavfilter/buffersink.h
+++ b/libavfilter/buffersink.h
@@ -46,7 +46,9 @@ AVBufferSinkParams *av_buffersink_params_alloc(void);
 typedef struct {
     const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
     const int64_t *channel_layouts;         ///< list of allowed channel layouts, terminated by -1
+#if FF_API_PACKING
     const int *packing_fmts;                ///< list of allowed packing formats
+#endif
 } AVABufferSinkParams;
 
 /**
diff --git a/libavfilter/defaults.c b/libavfilter/defaults.c
index 31dc18d..c25c037 100644
--- a/libavfilter/defaults.c
+++ b/libavfilter/defaults.c
@@ -70,9 +70,11 @@ void avfilter_set_common_channel_layouts(AVFilterContext *ctx, AVFilterFormats *
                        offsetof(AVFilterLink, out_channel_layouts));
 }
 
+#if FF_API_PACKING
 void avfilter_set_common_packing_formats(AVFilterContext *ctx, AVFilterFormats *formats)
 {
     set_common_formats(ctx, formats, AVMEDIA_TYPE_AUDIO,
                        offsetof(AVFilterLink, in_packing),
                        offsetof(AVFilterLink, out_packing));
 }
+#endif
diff --git a/libavfilter/formats.c b/libavfilter/formats.c
index 41c6da9..3534d64 100644
--- a/libavfilter/formats.c
+++ b/libavfilter/formats.c
@@ -289,6 +289,7 @@ const int64_t avfilter_all_channel_layouts[] = {
 //     return avfilter_make_format64_list(avfilter_all_channel_layouts);
 // }
 
+#if FF_API_PACKING
 AVFilterFormats *avfilter_make_all_packing_formats(void)
 {
     static const int packing[] = {
@@ -299,6 +300,7 @@ AVFilterFormats *avfilter_make_all_packing_formats(void)
 
     return avfilter_make_format_list(packing);
 }
+#endif
 
 AVFilterFormats *ff_all_samplerates(void)
 {
@@ -518,23 +520,6 @@ int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx)
     return 0;
 }
 
-int ff_parse_packing_format(int *ret, const char *arg, void *log_ctx)
-{
-    char *tail;
-    int planar = strtol(arg, &tail, 10);
-    if (*tail) {
-        planar = !strcmp(arg, "packed") ? 0:
-                 !strcmp(arg, "planar") ? 1: -1;
-    }
-
-    if (planar != 0 && planar != 1) {
-        av_log(log_ctx, AV_LOG_ERROR, "Invalid packing format '%s'\n", arg);
-        return AVERROR(EINVAL);
-    }
-    *ret = planar;
-    return 0;
-}
-
 #ifdef TEST
 
 #undef printf
diff --git a/libavfilter/graphdump.c b/libavfilter/graphdump.c
index bd2b278..28be29d 100644
--- a/libavfilter/graphdump.c
+++ b/libavfilter/graphdump.c
@@ -46,9 +46,8 @@ static int print_link_prop(AVBPrint *buf, AVFilterLink *link)
             av_get_channel_layout_string(layout, sizeof(layout),
                                          -1, link->channel_layout);
             format = av_x_if_null(av_get_sample_fmt_name(link->format), "?");
-            av_bprintf(buf, "[%dHz %s:%s:%s]",
-                    (int)link->sample_rate, format, layout,
-                    link->planar ? "planar" : "packed");
+            av_bprintf(buf, "[%dHz %s:%s]",
+                       (int)link->sample_rate, format, layout);
             break;
 
         default:
diff --git a/libavfilter/internal.h b/libavfilter/internal.h
index 034a6c9..f06151f 100644
--- a/libavfilter/internal.h
+++ b/libavfilter/internal.h
@@ -132,16 +132,6 @@ int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx);
 int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx);
 
 /**
- * Parse a packing format or a corresponding integer representation.
- *
- * @param ret integer pointer to where the value should be written
- * @param arg string to parse
- * @param log_ctx log context
- * @return 0 in case of success, a negative AVERROR code on error
- */
-int ff_parse_packing_format(int *ret, const char *arg, void *log_ctx);
-
-/**
  * Pass video frame along and keep an internal reference for later use.
  */
 static inline void ff_null_start_frame_keep_ref(AVFilterLink *inlink,
diff --git a/libavfilter/sink_buffer.c b/libavfilter/sink_buffer.c
index ab7aa4f..3eb66ca 100644
--- a/libavfilter/sink_buffer.c
+++ b/libavfilter/sink_buffer.c
@@ -42,7 +42,6 @@ AVBufferSinkParams *av_buffersink_params_alloc(void)
 AVABufferSinkParams *av_abuffersink_params_alloc(void)
 {
     static const int sample_fmts[] = { -1 };
-    static const int packing_fmts[] = { -1 };
     static const int64_t channel_layouts[] = { -1 };
     AVABufferSinkParams *params = av_malloc(sizeof(AVABufferSinkParams));
 
@@ -51,7 +50,6 @@ AVABufferSinkParams *av_abuffersink_params_alloc(void)
 
     params->sample_fmts = sample_fmts;
     params->channel_layouts = channel_layouts;
-    params->packing_fmts = packing_fmts;
     return params;
 }
 
@@ -64,7 +62,6 @@ typedef struct {
     /* only used for audio */
     enum AVSampleFormat *sample_fmts;       ///< list of accepted sample formats, terminated by AV_SAMPLE_FMT_NONE
     int64_t *channel_layouts;               ///< list of accepted channel layouts, terminated by -1
-    int *packing_fmts;                      ///< list of accepted packing formats, terminated by -1
 } BufferSinkContext;
 
 #define FIFO_INIT_SIZE 8
@@ -244,11 +241,9 @@ static av_cold int asink_init(AVFilterContext *ctx, const char *args, void *opaq
 
     buf->sample_fmts     = ff_copy_int_list  (params->sample_fmts);
     buf->channel_layouts = ff_copy_int64_list(params->channel_layouts);
-    buf->packing_fmts    = ff_copy_int_list  (params->packing_fmts);
-    if (!buf->sample_fmts || !buf->channel_layouts || !buf->sample_fmts) {
+    if (!buf->sample_fmts || !buf->channel_layouts) {
         av_freep(&buf->sample_fmts);
         av_freep(&buf->channel_layouts);
-        av_freep(&buf->packing_fmts);
         return AVERROR(ENOMEM);
     }
 
@@ -261,7 +256,6 @@ static av_cold void asink_uninit(AVFilterContext *ctx)
 
     av_freep(&buf->sample_fmts);
     av_freep(&buf->channel_layouts);
-    av_freep(&buf->packing_fmts);
     return common_uninit(ctx);
 }
 
@@ -278,11 +272,6 @@ static int asink_query_formats(AVFilterContext *ctx)
     if (!(layouts = avfilter_make_format64_list(buf->channel_layouts)))
         return AVERROR(ENOMEM);
     ff_set_common_channel_layouts(ctx, layouts);
-
-    if (!(formats = avfilter_make_format_list(buf->packing_fmts)))
-        return AVERROR(ENOMEM);
-    avfilter_set_common_packing_formats(ctx, formats);
-
     ff_set_common_samplerates          (ctx, ff_all_samplerates());
 
     return 0;
diff --git a/libavfilter/src_buffer.c b/libavfilter/src_buffer.c
index cadc4ee..6402b44 100644
--- a/libavfilter/src_buffer.c
+++ b/libavfilter/src_buffer.c
@@ -55,7 +55,6 @@ typedef struct {
     int sample_rate;
     unsigned int sample_format;
     int64_t channel_layout;
-    int packing_format;
 
     // Normalization filters
     AVFilterContext *aconvert;
@@ -91,7 +90,6 @@ static int reconfigure_filter(BufferSourceContext *abuffer, AVFilterContext *fil
 
     inlink->format         = abuffer->sample_format;
     inlink->channel_layout = abuffer->channel_layout;
-    inlink->planar         = abuffer->packing_format;
     inlink->sample_rate    = abuffer->sample_rate;
 
     filt_ctx->filter->uninit(filt_ctx);
@@ -239,14 +237,12 @@ static int check_format_change_audio(AVFilterContext *ctx,
 
     link = ctx->outputs[0];
     if (samplesref->format                != link->format         ||
-        samplesref->audio->channel_layout != link->channel_layout ||
-        samplesref->audio->planar         != link->planar) {
+        samplesref->audio->channel_layout != link->channel_layout) {
 
         if (!logged) log_input_change(ctx, link, samplesref);
 
         abuffer->sample_format  = samplesref->format;
         abuffer->channel_layout = samplesref->audio->channel_layout;
-        abuffer->packing_format = samplesref->audio->planar;
 
         if (!abuffer->aconvert) {
             ret = insert_filter(abuffer, link, &abuffer->aconvert, "aconvert");
@@ -254,9 +250,7 @@ static int check_format_change_audio(AVFilterContext *ctx,
         } else {
             link = abuffer->aconvert->outputs[0];
             if (samplesref->format                == link->format         &&
-                samplesref->audio->channel_layout == link->channel_layout &&
-                samplesref->audio->planar         == link->planar
-               )
+                samplesref->audio->channel_layout == link->channel_layout)
                 remove_filter(&abuffer->aconvert);
             else
                 if ((ret = reconfigure_filter(abuffer, abuffer->aconvert)) < 0)
@@ -456,7 +450,6 @@ static av_cold int init_audio(AVFilterContext *ctx, const char *args0, void *opa
     ADD_FORMAT(sample_rate);
     ADD_FORMAT(sample_format);
     ADD_FORMAT(channel_layout);
-    ADD_FORMAT(packing_format);
 
     abuffer->fifo = av_fifo_alloc(FIFO_SIZE*sizeof(AVFilterBufferRef*));
     if (!abuffer->fifo) {
@@ -475,7 +468,7 @@ static av_cold int init_audio(AVFilterContext *ctx, const char *args0, void *opa
 
 arg_fail:
     av_log(ctx, AV_LOG_ERROR, "Invalid arguments, must be of the form "
-                              "sample_rate:sample_fmt:channel_layout:packing\n");
+                              "sample_rate:sample_fmt:channel_layout\n");
     av_freep(&args);
     return AVERROR(EINVAL);
 }
@@ -517,10 +510,6 @@ static int query_formats_audio(AVFilterContext *ctx)
     ff_add_channel_layout(&layouts, abuffer->channel_layout);
     ff_set_common_channel_layouts(ctx, layouts);
 
-    formats = NULL;
-    avfilter_add_format(&formats, abuffer->packing_format);
-    avfilter_set_common_packing_formats(ctx, formats);
-
     return 0;
 }
 
diff --git a/libavfilter/src_movie.c b/libavfilter/src_movie.c
index 3062455..21e4e3f 100644
--- a/libavfilter/src_movie.c
+++ b/libavfilter/src_movie.c
@@ -370,13 +370,11 @@ static int amovie_query_formats(AVFilterContext *ctx)
     AVCodecContext *c = movie->codec_ctx;
 
     enum AVSampleFormat sample_fmts[] = { c->sample_fmt, -1 };
-    int packing_fmts[] = { AVFILTER_PACKED, -1 };
     int sample_rates[] = { c->sample_rate, -1 };
     int64_t chlayouts[] = { c->channel_layout ? c->channel_layout :
                             av_get_default_channel_layout(c->channels), -1 };
 
     avfilter_set_common_sample_formats (ctx, avfilter_make_format_list(sample_fmts));
-    avfilter_set_common_packing_formats(ctx, avfilter_make_format_list(packing_fmts));
     ff_set_common_samplerates          (ctx, avfilter_make_format_list(sample_rates));
     ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
 
diff --git a/libavfilter/version.h b/libavfilter/version.h
index a8e4f89..a47cda2 100644
--- a/libavfilter/version.h
+++ b/libavfilter/version.h
@@ -53,5 +53,8 @@
 #ifndef FF_API_VSRC_BUFFER_ADD_FRAME
 #define FF_API_VSRC_BUFFER_ADD_FRAME        (LIBAVFILTER_VERSION_MAJOR < 3)
 #endif
+#ifndef FF_API_PACKING
+#define FF_API_PACKING                  (LIBAVFILTER_VERSION_MAJOR < 3)
+#endif
 
 #endif // AVFILTER_VERSION_H