FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/af_channelmap.c	Lines:	105	198	53.0 %
Date:	2021-04-14 23:45:22	Branches:	51	133	38.3 %


/*
 * Copyright (c) 2012 Google, Inc.
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * audio channel mapping filter
 */

#include <ctype.h>

#include "libavutil/avstring.h"
#include "libavutil/channel_layout.h"
#include "libavutil/common.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"

#include "audio.h"
#include "avfilter.h"
#include "formats.h"
#include "internal.h"

struct ChannelMap {
    uint64_t in_channel;
    uint64_t out_channel;
    int in_channel_idx;
    int out_channel_idx;
};

enum MappingMode {
    MAP_NONE,
    MAP_ONE_INT,
    MAP_ONE_STR,
    MAP_PAIR_INT_INT,
    MAP_PAIR_INT_STR,
    MAP_PAIR_STR_INT,
    MAP_PAIR_STR_STR
};

#define MAX_CH 64
typedef struct ChannelMapContext {
    const AVClass *class;
    char *mapping_str;
    char *channel_layout_str;
    uint64_t output_layout;
    struct ChannelMap map[MAX_CH];
    int nch;
    enum MappingMode mode;
} ChannelMapContext;

#define OFFSET(x) offsetof(ChannelMapContext, x)
#define A AV_OPT_FLAG_AUDIO_PARAM
#define F AV_OPT_FLAG_FILTERING_PARAM
static const AVOption channelmap_options[] = {
    { "map", "A comma-separated list of input channel numbers in output order.",
          OFFSET(mapping_str),        AV_OPT_TYPE_STRING, .flags = A|F },
    { "channel_layout", "Output channel layout.",
          OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A|F },
    { NULL }
};

AVFILTER_DEFINE_CLASS(channelmap);

static char* split(char *message, char delim) {
    char *next = strchr(message, delim);
    if (next)
      *next++ = '\0';
    return next;
}

static int get_channel_idx(char **map, int *ch, char delim, int max_ch)
{
    char *next;
    int len;
    int n = 0;
    if (!*map)
        return AVERROR(EINVAL);
    next = split(*map, delim);
    if (!next && delim == '-')
        return AVERROR(EINVAL);
    len = strlen(*map);
    sscanf(*map, "%d%n", ch, &n);
    if (n != len)
        return AVERROR(EINVAL);
    if (*ch < 0 || *ch > max_ch)
        return AVERROR(EINVAL);
    *map = next;
    return 0;
}

static int get_channel(char **map, uint64_t *ch, char delim)
{
    char *next = split(*map, delim);
    if (!next && delim == '-')
        return AVERROR(EINVAL);
    *ch = av_get_channel_layout(*map);
    if (av_get_channel_layout_nb_channels(*ch) != 1)
        return AVERROR(EINVAL);
    *map = next;
    return 0;
}

static av_cold int channelmap_init(AVFilterContext *ctx)
{
    ChannelMapContext *s = ctx->priv;
    char *mapping, separator = '|';
    int map_entries = 0;
    char buf[256];
    enum MappingMode mode;
    uint64_t out_ch_mask = 0;
    int i;

    mapping = s->mapping_str;

    if (!mapping) {
        mode = MAP_NONE;
    } else {
        char *dash = strchr(mapping, '-');
        if (!dash) {  // short mapping
            if (av_isdigit(*mapping))
                mode = MAP_ONE_INT;
            else
                mode = MAP_ONE_STR;
        } else if (av_isdigit(*mapping)) {
            if (av_isdigit(*(dash+1)))
                mode = MAP_PAIR_INT_INT;
            else
                mode = MAP_PAIR_INT_STR;
        } else {
            if (av_isdigit(*(dash+1)))
                mode = MAP_PAIR_STR_INT;
            else
                mode = MAP_PAIR_STR_STR;
        }
    }

    if (mode != MAP_NONE) {
        char *sep = mapping;
        map_entries = 1;
        while ((sep = strchr(sep, separator))) {
            if (*++sep)  // Allow trailing comma
                map_entries++;
        }
    }

    if (map_entries > MAX_CH) {
        av_log(ctx, AV_LOG_ERROR, "Too many channels mapped: '%d'.\n", map_entries);
        return AVERROR(EINVAL);
    }

    for (i = 0; i < map_entries; i++) {
        int in_ch_idx = -1, out_ch_idx = -1;
        uint64_t in_ch = 0, out_ch = 0;
        static const char err[] = "Failed to parse channel map\n";
        switch (mode) {
        case MAP_ONE_INT:
            if (get_channel_idx(&mapping, &in_ch_idx, separator, MAX_CH) < 0) {
                av_log(ctx, AV_LOG_ERROR, err);
                return AVERROR(EINVAL);
            }
            s->map[i].in_channel_idx  = in_ch_idx;
            s->map[i].out_channel_idx = i;
            break;
        case MAP_ONE_STR:
            if (get_channel(&mapping, &in_ch, separator) < 0) {
                av_log(ctx, AV_LOG_ERROR, err);
                return AVERROR(EINVAL);
            }
            s->map[i].in_channel      = in_ch;
            s->map[i].out_channel_idx = i;
            break;
        case MAP_PAIR_INT_INT:
            if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 ||
                get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {
                av_log(ctx, AV_LOG_ERROR, err);
                return AVERROR(EINVAL);
            }
            s->map[i].in_channel_idx  = in_ch_idx;
            s->map[i].out_channel_idx = out_ch_idx;
            break;
        case MAP_PAIR_INT_STR:
            if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 ||
                get_channel(&mapping, &out_ch, separator) < 0 ||
                out_ch & out_ch_mask) {
                av_log(ctx, AV_LOG_ERROR, err);
                return AVERROR(EINVAL);
            }
            s->map[i].in_channel_idx  = in_ch_idx;
            s->map[i].out_channel     = out_ch;
            out_ch_mask |= out_ch;
            break;
        case MAP_PAIR_STR_INT:
            if (get_channel(&mapping, &in_ch, '-') < 0 ||
                get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {
                av_log(ctx, AV_LOG_ERROR, err);
                return AVERROR(EINVAL);
            }
            s->map[i].in_channel      = in_ch;
            s->map[i].out_channel_idx = out_ch_idx;
            break;
        case MAP_PAIR_STR_STR:
            if (get_channel(&mapping, &in_ch, '-') < 0 ||
                get_channel(&mapping, &out_ch, separator) < 0 ||
                out_ch & out_ch_mask) {
                av_log(ctx, AV_LOG_ERROR, err);
                return AVERROR(EINVAL);
            }
            s->map[i].in_channel = in_ch;
            s->map[i].out_channel = out_ch;
            out_ch_mask |= out_ch;
            break;
        }
    }
    s->mode          = mode;
    s->nch           = map_entries;
    s->output_layout = out_ch_mask ? out_ch_mask :
                       av_get_default_channel_layout(map_entries);

    if (s->channel_layout_str) {
        uint64_t fmt;
        if ((fmt = av_get_channel_layout(s->channel_layout_str)) == 0) {
            av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout: '%s'.\n",
                   s->channel_layout_str);
            return AVERROR(EINVAL);
        }
        if (mode == MAP_NONE) {
            int i;
            s->nch = av_get_channel_layout_nb_channels(fmt);
            for (i = 0; i < s->nch; i++) {
                s->map[i].in_channel_idx  = i;
                s->map[i].out_channel_idx = i;
            }
        } else if (out_ch_mask && out_ch_mask != fmt) {
            av_get_channel_layout_string(buf, sizeof(buf), 0, out_ch_mask);
            av_log(ctx, AV_LOG_ERROR,
                   "Output channel layout '%s' does not match the list of channel mapped: '%s'.\n",
                   s->channel_layout_str, buf);
            return AVERROR(EINVAL);
        } else if (s->nch != av_get_channel_layout_nb_channels(fmt)) {
            av_log(ctx, AV_LOG_ERROR,
                   "Output channel layout %s does not match the number of channels mapped %d.\n",
                   s->channel_layout_str, s->nch);
            return AVERROR(EINVAL);
        }
        s->output_layout = fmt;
    }
    if (!s->output_layout) {
        av_log(ctx, AV_LOG_ERROR, "Output channel layout is not set and "
               "cannot be guessed from the maps.\n");
        return AVERROR(EINVAL);
    }

    if (mode == MAP_PAIR_INT_STR || mode == MAP_PAIR_STR_STR) {
        for (i = 0; i < s->nch; i++) {
            s->map[i].out_channel_idx = av_get_channel_layout_channel_index(
                s->output_layout, s->map[i].out_channel);
        }
    }

    return 0;
}

static int channelmap_query_formats(AVFilterContext *ctx)
{
    ChannelMapContext *s = ctx->priv;
    AVFilterChannelLayouts *channel_layouts = NULL;
    int ret;

    if ((ret = ff_set_common_formats    (ctx,  ff_planar_sample_fmts()))  < 0 ||
        (ret = ff_set_common_samplerates (ctx             , ff_all_samplerates()                )) < 0 ||
        (ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0 ||
        (ret = ff_channel_layouts_ref(channel_layouts,
                                      &ctx->outputs[0]->incfg.channel_layouts)) < 0)
        return ret;

    return ff_channel_layouts_ref(ff_all_channel_counts(),
                                  &ctx->inputs[0]->outcfg.channel_layouts);
}

static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)
{
    AVFilterContext  *ctx = inlink->dst;
    AVFilterLink *outlink = ctx->outputs[0];
    const ChannelMapContext *s = ctx->priv;
    const int nch_in = inlink->channels;
    const int nch_out = s->nch;
    int ch;
    uint8_t *source_planes[MAX_CH];

    memcpy(source_planes, buf->extended_data,
           nch_in * sizeof(source_planes[0]));

    if (nch_out > nch_in) {
        if (nch_out > FF_ARRAY_ELEMS(buf->data)) {
            uint8_t **new_extended_data =
                av_mallocz_array(nch_out, sizeof(*buf->extended_data));
            if (!new_extended_data) {
                av_frame_free(&buf);
                return AVERROR(ENOMEM);
            }
            if (buf->extended_data == buf->data) {
                buf->extended_data = new_extended_data;
            } else {
                av_free(buf->extended_data);
                buf->extended_data = new_extended_data;
            }
        } else if (buf->extended_data != buf->data) {
            av_free(buf->extended_data);
            buf->extended_data = buf->data;
        }
    }

    for (ch = 0; ch < nch_out; ch++) {
        buf->extended_data[s->map[ch].out_channel_idx] =
            source_planes[s->map[ch].in_channel_idx];
    }

    if (buf->data != buf->extended_data)
        memcpy(buf->data, buf->extended_data,
           FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));

    buf->channel_layout = outlink->channel_layout;
    buf->channels       = outlink->channels;

    return ff_filter_frame(outlink, buf);
}

static int channelmap_config_input(AVFilterLink *inlink)
{
    AVFilterContext *ctx = inlink->dst;
    ChannelMapContext *s = ctx->priv;
    int nb_channels = inlink->channels;
    int i, err = 0;
    const char *channel_name;
    char layout_name[256];

    for (i = 0; i < s->nch; i++) {
        struct ChannelMap *m = &s->map[i];

        if (s->mode == MAP_PAIR_STR_INT || s->mode == MAP_PAIR_STR_STR) {
            m->in_channel_idx = av_get_channel_layout_channel_index(
                inlink->channel_layout, m->in_channel);
        }

        if (m->in_channel_idx < 0 || m->in_channel_idx >= nb_channels) {
            av_get_channel_layout_string(layout_name, sizeof(layout_name),
                                         nb_channels, inlink->channel_layout);
            if (m->in_channel) {
                channel_name = av_get_channel_name(m->in_channel);
                av_log(ctx, AV_LOG_ERROR,
                       "input channel '%s' not available from input layout '%s'\n",
                       channel_name, layout_name);
            } else {
                av_log(ctx, AV_LOG_ERROR,
                       "input channel #%d not available from input layout '%s'\n",
                       m->in_channel_idx, layout_name);
            }
            err = AVERROR(EINVAL);
        }
    }

    return err;
}

static const AVFilterPad avfilter_af_channelmap_inputs[] = {
    {
        .name           = "default",
        .type           = AVMEDIA_TYPE_AUDIO,
        .filter_frame   = channelmap_filter_frame,
        .config_props   = channelmap_config_input,
        .needs_writable = 1,
    },
    { NULL }
};

static const AVFilterPad avfilter_af_channelmap_outputs[] = {
    {
        .name = "default",
        .type = AVMEDIA_TYPE_AUDIO
    },
    { NULL }
};

AVFilter ff_af_channelmap = {
    .name          = "channelmap",
    .description   = NULL_IF_CONFIG_SMALL("Remap audio channels."),
    .init          = channelmap_init,
    .query_formats = channelmap_query_formats,
    .priv_size     = sizeof(ChannelMapContext),
    .priv_class    = &channelmap_class,
    .inputs        = avfilter_af_channelmap_inputs,
    .outputs       = avfilter_af_channelmap_outputs,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2012 Google, Inc.
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			/**
22			* @file
23			* audio channel mapping filter
24			*/
25
26			#include <ctype.h>
27
28			#include "libavutil/avstring.h"
29			#include "libavutil/channel_layout.h"
30			#include "libavutil/common.h"
31			#include "libavutil/mathematics.h"
32			#include "libavutil/opt.h"
33			#include "libavutil/samplefmt.h"
34
35			#include "audio.h"
36			#include "avfilter.h"
37			#include "formats.h"
38			#include "internal.h"
39
40			struct ChannelMap {
41			uint64_t in_channel;
42			uint64_t out_channel;
43			int in_channel_idx;
44			int out_channel_idx;
45			};
46
47			enum MappingMode {
48			MAP_NONE,
49			MAP_ONE_INT,
50			MAP_ONE_STR,
51			MAP_PAIR_INT_INT,
52			MAP_PAIR_INT_STR,
53			MAP_PAIR_STR_INT,
54			MAP_PAIR_STR_STR
55			};
56
57			#define MAX_CH 64
58			typedef struct ChannelMapContext {
59			const AVClass *class;
60			char *mapping_str;
61			char *channel_layout_str;
62			uint64_t output_layout;
63			struct ChannelMap map[MAX_CH];
64			int nch;
65			enum MappingMode mode;
66			} ChannelMapContext;
67
68			#define OFFSET(x) offsetof(ChannelMapContext, x)
69			#define A AV_OPT_FLAG_AUDIO_PARAM
70			#define F AV_OPT_FLAG_FILTERING_PARAM
71			static const AVOption channelmap_options[] = {
72			{ "map", "A comma-separated list of input channel numbers in output order.",
73			OFFSET(mapping_str), AV_OPT_TYPE_STRING, .flags = A\|F },
74			{ "channel_layout", "Output channel layout.",
75			OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A\|F },
76			{ NULL }
77			};
78
79			AVFILTER_DEFINE_CLASS(channelmap);
80
81		16	static char* split(char *message, char delim) {
82		16	char *next = strchr(message, delim);
83	✓✓	16	if (next)
84		12	*next++ = '\0';
85		16	return next;
86			}
87
88		12	static int get_channel_idx(char *map, int ch, char delim, int max_ch)
89			{
90			char *next;
91			int len;
92		12	int n = 0;
93	✗✓	12	if (!*map)
94			return AVERROR(EINVAL);
95		12	next = split(*map, delim);
96	✓✓✗✓	12	if (!next && delim == '-')
97			return AVERROR(EINVAL);
98		12	len = strlen(*map);
99		12	sscanf(*map, "%d%n", ch, &n);
100	✗✓	12	if (n != len)
101			return AVERROR(EINVAL);
102	✓✗✗✓	12	if (ch < 0 \|\| ch > max_ch)
103			return AVERROR(EINVAL);
104		12	*map = next;
105		12	return 0;
106			}
107
108		4	static int get_channel(char *map, uint64_t ch, char delim)
109			{
110		4	char next = split(map, delim);
111	✓✓✗✓	4	if (!next && delim == '-')
112			return AVERROR(EINVAL);
113		4	ch = av_get_channel_layout(map);
114	✗✓	4	if (av_get_channel_layout_nb_channels(*ch) != 1)
115			return AVERROR(EINVAL);
116		4	*map = next;
117		4	return 0;
118			}
119
120		4	static av_cold int channelmap_init(AVFilterContext *ctx)
121			{
122		4	ChannelMapContext *s = ctx->priv;
123		4	char *mapping, separator = '\|';
124		4	int map_entries = 0;
125			char buf[256];
126			enum MappingMode mode;
127		4	uint64_t out_ch_mask = 0;
128			int i;
129
130		4	mapping = s->mapping_str;
131
132	✗✓	4	if (!mapping) {
133			mode = MAP_NONE;
134			} else {
135		4	char *dash = strchr(mapping, '-');
136	✓✗	4	if (!dash) { // short mapping
137	✓✓	4	if (av_isdigit(*mapping))
138		2	mode = MAP_ONE_INT;
139			else
140		2	mode = MAP_ONE_STR;
141			} else if (av_isdigit(*mapping)) {
142			if (av_isdigit(*(dash+1)))
143			mode = MAP_PAIR_INT_INT;
144			else
145			mode = MAP_PAIR_INT_STR;
146			} else {
147			if (av_isdigit(*(dash+1)))
148			mode = MAP_PAIR_STR_INT;
149			else
150			mode = MAP_PAIR_STR_STR;
151			}
152			}
153
154	✓✗	4	if (mode != MAP_NONE) {
155		4	char *sep = mapping;
156		4	map_entries = 1;
157	✓✓	16	while ((sep = strchr(sep, separator))) {
158	✓✗	12	if (*++sep) // Allow trailing comma
159		12	map_entries++;
160			}
161			}
162
163	✗✓	4	if (map_entries > MAX_CH) {
164			av_log(ctx, AV_LOG_ERROR, "Too many channels mapped: '%d'.\n", map_entries);
165			return AVERROR(EINVAL);
166			}
167
168	✓✓	20	for (i = 0; i < map_entries; i++) {
169		16	int in_ch_idx = -1, out_ch_idx = -1;
170		16	uint64_t in_ch = 0, out_ch = 0;
171			static const char err[] = "Failed to parse channel map\n";
172	✓✓✗✗ ✗✗✗	16	switch (mode) {
173		12	case MAP_ONE_INT:
174	✗✓	12	if (get_channel_idx(&mapping, &in_ch_idx, separator, MAX_CH) < 0) {
175			av_log(ctx, AV_LOG_ERROR, err);
176			return AVERROR(EINVAL);
177			}
178		12	s->map[i].in_channel_idx = in_ch_idx;
179		12	s->map[i].out_channel_idx = i;
180		12	break;
181		4	case MAP_ONE_STR:
182	✗✓	4	if (get_channel(&mapping, &in_ch, separator) < 0) {
183			av_log(ctx, AV_LOG_ERROR, err);
184			return AVERROR(EINVAL);
185			}
186		4	s->map[i].in_channel = in_ch;
187		4	s->map[i].out_channel_idx = i;
188		4	break;
189			case MAP_PAIR_INT_INT:
190			if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 \|\|
191			get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {
192			av_log(ctx, AV_LOG_ERROR, err);
193			return AVERROR(EINVAL);
194			}
195			s->map[i].in_channel_idx = in_ch_idx;
196			s->map[i].out_channel_idx = out_ch_idx;
197			break;
198			case MAP_PAIR_INT_STR:
199			if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 \|\|
200			get_channel(&mapping, &out_ch, separator) < 0 \|\|
201			out_ch & out_ch_mask) {
202			av_log(ctx, AV_LOG_ERROR, err);
203			return AVERROR(EINVAL);
204			}
205			s->map[i].in_channel_idx = in_ch_idx;
206			s->map[i].out_channel = out_ch;
207			out_ch_mask \|= out_ch;
208			break;
209			case MAP_PAIR_STR_INT:
210			if (get_channel(&mapping, &in_ch, '-') < 0 \|\|
211			get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {
212			av_log(ctx, AV_LOG_ERROR, err);
213			return AVERROR(EINVAL);
214			}
215			s->map[i].in_channel = in_ch;
216			s->map[i].out_channel_idx = out_ch_idx;
217			break;
218			case MAP_PAIR_STR_STR:
219			if (get_channel(&mapping, &in_ch, '-') < 0 \|\|
220			get_channel(&mapping, &out_ch, separator) < 0 \|\|
221			out_ch & out_ch_mask) {
222			av_log(ctx, AV_LOG_ERROR, err);
223			return AVERROR(EINVAL);
224			}
225			s->map[i].in_channel = in_ch;
226			s->map[i].out_channel = out_ch;
227			out_ch_mask \|= out_ch;
228			break;
229			}
230		16	}
231		4	s->mode = mode;
232		4	s->nch = map_entries;
233	✓✗	8	s->output_layout = out_ch_mask ? out_ch_mask :
234		4	av_get_default_channel_layout(map_entries);
235
236	✓✗	4	if (s->channel_layout_str) {
237			uint64_t fmt;
238	✗✓	4	if ((fmt = av_get_channel_layout(s->channel_layout_str)) == 0) {
239			av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout: '%s'.\n",
240			s->channel_layout_str);
241			return AVERROR(EINVAL);
242			}
243	✗✓	4	if (mode == MAP_NONE) {
244			int i;
245			s->nch = av_get_channel_layout_nb_channels(fmt);
246			for (i = 0; i < s->nch; i++) {
247			s->map[i].in_channel_idx = i;
248			s->map[i].out_channel_idx = i;
249			}
250	✗✓✗✗	4	} else if (out_ch_mask && out_ch_mask != fmt) {
251			av_get_channel_layout_string(buf, sizeof(buf), 0, out_ch_mask);
252			av_log(ctx, AV_LOG_ERROR,
253			"Output channel layout '%s' does not match the list of channel mapped: '%s'.\n",
254			s->channel_layout_str, buf);
255			return AVERROR(EINVAL);
256	✗✓	4	} else if (s->nch != av_get_channel_layout_nb_channels(fmt)) {
257			av_log(ctx, AV_LOG_ERROR,
258			"Output channel layout %s does not match the number of channels mapped %d.\n",
259			s->channel_layout_str, s->nch);
260			return AVERROR(EINVAL);
261			}
262		4	s->output_layout = fmt;
263			}
264	✗✓	4	if (!s->output_layout) {
265			av_log(ctx, AV_LOG_ERROR, "Output channel layout is not set and "
266			"cannot be guessed from the maps.\n");
267			return AVERROR(EINVAL);
268			}
269
270	✓✗✗✓	4	if (mode == MAP_PAIR_INT_STR \|\| mode == MAP_PAIR_STR_STR) {
271			for (i = 0; i < s->nch; i++) {
272			s->map[i].out_channel_idx = av_get_channel_layout_channel_index(
273			s->output_layout, s->map[i].out_channel);
274			}
275			}
276
277		4	return 0;
278			}
279
280		2	static int channelmap_query_formats(AVFilterContext *ctx)
281			{
282		2	ChannelMapContext *s = ctx->priv;
283		2	AVFilterChannelLayouts *channel_layouts = NULL;
284			int ret;
285
286	✓✗✓✗	4	if ((ret = ff_set_common_formats (ctx, ff_planar_sample_fmts())) < 0 \|\|
287	✓✗	4	(ret = ff_set_common_samplerates (ctx , ff_all_samplerates() )) < 0 \|\|
288	✗✓	4	(ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0 \|\|
289		2	(ret = ff_channel_layouts_ref(channel_layouts,
290		2	&ctx->outputs[0]->incfg.channel_layouts)) < 0)
291			return ret;
292
293		2	return ff_channel_layouts_ref(ff_all_channel_counts(),
294		2	&ctx->inputs[0]->outcfg.channel_layouts);
295			}
296
297		1035	static int channelmap_filter_frame(AVFilterLink inlink, AVFrame buf)
298			{
299		1035	AVFilterContext *ctx = inlink->dst;
300		1035	AVFilterLink *outlink = ctx->outputs[0];
301		1035	const ChannelMapContext *s = ctx->priv;
302		1035	const int nch_in = inlink->channels;
303		1035	const int nch_out = s->nch;
304			int ch;
305			uint8_t *source_planes[MAX_CH];
306
307		1035	memcpy(source_planes, buf->extended_data,
308			nch_in * sizeof(source_planes[0]));
309
310	✗✓	1035	if (nch_out > nch_in) {
311			if (nch_out > FF_ARRAY_ELEMS(buf->data)) {
312			uint8_t **new_extended_data =
313			av_mallocz_array(nch_out, sizeof(*buf->extended_data));
314			if (!new_extended_data) {
315			av_frame_free(&buf);
316			return AVERROR(ENOMEM);
317			}
318			if (buf->extended_data == buf->data) {
319			buf->extended_data = new_extended_data;
320			} else {
321			av_free(buf->extended_data);
322			buf->extended_data = new_extended_data;
323			}
324			} else if (buf->extended_data != buf->data) {
325			av_free(buf->extended_data);
326			buf->extended_data = buf->data;
327			}
328			}
329
330	✓✓	6209	for (ch = 0; ch < nch_out; ch++) {
331		5174	buf->extended_data[s->map[ch].out_channel_idx] =
332		5174	source_planes[s->map[ch].in_channel_idx];
333			}
334
335	✗✓	1035	if (buf->data != buf->extended_data)
336			memcpy(buf->data, buf->extended_data,
337			FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));
338
339		1035	buf->channel_layout = outlink->channel_layout;
340		1035	buf->channels = outlink->channels;
341
342		1035	return ff_filter_frame(outlink, buf);
343			}
344
345		2	static int channelmap_config_input(AVFilterLink *inlink)
346			{
347		2	AVFilterContext *ctx = inlink->dst;
348		2	ChannelMapContext *s = ctx->priv;
349		2	int nb_channels = inlink->channels;
350		2	int i, err = 0;
351			const char *channel_name;
352			char layout_name[256];
353
354	✓✓	10	for (i = 0; i < s->nch; i++) {
355		8	struct ChannelMap *m = &s->map[i];
356
357	✓✗✗✓	8	if (s->mode == MAP_PAIR_STR_INT \|\| s->mode == MAP_PAIR_STR_STR) {
358			m->in_channel_idx = av_get_channel_layout_channel_index(
359			inlink->channel_layout, m->in_channel);
360			}
361
362	✓✗✗✓	8	if (m->in_channel_idx < 0 \|\| m->in_channel_idx >= nb_channels) {
363			av_get_channel_layout_string(layout_name, sizeof(layout_name),
364			nb_channels, inlink->channel_layout);
365			if (m->in_channel) {
366			channel_name = av_get_channel_name(m->in_channel);
367			av_log(ctx, AV_LOG_ERROR,
368			"input channel '%s' not available from input layout '%s'\n",
369			channel_name, layout_name);
370			} else {
371			av_log(ctx, AV_LOG_ERROR,
372			"input channel #%d not available from input layout '%s'\n",
373			m->in_channel_idx, layout_name);
374			}
375			err = AVERROR(EINVAL);
376			}
377			}
378
379		2	return err;
380			}
381
382			static const AVFilterPad avfilter_af_channelmap_inputs[] = {
383			{
384			.name = "default",
385			.type = AVMEDIA_TYPE_AUDIO,
386			.filter_frame = channelmap_filter_frame,
387			.config_props = channelmap_config_input,
388			.needs_writable = 1,
389			},
390			{ NULL }
391			};
392
393			static const AVFilterPad avfilter_af_channelmap_outputs[] = {
394			{
395			.name = "default",
396			.type = AVMEDIA_TYPE_AUDIO
397			},
398			{ NULL }
399			};
400
401			AVFilter ff_af_channelmap = {
402			.name = "channelmap",
403			.description = NULL_IF_CONFIG_SMALL("Remap audio channels."),
404			.init = channelmap_init,
405			.query_formats = channelmap_query_formats,
406			.priv_size = sizeof(ChannelMapContext),
407			.priv_class = &channelmap_class,
408			.inputs = avfilter_af_channelmap_inputs,
409			.outputs = avfilter_af_channelmap_outputs,
410			};