FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/af_aderivative.c	Lines:	0	58	0.0 %
Date:	2020-09-25 14:59:26	Branches:	0	50	0.0 %


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

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

typedef struct ADerivativeContext {
    const AVClass *class;
    AVFrame *prev;
    void (*filter)(void **dst, void **prv, const void **src,
                   int nb_samples, int channels);
} ADerivativeContext;

static int query_formats(AVFilterContext *ctx)
{
    AVFilterFormats *formats = NULL;
    AVFilterChannelLayouts *layouts = NULL;
    static const enum AVSampleFormat derivative_sample_fmts[] = {
        AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_FLTP,
        AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_DBLP,
        AV_SAMPLE_FMT_NONE
    };
    static const enum AVSampleFormat integral_sample_fmts[] = {
        AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
        AV_SAMPLE_FMT_NONE
    };
    int ret;

    formats = ff_make_format_list(strcmp(ctx->filter->name, "aintegral") ?
                                  derivative_sample_fmts : integral_sample_fmts);
    if (!formats)
        return AVERROR(ENOMEM);
    ret = ff_set_common_formats(ctx, formats);
    if (ret < 0)
        return ret;

    layouts = ff_all_channel_counts();
    if (!layouts)
        return AVERROR(ENOMEM);

    ret = ff_set_common_channel_layouts(ctx, layouts);
    if (ret < 0)
        return ret;

    formats = ff_all_samplerates();
    return ff_set_common_samplerates(ctx, formats);
}

#define DERIVATIVE(name, type)                                          \
static void aderivative_## name ##p(void **d, void **p, const void **s, \
                                    int nb_samples, int channels)       \
{                                                                       \
    int n, c;                                                           \
                                                                        \
    for (c = 0; c < channels; c++) {                                    \
        const type *src = s[c];                                         \
        type *dst = d[c];                                               \
        type *prv = p[c];                                               \
                                                                        \
        for (n = 0; n < nb_samples; n++) {                              \
            const type current = src[n];                                \
                                                                        \
            dst[n] = current - prv[0];                                  \
            prv[0] = current;                                           \
        }                                                               \
    }                                                                   \
}

DERIVATIVE(flt, float)
DERIVATIVE(dbl, double)
DERIVATIVE(s16, int16_t)
DERIVATIVE(s32, int32_t)

#define INTEGRAL(name, type)                                          \
static void aintegral_## name ##p(void **d, void **p, const void **s, \
                                  int nb_samples, int channels)       \
{                                                                     \
    int n, c;                                                         \
                                                                      \
    for (c = 0; c < channels; c++) {                                  \
        const type *src = s[c];                                       \
        type *dst = d[c];                                             \
        type *prv = p[c];                                             \
                                                                      \
        for (n = 0; n < nb_samples; n++) {                            \
            const type current = src[n];                              \
                                                                      \
            dst[n] = current + prv[0];                                \
            prv[0] = dst[n];                                          \
        }                                                             \
    }                                                                 \
}

INTEGRAL(flt, float)
INTEGRAL(dbl, double)

static int config_input(AVFilterLink *inlink)
{
    AVFilterContext *ctx = inlink->dst;
    ADerivativeContext *s = ctx->priv;

    switch (inlink->format) {
    case AV_SAMPLE_FMT_FLTP: s->filter = aderivative_fltp; break;
    case AV_SAMPLE_FMT_DBLP: s->filter = aderivative_dblp; break;
    case AV_SAMPLE_FMT_S32P: s->filter = aderivative_s32p; break;
    case AV_SAMPLE_FMT_S16P: s->filter = aderivative_s16p; break;
    }

    if (strcmp(ctx->filter->name, "aintegral"))
        return 0;

    switch (inlink->format) {
    case AV_SAMPLE_FMT_FLTP: s->filter = aintegral_fltp; break;
    case AV_SAMPLE_FMT_DBLP: s->filter = aintegral_dblp; break;
    }

    return 0;
}

static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
    AVFilterContext *ctx = inlink->dst;
    ADerivativeContext *s = ctx->priv;
    AVFilterLink *outlink = ctx->outputs[0];
    AVFrame *out = ff_get_audio_buffer(outlink, in->nb_samples);

    if (!out) {
        av_frame_free(&in);
        return AVERROR(ENOMEM);
    }
    av_frame_copy_props(out, in);

    if (!s->prev) {
        s->prev = ff_get_audio_buffer(inlink, 1);
        if (!s->prev) {
            av_frame_free(&in);
            return AVERROR(ENOMEM);
        }
    }

    s->filter((void **)out->extended_data, (void **)s->prev->extended_data, (const void **)in->extended_data,
              in->nb_samples, in->channels);

    av_frame_free(&in);
    return ff_filter_frame(outlink, out);
}

static av_cold void uninit(AVFilterContext *ctx)
{
    ADerivativeContext *s = ctx->priv;

    av_frame_free(&s->prev);
}

static const AVFilterPad aderivative_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_AUDIO,
        .filter_frame = filter_frame,
        .config_props = config_input,
    },
    { NULL }
};

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

AVFilter ff_af_aderivative = {
    .name          = "aderivative",
    .description   = NULL_IF_CONFIG_SMALL("Compute derivative of input audio."),
    .query_formats = query_formats,
    .priv_size     = sizeof(ADerivativeContext),
    .uninit        = uninit,
    .inputs        = aderivative_inputs,
    .outputs       = aderivative_outputs,
};

AVFilter ff_af_aintegral = {
    .name          = "aintegral",
    .description   = NULL_IF_CONFIG_SMALL("Compute integral of input audio."),
    .query_formats = query_formats,
    .priv_size     = sizeof(ADerivativeContext),
    .uninit        = uninit,
    .inputs        = aderivative_inputs,
    .outputs       = aderivative_outputs,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* This file is part of FFmpeg.
3			*
4			* FFmpeg is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* FFmpeg is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with FFmpeg; if not, write to the Free Software
16			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17			*/
18
19			#include "audio.h"
20			#include "avfilter.h"
21			#include "internal.h"
22
23			typedef struct ADerivativeContext {
24			const AVClass *class;
25			AVFrame *prev;
26			void (filter)(void dst, void prv, const void *src,
27			int nb_samples, int channels);
28			} ADerivativeContext;
29
30			static int query_formats(AVFilterContext *ctx)
31			{
32			AVFilterFormats *formats = NULL;
33			AVFilterChannelLayouts *layouts = NULL;
34			static const enum AVSampleFormat derivative_sample_fmts[] = {
35			AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_FLTP,
36			AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_DBLP,
37			AV_SAMPLE_FMT_NONE
38			};
39			static const enum AVSampleFormat integral_sample_fmts[] = {
40			AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
41			AV_SAMPLE_FMT_NONE
42			};
43			int ret;
44
45			formats = ff_make_format_list(strcmp(ctx->filter->name, "aintegral") ?
46			derivative_sample_fmts : integral_sample_fmts);
47			if (!formats)
48			return AVERROR(ENOMEM);
49			ret = ff_set_common_formats(ctx, formats);
50			if (ret < 0)
51			return ret;
52
53			layouts = ff_all_channel_counts();
54			if (!layouts)
55			return AVERROR(ENOMEM);
56
57			ret = ff_set_common_channel_layouts(ctx, layouts);
58			if (ret < 0)
59			return ret;
60
61			formats = ff_all_samplerates();
62			return ff_set_common_samplerates(ctx, formats);
63			}
64
65			#define DERIVATIVE(name, type) \
66			static void aderivative_## name ##p(void d, void p, const void **s, \
67			int nb_samples, int channels) \
68			{ \
69			int n, c; \
70			\
71			for (c = 0; c < channels; c++) { \
72			const type *src = s[c]; \
73			type *dst = d[c]; \
74			type *prv = p[c]; \
75			\
76			for (n = 0; n < nb_samples; n++) { \
77			const type current = src[n]; \
78			\
79			dst[n] = current - prv[0]; \
80			prv[0] = current; \
81			} \
82			} \
83			}
84
85			DERIVATIVE(flt, float)
86			DERIVATIVE(dbl, double)
87			DERIVATIVE(s16, int16_t)
88			DERIVATIVE(s32, int32_t)
89
90			#define INTEGRAL(name, type) \
91			static void aintegral_## name ##p(void d, void p, const void **s, \
92			int nb_samples, int channels) \
93			{ \
94			int n, c; \
95			\
96			for (c = 0; c < channels; c++) { \
97			const type *src = s[c]; \
98			type *dst = d[c]; \
99			type *prv = p[c]; \
100			\
101			for (n = 0; n < nb_samples; n++) { \
102			const type current = src[n]; \
103			\
104			dst[n] = current + prv[0]; \
105			prv[0] = dst[n]; \
106			} \
107			} \
108			}
109
110			INTEGRAL(flt, float)
111			INTEGRAL(dbl, double)
112
113			static int config_input(AVFilterLink *inlink)
114			{
115			AVFilterContext *ctx = inlink->dst;
116			ADerivativeContext *s = ctx->priv;
117
118			switch (inlink->format) {
119			case AV_SAMPLE_FMT_FLTP: s->filter = aderivative_fltp; break;
120			case AV_SAMPLE_FMT_DBLP: s->filter = aderivative_dblp; break;
121			case AV_SAMPLE_FMT_S32P: s->filter = aderivative_s32p; break;
122			case AV_SAMPLE_FMT_S16P: s->filter = aderivative_s16p; break;
123			}
124
125			if (strcmp(ctx->filter->name, "aintegral"))
126			return 0;
127
128			switch (inlink->format) {
129			case AV_SAMPLE_FMT_FLTP: s->filter = aintegral_fltp; break;
130			case AV_SAMPLE_FMT_DBLP: s->filter = aintegral_dblp; break;
131			}
132
133			return 0;
134			}
135
136			static int filter_frame(AVFilterLink inlink, AVFrame in)
137			{
138			AVFilterContext *ctx = inlink->dst;
139			ADerivativeContext *s = ctx->priv;
140			AVFilterLink *outlink = ctx->outputs[0];
141			AVFrame *out = ff_get_audio_buffer(outlink, in->nb_samples);
142
143			if (!out) {
144			av_frame_free(&in);
145			return AVERROR(ENOMEM);
146			}
147			av_frame_copy_props(out, in);
148
149			if (!s->prev) {
150			s->prev = ff_get_audio_buffer(inlink, 1);
151			if (!s->prev) {
152			av_frame_free(&in);
153			return AVERROR(ENOMEM);
154			}
155			}
156
157			s->filter((void )out->extended_data, (void )s->prev->extended_data, (const void **)in->extended_data,
158			in->nb_samples, in->channels);
159
160			av_frame_free(&in);
161			return ff_filter_frame(outlink, out);
162			}
163
164			static av_cold void uninit(AVFilterContext *ctx)
165			{
166			ADerivativeContext *s = ctx->priv;
167
168			av_frame_free(&s->prev);
169			}
170
171			static const AVFilterPad aderivative_inputs[] = {
172			{
173			.name = "default",
174			.type = AVMEDIA_TYPE_AUDIO,
175			.filter_frame = filter_frame,
176			.config_props = config_input,
177			},
178			{ NULL }
179			};
180
181			static const AVFilterPad aderivative_outputs[] = {
182			{
183			.name = "default",
184			.type = AVMEDIA_TYPE_AUDIO,
185			},
186			{ NULL }
187			};
188
189			AVFilter ff_af_aderivative = {
190			.name = "aderivative",
191			.description = NULL_IF_CONFIG_SMALL("Compute derivative of input audio."),
192			.query_formats = query_formats,
193			.priv_size = sizeof(ADerivativeContext),
194			.uninit = uninit,
195			.inputs = aderivative_inputs,
196			.outputs = aderivative_outputs,
197			};
198
199			AVFilter ff_af_aintegral = {
200			.name = "aintegral",
201			.description = NULL_IF_CONFIG_SMALL("Compute integral of input audio."),
202			.query_formats = query_formats,
203			.priv_size = sizeof(ADerivativeContext),
204			.uninit = uninit,
205			.inputs = aderivative_inputs,
206			.outputs = aderivative_outputs,
207			};