FFmpeg coverage

GCC Code Coverage Report

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


/*
 * Copyright (c) 2015 Derek Buitenhuis
 *
 * 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 "libavutil/opt.h"
#include "avfilter.h"
#include "formats.h"
#include "internal.h"
#include "video.h"

#define DEFAULT_LENGTH 300

typedef struct ReverseContext {
    int nb_frames;
    AVFrame **frames;
    unsigned int frames_size;
    unsigned int pts_size;
    int64_t *pts;
    int flush_idx;
} ReverseContext;

static av_cold int init(AVFilterContext *ctx)
{
    ReverseContext *s = ctx->priv;

    s->pts = av_fast_realloc(NULL, &s->pts_size,
                             DEFAULT_LENGTH * sizeof(*(s->pts)));
    if (!s->pts)
        return AVERROR(ENOMEM);

    s->frames = av_fast_realloc(NULL, &s->frames_size,
                                DEFAULT_LENGTH * sizeof(*(s->frames)));
    if (!s->frames) {
        av_freep(&s->pts);
        return AVERROR(ENOMEM);
    }

    return 0;
}

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

    while (s->nb_frames > 0) {
        av_frame_free(&s->frames[s->nb_frames - 1]);
        s->nb_frames--;
    }

    av_freep(&s->pts);
    av_freep(&s->frames);
}

static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
    AVFilterContext *ctx = inlink->dst;
    ReverseContext *s    = ctx->priv;
    void *ptr;

    if (s->nb_frames + 1 > s->pts_size / sizeof(*(s->pts))) {
        ptr = av_fast_realloc(s->pts, &s->pts_size, s->pts_size * 2);
        if (!ptr)
            return AVERROR(ENOMEM);
        s->pts = ptr;
    }

    if (s->nb_frames + 1 > s->frames_size / sizeof(*(s->frames))) {
        ptr = av_fast_realloc(s->frames, &s->frames_size, s->frames_size * 2);
        if (!ptr)
            return AVERROR(ENOMEM);
        s->frames = ptr;
    }

    s->frames[s->nb_frames] = in;
    s->pts[s->nb_frames]    = in->pts;
    s->nb_frames++;

    return 0;
}

#if CONFIG_REVERSE_FILTER

static int request_frame(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    ReverseContext *s = ctx->priv;
    int ret;

    ret = ff_request_frame(ctx->inputs[0]);

    if (ret == AVERROR_EOF && s->nb_frames > 0) {
        AVFrame *out = s->frames[s->nb_frames - 1];
        out->pts     = s->pts[s->flush_idx++];
        ret          = ff_filter_frame(outlink, out);
        s->frames[s->nb_frames - 1] = NULL;
        s->nb_frames--;
    }

    return ret;
}

static const AVFilterPad reverse_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_VIDEO,
        .filter_frame = filter_frame,
    },
    { NULL }
};

static const AVFilterPad reverse_outputs[] = {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .request_frame = request_frame,
    },
    { NULL }
};

AVFilter ff_vf_reverse = {
    .name        = "reverse",
    .description = NULL_IF_CONFIG_SMALL("Reverse a clip."),
    .priv_size   = sizeof(ReverseContext),
    .init        = init,
    .uninit      = uninit,
    .inputs      = reverse_inputs,
    .outputs     = reverse_outputs,
};

#endif /* CONFIG_REVERSE_FILTER */

#if CONFIG_AREVERSE_FILTER

static int query_formats(AVFilterContext *ctx)
{
    AVFilterFormats *formats;
    AVFilterChannelLayouts *layouts;
    int ret;

    layouts = ff_all_channel_counts();
    if (!layouts)
        return AVERROR(ENOMEM);
    ret = ff_set_common_channel_layouts(ctx, layouts);
    if (ret < 0)
        return ret;

    ret = ff_set_common_formats(ctx, ff_all_formats(AVMEDIA_TYPE_AUDIO));
    if (ret < 0)
        return ret;

    formats = ff_all_samplerates();
    if (!formats)
        return AVERROR(ENOMEM);
    return ff_set_common_samplerates(ctx, formats);
}

static void reverse_samples_planar(AVFrame *out)
{
    for (int p = 0; p < out->channels; p++) {
        switch (out->format) {
        case AV_SAMPLE_FMT_U8P: {
            uint8_t *dst = (uint8_t *)out->extended_data[p];
            for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
                FFSWAP(uint8_t, dst[i], dst[j]);
        }
            break;
        case AV_SAMPLE_FMT_S16P: {
            int16_t *dst = (int16_t *)out->extended_data[p];
            for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
                FFSWAP(int16_t, dst[i], dst[j]);
        }
            break;
        case AV_SAMPLE_FMT_S32P: {
            int32_t *dst = (int32_t *)out->extended_data[p];
            for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
                FFSWAP(int32_t, dst[i], dst[j]);
        }
            break;
        case AV_SAMPLE_FMT_FLTP: {
            float *dst = (float *)out->extended_data[p];
            for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
                FFSWAP(float, dst[i], dst[j]);
        }
            break;
        case AV_SAMPLE_FMT_DBLP: {
            double *dst = (double *)out->extended_data[p];
            for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
                FFSWAP(double, dst[i], dst[j]);
        }
            break;
        }
    }
}

static void reverse_samples_packed(AVFrame *out)
{
    const int channels = out->channels;

    switch (out->format) {
    case AV_SAMPLE_FMT_U8: {
        uint8_t *dst = (uint8_t *)out->extended_data[0];
        for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
            for (int p = 0; p < channels; p++)
                FFSWAP(uint8_t, dst[i * channels + p], dst[j * channels + p]);
    }
        break;
    case AV_SAMPLE_FMT_S16: {
        int16_t *dst = (int16_t *)out->extended_data[0];
        for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
            for (int p = 0; p < channels; p++)
                FFSWAP(int16_t, dst[i * channels + p], dst[j * channels + p]);
    }
        break;
    case AV_SAMPLE_FMT_S32: {
        int32_t *dst = (int32_t *)out->extended_data[0];
        for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
            for (int p = 0; p < channels; p++)
                FFSWAP(int32_t, dst[i * channels + p], dst[j * channels + p]);
    }
        break;
    case AV_SAMPLE_FMT_FLT: {
        float *dst = (float *)out->extended_data[0];
        for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
            for (int p = 0; p < channels; p++)
                FFSWAP(float, dst[i * channels + p], dst[j * channels + p]);
    }
        break;
    case AV_SAMPLE_FMT_DBL: {
        double *dst = (double *)out->extended_data[0];
        for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
            for (int p = 0; p < channels; p++)
                FFSWAP(double, dst[i * channels + p], dst[j * channels + p]);
    }
        break;
    }
}

static int areverse_request_frame(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    ReverseContext *s = ctx->priv;
    int ret;

    ret = ff_request_frame(ctx->inputs[0]);

    if (ret == AVERROR_EOF && s->nb_frames > 0) {
        AVFrame *out = s->frames[s->nb_frames - 1];
        out->pts     = s->pts[s->flush_idx++];

        if (av_sample_fmt_is_planar(out->format))
            reverse_samples_planar(out);
        else
            reverse_samples_packed(out);
        ret = ff_filter_frame(outlink, out);
        s->frames[s->nb_frames - 1] = NULL;
        s->nb_frames--;
    }

    return ret;
}

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

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

AVFilter ff_af_areverse = {
    .name          = "areverse",
    .description   = NULL_IF_CONFIG_SMALL("Reverse an audio clip."),
    .query_formats = query_formats,
    .priv_size     = sizeof(ReverseContext),
    .init          = init,
    .uninit        = uninit,
    .inputs        = areverse_inputs,
    .outputs       = areverse_outputs,
};

#endif /* CONFIG_AREVERSE_FILTER */


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2015 Derek Buitenhuis
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			#include "libavutil/opt.h"
22			#include "avfilter.h"
23			#include "formats.h"
24			#include "internal.h"
25			#include "video.h"
26
27			#define DEFAULT_LENGTH 300
28
29			typedef struct ReverseContext {
30			int nb_frames;
31			AVFrame **frames;
32			unsigned int frames_size;
33			unsigned int pts_size;
34			int64_t *pts;
35			int flush_idx;
36			} ReverseContext;
37
38			static av_cold int init(AVFilterContext *ctx)
39			{
40			ReverseContext *s = ctx->priv;
41
42			s->pts = av_fast_realloc(NULL, &s->pts_size,
43			DEFAULT_LENGTH * sizeof(*(s->pts)));
44			if (!s->pts)
45			return AVERROR(ENOMEM);
46
47			s->frames = av_fast_realloc(NULL, &s->frames_size,
48			DEFAULT_LENGTH * sizeof(*(s->frames)));
49			if (!s->frames) {
50			av_freep(&s->pts);
51			return AVERROR(ENOMEM);
52			}
53
54			return 0;
55			}
56
57			static av_cold void uninit(AVFilterContext *ctx)
58			{
59			ReverseContext *s = ctx->priv;
60
61			while (s->nb_frames > 0) {
62			av_frame_free(&s->frames[s->nb_frames - 1]);
63			s->nb_frames--;
64			}
65
66			av_freep(&s->pts);
67			av_freep(&s->frames);
68			}
69
70			static int filter_frame(AVFilterLink inlink, AVFrame in)
71			{
72			AVFilterContext *ctx = inlink->dst;
73			ReverseContext *s = ctx->priv;
74			void *ptr;
75
76			if (s->nb_frames + 1 > s->pts_size / sizeof(*(s->pts))) {
77			ptr = av_fast_realloc(s->pts, &s->pts_size, s->pts_size * 2);
78			if (!ptr)
79			return AVERROR(ENOMEM);
80			s->pts = ptr;
81			}
82
83			if (s->nb_frames + 1 > s->frames_size / sizeof(*(s->frames))) {
84			ptr = av_fast_realloc(s->frames, &s->frames_size, s->frames_size * 2);
85			if (!ptr)
86			return AVERROR(ENOMEM);
87			s->frames = ptr;
88			}
89
90			s->frames[s->nb_frames] = in;
91			s->pts[s->nb_frames] = in->pts;
92			s->nb_frames++;
93
94			return 0;
95			}
96
97			#if CONFIG_REVERSE_FILTER
98
99			static int request_frame(AVFilterLink *outlink)
100			{
101			AVFilterContext *ctx = outlink->src;
102			ReverseContext *s = ctx->priv;
103			int ret;
104
105			ret = ff_request_frame(ctx->inputs[0]);
106
107			if (ret == AVERROR_EOF && s->nb_frames > 0) {
108			AVFrame *out = s->frames[s->nb_frames - 1];
109			out->pts = s->pts[s->flush_idx++];
110			ret = ff_filter_frame(outlink, out);
111			s->frames[s->nb_frames - 1] = NULL;
112			s->nb_frames--;
113			}
114
115			return ret;
116			}
117
118			static const AVFilterPad reverse_inputs[] = {
119			{
120			.name = "default",
121			.type = AVMEDIA_TYPE_VIDEO,
122			.filter_frame = filter_frame,
123			},
124			{ NULL }
125			};
126
127			static const AVFilterPad reverse_outputs[] = {
128			{
129			.name = "default",
130			.type = AVMEDIA_TYPE_VIDEO,
131			.request_frame = request_frame,
132			},
133			{ NULL }
134			};
135
136			AVFilter ff_vf_reverse = {
137			.name = "reverse",
138			.description = NULL_IF_CONFIG_SMALL("Reverse a clip."),
139			.priv_size = sizeof(ReverseContext),
140			.init = init,
141			.uninit = uninit,
142			.inputs = reverse_inputs,
143			.outputs = reverse_outputs,
144			};
145
146			#endif /* CONFIG_REVERSE_FILTER */
147
148			#if CONFIG_AREVERSE_FILTER
149
150			static int query_formats(AVFilterContext *ctx)
151			{
152			AVFilterFormats *formats;
153			AVFilterChannelLayouts *layouts;
154			int ret;
155
156			layouts = ff_all_channel_counts();
157			if (!layouts)
158			return AVERROR(ENOMEM);
159			ret = ff_set_common_channel_layouts(ctx, layouts);
160			if (ret < 0)
161			return ret;
162
163			ret = ff_set_common_formats(ctx, ff_all_formats(AVMEDIA_TYPE_AUDIO));
164			if (ret < 0)
165			return ret;
166
167			formats = ff_all_samplerates();
168			if (!formats)
169			return AVERROR(ENOMEM);
170			return ff_set_common_samplerates(ctx, formats);
171			}
172
173			static void reverse_samples_planar(AVFrame *out)
174			{
175			for (int p = 0; p < out->channels; p++) {
176			switch (out->format) {
177			case AV_SAMPLE_FMT_U8P: {
178			uint8_t dst = (uint8_t )out->extended_data[p];
179			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
180			FFSWAP(uint8_t, dst[i], dst[j]);
181			}
182			break;
183			case AV_SAMPLE_FMT_S16P: {
184			int16_t dst = (int16_t )out->extended_data[p];
185			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
186			FFSWAP(int16_t, dst[i], dst[j]);
187			}
188			break;
189			case AV_SAMPLE_FMT_S32P: {
190			int32_t dst = (int32_t )out->extended_data[p];
191			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
192			FFSWAP(int32_t, dst[i], dst[j]);
193			}
194			break;
195			case AV_SAMPLE_FMT_FLTP: {
196			float dst = (float )out->extended_data[p];
197			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
198			FFSWAP(float, dst[i], dst[j]);
199			}
200			break;
201			case AV_SAMPLE_FMT_DBLP: {
202			double dst = (double )out->extended_data[p];
203			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
204			FFSWAP(double, dst[i], dst[j]);
205			}
206			break;
207			}
208			}
209			}
210
211			static void reverse_samples_packed(AVFrame *out)
212			{
213			const int channels = out->channels;
214
215			switch (out->format) {
216			case AV_SAMPLE_FMT_U8: {
217			uint8_t dst = (uint8_t )out->extended_data[0];
218			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
219			for (int p = 0; p < channels; p++)
220			FFSWAP(uint8_t, dst[i * channels + p], dst[j * channels + p]);
221			}
222			break;
223			case AV_SAMPLE_FMT_S16: {
224			int16_t dst = (int16_t )out->extended_data[0];
225			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
226			for (int p = 0; p < channels; p++)
227			FFSWAP(int16_t, dst[i * channels + p], dst[j * channels + p]);
228			}
229			break;
230			case AV_SAMPLE_FMT_S32: {
231			int32_t dst = (int32_t )out->extended_data[0];
232			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
233			for (int p = 0; p < channels; p++)
234			FFSWAP(int32_t, dst[i * channels + p], dst[j * channels + p]);
235			}
236			break;
237			case AV_SAMPLE_FMT_FLT: {
238			float dst = (float )out->extended_data[0];
239			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
240			for (int p = 0; p < channels; p++)
241			FFSWAP(float, dst[i * channels + p], dst[j * channels + p]);
242			}
243			break;
244			case AV_SAMPLE_FMT_DBL: {
245			double dst = (double )out->extended_data[0];
246			for (int i = 0, j = out->nb_samples - 1; i < j; i++, j--)
247			for (int p = 0; p < channels; p++)
248			FFSWAP(double, dst[i * channels + p], dst[j * channels + p]);
249			}
250			break;
251			}
252			}
253
254			static int areverse_request_frame(AVFilterLink *outlink)
255			{
256			AVFilterContext *ctx = outlink->src;
257			ReverseContext *s = ctx->priv;
258			int ret;
259
260			ret = ff_request_frame(ctx->inputs[0]);
261
262			if (ret == AVERROR_EOF && s->nb_frames > 0) {
263			AVFrame *out = s->frames[s->nb_frames - 1];
264			out->pts = s->pts[s->flush_idx++];
265
266			if (av_sample_fmt_is_planar(out->format))
267			reverse_samples_planar(out);
268			else
269			reverse_samples_packed(out);
270			ret = ff_filter_frame(outlink, out);
271			s->frames[s->nb_frames - 1] = NULL;
272			s->nb_frames--;
273			}
274
275			return ret;
276			}
277
278			static const AVFilterPad areverse_inputs[] = {
279			{
280			.name = "default",
281			.type = AVMEDIA_TYPE_AUDIO,
282			.filter_frame = filter_frame,
283			.needs_writable = 1,
284			},
285			{ NULL }
286			};
287
288			static const AVFilterPad areverse_outputs[] = {
289			{
290			.name = "default",
291			.type = AVMEDIA_TYPE_AUDIO,
292			.request_frame = areverse_request_frame,
293			},
294			{ NULL }
295			};
296
297			AVFilter ff_af_areverse = {
298			.name = "areverse",
299			.description = NULL_IF_CONFIG_SMALL("Reverse an audio clip."),
300			.query_formats = query_formats,
301			.priv_size = sizeof(ReverseContext),
302			.init = init,
303			.uninit = uninit,
304			.inputs = areverse_inputs,
305			.outputs = areverse_outputs,
306			};
307
308			#endif /* CONFIG_AREVERSE_FILTER */