sigrid/ffmpeg

doc/examples/filtering_audio.c+1−3

     AVFilterInOut *outputs = avfilter_inout_alloc();
     AVFilterInOut *inputs  = avfilter_inout_alloc();
     const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
-    const int packing_fmts[]                = { AVFILTER_PACKED, -1 };
     const int64_t *chlayouts                = avfilter_all_channel_layouts;
     AVABufferSinkParams *abuffersink_params;
     const AVFilterLink *outlink;
     /* buffer audio source: the decoded frames from the decoder will be inserted here. */
     if (!dec_ctx->channel_layout)
         dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
-    snprintf(args, sizeof(args), "%d:%d:0x%"PRIx64":packed",
+    snprintf(args, sizeof(args), "%d:%d:0x%"PRIx64,
              dec_ctx->sample_rate, dec_ctx->sample_fmt, dec_ctx->channel_layout);
     ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in",
                                        args, NULL, filter_graph);
     abuffersink_params = av_abuffersink_params_alloc();
     abuffersink_params->sample_fmts     = sample_fmts;
     abuffersink_params->channel_layouts = chlayouts;
-    abuffersink_params->packing_fmts    = packing_fmts;
     ret = avfilter_graph_create_filter(&buffersink_ctx, abuffersink, "out",
                                        NULL, abuffersink_params, filter_graph);
     av_free(abuffersink_params);

doc/filter_design.txt+2−1

@@ -15,7 +15,8 @@ Format negotiation · 14 unmodified lines
15	the list supported formats.	15	the list supported formats.
16		16
17	For video links, that means pixel format. For audio links, that means	17	For video links, that means pixel format. For audio links, that means
18	channel layout, sample format and sample packing.	18	channel layout, and sample format (the sample packing is implied by the
		19	sample format).
19		20
20	The lists are not just lists, they are references to shared objects. When	21	The lists are not just lists, they are references to shared objects. When
21	the negotiation mechanism computes the intersection of the formats	22	the negotiation mechanism computes the intersection of the formats

doc/filters.texi+9−16

@@ -146,7 +146,7 @@ Convert the input audio to one of the specified formats. The framework will · 145 unmodified lines
146	negotiate the most appropriate format to minimize conversions.	146	negotiate the most appropriate format to minimize conversions.
147		147
148	The filter accepts three lists of formats, separated by ":", in the form:	148	The filter accepts three lists of formats, separated by ":", in the form:
149	"@var{sample_formats}:@var{channel_layouts}:@var{packing_formats}".	149	"@var{sample_formats}:@var{channel_layouts}".
150		150
151	Elements in each list are separated by "," which has to be escaped in the	151	Elements in each list are separated by "," which has to be escaped in the
152	filtergraph specification.	152	filtergraph specification.
@@ -156,9 +156,9 @@ supported formats. · 3 unmodified lines
156		156
157	Some examples follow:	157	Some examples follow:
158	@example	158	@example
159	aformat=u8\\,s16:mono:packed	159	aformat=u8\\,s16:mono
160		160
161	aformat=s16:mono\\,stereo:all	161	aformat=s16:mono\\,stereo
162	@end example	162	@end example
163		163
164	@section amerge	164	@section amerge
@@ -184,7 +184,7 @@ On the other hand, if both input are in stereo, the output channels will be · 19 unmodified lines
184	in the default order: a1, a2, b1, b2, and the channel layout will be	184	in the default order: a1, a2, b1, b2, and the channel layout will be
185	arbitrarily set to 4.0, which may or may not be the expected value.	185	arbitrarily set to 4.0, which may or may not be the expected value.
186		186
187	Both inputs must have the same sample rate, format and packing.	187	Both inputs must have the same sample rate, and format.
188		188
189	If inputs do not have the same duration, the output will stop with the	189	If inputs do not have the same duration, the output will stop with the
190	shortest.	190	shortest.
@@ -293,9 +293,6 @@ number of samples (per each channel) contained in the filtered frame · 102 unmodified lines
293	@item rate	293	@item rate
294	sample rate for the audio frame	294	sample rate for the audio frame
295		295
296	@item planar
297	if the packing format is planar, 0 if packed
298
299	@item checksum	296	@item checksum
300	Adler-32 checksum (printed in hexadecimal) of all the planes of the input frame	297	Adler-32 checksum (printed in hexadecimal) of all the planes of the input frame
301		298
@@ -566,7 +563,7 @@ This source is mainly intended for a programmatic use, in particular · 264 unmodified lines
566	through the interface defined in @file{libavfilter/asrc_abuffer.h}.	563	through the interface defined in @file{libavfilter/asrc_abuffer.h}.
567		564
568	It accepts the following mandatory parameters:	565	It accepts the following mandatory parameters:
569	@var{sample_rate}:@var{sample_fmt}:@var{channel_layout}:@var{packing}	566	@var{sample_rate}:@var{sample_fmt}:@var{channel_layout}
570		567
571	@table @option	568	@table @option
572		569
@@ -584,23 +581,19 @@ Either a channel layout name from channel_layout_map in · 11 unmodified lines
584	@file{libavutil/audioconvert.c} or its corresponding integer representation	581	@file{libavutil/audioconvert.c} or its corresponding integer representation
585	from the AV_CH_LAYOUT_* macros in @file{libavutil/audioconvert.h}	582	from the AV_CH_LAYOUT_* macros in @file{libavutil/audioconvert.h}
586		583
587	@item packing
588	Either "packed" or "planar", or their integer representation: 0 or 1
589	respectively.
590
591	@end table	584	@end table
592		585
593	For example:	586	For example:
594	@example	587	@example
595	abuffer=44100:s16:stereo:planar	588	abuffer=44100:s16p:stereo
596	@end example	589	@end example
597		590
598	will instruct the source to accept planar 16bit signed stereo at 44100Hz.	591	will instruct the source to accept planar 16bit signed stereo at 44100Hz.
599	Since the sample format with name "s16" corresponds to the number	592	Since the sample format with name "s16p" corresponds to the number
600	1 and the "stereo" channel layout corresponds to the value 0x3, this is	593	6 and the "stereo" channel layout corresponds to the value 0x3, this is
601	equivalent to:	594	equivalent to:
602	@example	595	@example
603	abuffer=44100:1:0x3:1	596	abuffer=44100:6:0x3
604	@end example	597	@end example
605		598
606	@section aevalsrc	599	@section aevalsrc

libavdevice/lavfi.c+0−2

                                                   AV_SAMPLE_FMT_S32,
                                                   AV_SAMPLE_FMT_FLT,
                                                   AV_SAMPLE_FMT_DBL, -1 };
-            const int packing_fmts[] = { AVFILTER_PACKED, -1 };
             const int64_t *chlayouts = avfilter_all_channel_layouts;
             AVABufferSinkParams *abuffersink_params = av_abuffersink_params_alloc();
             abuffersink_params->sample_fmts = sample_fmts;
-            abuffersink_params->packing_fmts = packing_fmts;
             abuffersink_params->channel_layouts = chlayouts;
             ret = avfilter_graph_create_filter(&sink, abuffersink,

libavfilter/af_aconvert.c+4−12

     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),
         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;
 }
     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",
+           "fmt:%s cl:%s -> fmt:%s cl:%s\n",
-           av_get_sample_fmt_name(inlink ->format), buf1, inlink ->planar,
+           av_get_sample_fmt_name(inlink ->format), buf1,
-           av_get_sample_fmt_name(outlink->format), buf2, outlink->planar);
+           av_get_sample_fmt_name(outlink->format), buf2);
     return 0;
 }
     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);
 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,

libavfilter/af_amerge.c+1−5

 {
     AMergeContext *am = ctx->priv;
     int64_t inlayout[2], outlayout;
-    const int packing_fmts[] = { AVFILTER_PACKED, -1 };
     AVFilterFormats *formats;
     AVFilterChannelLayouts *layouts;
     int i;
                 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]);
     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;

libavfilter/af_ashowinfo.c+2−3

     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++) {
     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),
            chlayout_str,
            samplesref->audio->nb_samples,
            samplesref->audio->sample_rate,
-           samplesref->audio->planar,
            checksum,
            plane_checksum[0]);

libavfilter/af_astreamsync.c+0−3

         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);

libavfilter/af_earwax.c+0−3

     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;

libavfilter/af_pan.c+0−2

     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();
     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);

libavfilter/af_silencedetect.c+0−6

         AV_SAMPLE_FMT_DBL,
         AV_SAMPLE_FMT_NONE
     };
-    int packing_fmts[] = { AVFILTER_PACKED, -1 };
     layouts = ff_all_channel_layouts();
     if (!layouts)
         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);

libavfilter/af_volume.c+0−6

         AV_SAMPLE_FMT_DBL,
         AV_SAMPLE_FMT_NONE
     };
-    int packing_fmts[] = { AVFILTER_PACKED, -1 };
     layouts = ff_all_channel_layouts();
     if (!layouts)
         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);

libavfilter/asrc_aevalsrc.c+0−2

     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;
 }

libavfilter/audio.c+2−2

@@ -100,9 +100,9 @@ AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data, · 99 unmodified lines
100		100
101	samplesref->audio->nb_samples = nb_samples;	101	samplesref->audio->nb_samples = nb_samples;
102	samplesref->audio->channel_layout = channel_layout;	102	samplesref->audio->channel_layout = channel_layout;
103	samplesref->audio->planar = av_sample_fmt_is_planar(sample_fmt);
104		103
105	planes = samplesref->audio->planar ? av_get_channel_layout_nb_channels(channel_layout) : 1;	104	planes = av_sample_fmt_is_planar(sample_fmt) ?
		105	av_get_channel_layout_nb_channels(channel_layout) : 1;
106		106
107	/* make sure the buffer gets read permission or it's useless for output */	107	/* make sure the buffer gets read permission or it's useless for output */
108	samplesref->perms = perms \| AV_PERM_READ;	108	samplesref->perms = perms \| AV_PERM_READ;

libavfilter/audio.h+17−0

@@ -24,6 +24,23 @@ · 23 unmodified lines
24		24
25	#include "avfilter.h"	25	#include "avfilter.h"
26		26
		27	static const enum AVSampleFormat ff_packed_sample_fmts[] = {
		28	AV_SAMPLE_FMT_U8,
		29	AV_SAMPLE_FMT_S16,
		30	AV_SAMPLE_FMT_S32,
		31	AV_SAMPLE_FMT_FLT,
		32	AV_SAMPLE_FMT_DBL,
		33	AV_SAMPLE_FMT_NONE
		34	};
		35
		36	static const enum AVSampleFormat ff_planar_sample_fmts[] = {
		37	AV_SAMPLE_FMT_U8P,
		38	AV_SAMPLE_FMT_S16P,
		39	AV_SAMPLE_FMT_S32P,
		40	AV_SAMPLE_FMT_FLTP,
		41	AV_SAMPLE_FMT_DBLP,
		42	AV_SAMPLE_FMT_NONE
		43	};
27		44
28	/** default handler for get_audio_buffer() for audio inputs */	45	/** default handler for get_audio_buffer() for audio inputs */
29	AVFilterBufferRef ff_default_get_audio_buffer(AVFilterLink link, int perms,	46	AVFilterBufferRef ff_default_get_audio_buffer(AVFilterLink link, int perms,

libavfilter/avfilter.c+0−3

     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);

libavfilter/avfilter.h+12−0

     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;
 /**
  */
 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
 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);
     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
 #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
     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

libavfilter/avfiltergraph.c+6−10

     if (link->type == AVMEDIA_TYPE_AUDIO &&
          (((link = filt_ctx-> inputs[0]) &&
-           (!ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts) ||
+           !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)) ||
-            !avfilter_merge_formats(link->in_packing,   link->out_packing))) ||
          ((link = filt_ctx->outputs[0]) &&
-           (!ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts) ||
+           !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)))
-            !avfilter_merge_formats(link->in_packing,   link->out_packing))))
        ) {
         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);
     }
 {
     int i, j, ret;
     char filt_args[128];
-    AVFilterFormats *formats, *packing;
+    AVFilterFormats *formats;
     AVFilterChannelLayouts *chlayouts;
     AVFilterFormats *samplerates;
     int scaler_count = 0, resampler_count = 0;
                     return ret;
             }
             else if (link->type == AVMEDIA_TYPE_AUDIO) {
-                if (!link->in_channel_layouts || !link->out_channel_layouts ||
+                if (!link->in_channel_layouts || !link->out_channel_layouts)
-                    !link->in_packing   || !link->out_packing)
                     return AVERROR(EINVAL);
                 /* Merge all three list before checking: that way, in all
                 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

libavfilter/buffersink.h+2−0

 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;
 /**

libavfilter/defaults.c+2−0

                        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

libavfilter/formats.c+2−17

 //     return avfilter_make_format64_list(avfilter_all_channel_layouts);
 // }
+#if FF_API_PACKING
 AVFilterFormats *avfilter_make_all_packing_formats(void)
 {
     static const int packing[] = {
     return avfilter_make_format_list(packing);
 }
+#endif
 AVFilterFormats *ff_all_samplerates(void)
 {
     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

libavfilter/graphdump.c+2−3

             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]",
+            av_bprintf(buf, "[%dHz %s:%s]",
-                    (int)link->sample_rate, format, layout,
+                       (int)link->sample_rate, format, layout);
-                    link->planar ? "planar" : "packed");
             break;
         default:

libavfilter/internal.h+0−10

@@ -131,16 +131,6 @@ int ff_parse_sample_format(int ret, const char arg, void *log_ctx); · 130 unmodified lines
131	*/	131	*/
132	int ff_parse_channel_layout(int64_t ret, const char arg, void *log_ctx);	132	int ff_parse_channel_layout(int64_t ret, const char arg, void *log_ctx);
133		133
134	/**
135	* Parse a packing format or a corresponding integer representation.
136	*
137	* @param ret integer pointer to where the value should be written
138	* @param arg string to parse
139	* @param log_ctx log context
140	* @return 0 in case of success, a negative AVERROR code on error
141	*/
142	int ff_parse_packing_format(int ret, const char arg, void *log_ctx);
143
144	/**	134	/**
145	* Pass video frame along and keep an internal reference for later use.	135	* Pass video frame along and keep an internal reference for later use.
146	*/	136	*/

libavfilter/sink_buffer.c+1−12

 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));
     params->sample_fmts = sample_fmts;
     params->channel_layouts = channel_layouts;
-    params->packing_fmts = packing_fmts;
     return params;
 }
     /* 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
     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) {
-    if (!buf->sample_fmts || !buf->channel_layouts || !buf->sample_fmts) {
         av_freep(&buf->sample_fmts);
         av_freep(&buf->channel_layouts);
-        av_freep(&buf->packing_fmts);
         return AVERROR(ENOMEM);
     }
     av_freep(&buf->sample_fmts);
     av_freep(&buf->channel_layouts);
-    av_freep(&buf->packing_fmts);
     return common_uninit(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;

libavfilter/src_buffer.c+3−14

     int sample_rate;
     unsigned int sample_format;
     int64_t channel_layout;
-    int packing_format;
     // Normalization filters
     AVFilterContext *aconvert;
     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);
     link = ctx->outputs[0];
     if (samplesref->format                != link->format         ||
-        samplesref->audio->channel_layout != link->channel_layout ||
+        samplesref->audio->channel_layout != link->channel_layout) {
-        samplesref->audio->planar         != link->planar) {
         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");
         } else {
             link = abuffer->aconvert->outputs[0];
             if (samplesref->format                == link->format         &&
-                samplesref->audio->channel_layout == link->channel_layout &&
+                samplesref->audio->channel_layout == link->channel_layout)
-                samplesref->audio->planar         == link->planar
-               )
                 remove_filter(&abuffer->aconvert);
             else
                 if ((ret = reconfigure_filter(abuffer, abuffer->aconvert)) < 0)
     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) {
 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);
 }
     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;
 }

libavfilter/src_movie.c+0−2

     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));

libavfilter/version.h+3−0

@@ -53,5 +53,8 @@ · 52 unmodified lines
53	#ifndef FF_API_VSRC_BUFFER_ADD_FRAME	53	#ifndef FF_API_VSRC_BUFFER_ADD_FRAME
54	#define FF_API_VSRC_BUFFER_ADD_FRAME (LIBAVFILTER_VERSION_MAJOR < 3)	54	#define FF_API_VSRC_BUFFER_ADD_FRAME (LIBAVFILTER_VERSION_MAJOR < 3)
55	#endif	55	#endif
		56	#ifndef FF_API_PACKING
		57	#define FF_API_PACKING (LIBAVFILTER_VERSION_MAJOR < 3)
		58	#endif
56		59
57	#endif // AVFILTER_VERSION_H	60	#endif // AVFILTER_VERSION_H

tools/lavfi-showfiltfmts.c+0−8

@@ -53,14 +53,6 @@ static void print_formats(AVFilterContext *filter_ctx) · 52 unmodified lines
53	fmts->formats[j]); \	53	fmts->formats[j]); \
54	printf(#INOUT "PUT[%d] %s: chlayout:%s\n", \	54	printf(#INOUT "PUT[%d] %s: chlayout:%s\n", \
55	i, filter_ctx->filter->inout##puts[i].name, buf); \	55	i, filter_ctx->filter->inout##puts[i].name, buf); \
56	} \
57	\
58	fmts = filter_ctx->inout##puts[i]->outin##_packing; \
59	for (j = 0; j < fmts->format_count; j++) { \
60	printf(#INOUT "PUT[%d] %s: packing:%s\n", \
61	i, filter_ctx->filter->inout##puts[i].name, \
62	fmts->formats[j] == AVFILTER_PACKED ? \
63	"packed" : "planar"); \
64	} \	56	} \
65	} \	57	} \
66	} \	58	} \

lavfi: drop planar/packed negotiation support

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code