FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/framequeue.c	Lines:	78	80	97.5 %
Date:	2020-09-25 23:16:12	Branches:	22	26	84.6 %


/*
 * Generic frame queue
 * Copyright (c) 2016 Nicolas George
 *
 * 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/avassert.h"
#include "framequeue.h"

static inline FFFrameBucket *bucket(FFFrameQueue *fq, size_t idx)
{
    return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
}

void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
{
}

static void check_consistency(FFFrameQueue *fq)
{
#if defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
    uint64_t nb_samples = 0;
    size_t i;

    av_assert0(fq->queued == fq->total_frames_head - fq->total_frames_tail);
    for (i = 0; i < fq->queued; i++)
        nb_samples += bucket(fq, i)->frame->nb_samples;
    av_assert0(nb_samples == fq->total_samples_head - fq->total_samples_tail);
#endif
}

void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
{
    fq->queue = &fq->first_bucket;
    fq->allocated = 1;
}

void ff_framequeue_free(FFFrameQueue *fq)
{
    while (fq->queued) {
        AVFrame *frame = ff_framequeue_take(fq);
        av_frame_free(&frame);
    }
    if (fq->queue != &fq->first_bucket)
        av_freep(&fq->queue);
}

int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
{
    FFFrameBucket *b;

    check_consistency(fq);
    if (fq->queued == fq->allocated) {
        if (fq->allocated == 1) {
            size_t na = 8;
            FFFrameBucket *nq = av_realloc_array(NULL, na, sizeof(*nq));
            if (!nq)
                return AVERROR(ENOMEM);
            nq[0] = fq->queue[0];
            fq->queue = nq;
            fq->allocated = na;
        } else {
            size_t na = fq->allocated << 1;
            FFFrameBucket *nq = av_realloc_array(fq->queue, na, sizeof(*nq));
            if (!nq)
                return AVERROR(ENOMEM);
            if (fq->tail + fq->queued > fq->allocated)
                memmove(nq + fq->allocated, nq,
                        (fq->tail + fq->queued - fq->allocated) * sizeof(*nq));
            fq->queue = nq;
            fq->allocated = na;
        }
    }
    b = bucket(fq, fq->queued);
    b->frame = frame;
    fq->queued++;
    fq->total_frames_head++;
    fq->total_samples_head += frame->nb_samples;
    check_consistency(fq);
    return 0;
}

AVFrame *ff_framequeue_take(FFFrameQueue *fq)
{
    FFFrameBucket *b;

    check_consistency(fq);
    av_assert1(fq->queued);
    b = bucket(fq, 0);
    fq->queued--;
    fq->tail++;
    fq->tail &= fq->allocated - 1;
    fq->total_frames_tail++;
    fq->total_samples_tail += b->frame->nb_samples;
    fq->samples_skipped = 0;
    check_consistency(fq);
    return b->frame;
}

AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
{
    FFFrameBucket *b;

    check_consistency(fq);
    av_assert1(idx < fq->queued);
    b = bucket(fq, idx);
    check_consistency(fq);
    return b->frame;
}

void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
{
    FFFrameBucket *b;
    size_t bytes;
    int planar, planes, i;

    check_consistency(fq);
    av_assert1(fq->queued);
    b = bucket(fq, 0);
    av_assert1(samples < b->frame->nb_samples);
    planar = av_sample_fmt_is_planar(b->frame->format);
    planes = planar ? b->frame->channels : 1;
    bytes = samples * av_get_bytes_per_sample(b->frame->format);
    if (!planar)
        bytes *= b->frame->channels;
    if (b->frame->pts != AV_NOPTS_VALUE)
        b->frame->pts += av_rescale_q(samples, av_make_q(1, b->frame->sample_rate), time_base);
    b->frame->nb_samples -= samples;
    b->frame->linesize[0] -= bytes;
    for (i = 0; i < planes; i++)
        b->frame->extended_data[i] += bytes;
    for (i = 0; i < planes && i < AV_NUM_DATA_POINTERS; i++)
        b->frame->data[i] = b->frame->extended_data[i];
    fq->total_samples_tail += samples;
    fq->samples_skipped = 1;
    ff_framequeue_update_peeked(fq, 0);
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Generic frame queue
3			* Copyright (c) 2016 Nicolas George
4			*
5			* This file is part of FFmpeg.
6			*
7			* FFmpeg is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU Lesser General Public License
9			* as published by the Free Software Foundation; either
10			* version 2.1 of the License, or (at your option) any later version.
11			*
12			* FFmpeg is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU Lesser General Public License for more details.
16			*
17			* You should have received a copy of the GNU Lesser General Public License
18			* along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20			*/
21
22			#include "libavutil/avassert.h"
23			#include "framequeue.h"
24
25		3029925	static inline FFFrameBucket bucket(FFFrameQueue fq, size_t idx)
26			{
27		3029925	return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
28			}
29
30		6001	void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
31			{
32		6001	}
33
34		6007030	static void check_consistency(FFFrameQueue *fq)
35			{
36			#if defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
37			uint64_t nb_samples = 0;
38			size_t i;
39
40			av_assert0(fq->queued == fq->total_frames_head - fq->total_frames_tail);
41			for (i = 0; i < fq->queued; i++)
42			nb_samples += bucket(fq, i)->frame->nb_samples;
43			av_assert0(nb_samples == fq->total_samples_head - fq->total_samples_tail);
44			#endif
45		6007030	}
46
47		23736	void ff_framequeue_init(FFFrameQueue fq, FFFrameQueueGlobal fqg)
48			{
49		23736	fq->queue = &fq->first_bucket;
50		23736	fq->allocated = 1;
51		23736	}
52
53		23868	void ff_framequeue_free(FFFrameQueue *fq)
54			{
55	✓✓	23906	while (fq->queued) {
56		38	AVFrame *frame = ff_framequeue_take(fq);
57		38	av_frame_free(&frame);
58			}
59	✓✓	23868	if (fq->queue != &fq->first_bucket)
60		330	av_freep(&fq->queue);
61		23868	}
62
63		1414045	int ff_framequeue_add(FFFrameQueue fq, AVFrame frame)
64			{
65			FFFrameBucket *b;
66
67		1414045	check_consistency(fq);
68	✓✓	1414045	if (fq->queued == fq->allocated) {
69	✓✓	313	if (fq->allocated == 1) {
70		198	size_t na = 8;
71		198	FFFrameBucket nq = av_realloc_array(NULL, na, sizeof(nq));
72	✗✓	198	if (!nq)
73			return AVERROR(ENOMEM);
74		198	nq[0] = fq->queue[0];
75		198	fq->queue = nq;
76		198	fq->allocated = na;
77			} else {
78		115	size_t na = fq->allocated << 1;
79		115	FFFrameBucket nq = av_realloc_array(fq->queue, na, sizeof(nq));
80	✗✓	115	if (!nq)
81			return AVERROR(ENOMEM);
82	✓✓	115	if (fq->tail + fq->queued > fq->allocated)
83		10	memmove(nq + fq->allocated, nq,
84		10	(fq->tail + fq->queued - fq->allocated) * sizeof(*nq));
85		115	fq->queue = nq;
86		115	fq->allocated = na;
87			}
88			}
89		1414045	b = bucket(fq, fq->queued);
90		1414045	b->frame = frame;
91		1414045	fq->queued++;
92		1414045	fq->total_frames_head++;
93		1414045	fq->total_samples_head += frame->nb_samples;
94		1414045	check_consistency(fq);
95		1414045	return 0;
96			}
97
98		1414045	AVFrame ff_framequeue_take(FFFrameQueue fq)
99			{
100			FFFrameBucket *b;
101
102		1414045	check_consistency(fq);
103			av_assert1(fq->queued);
104		1414045	b = bucket(fq, 0);
105		1414045	fq->queued--;
106		1414045	fq->tail++;
107		1414045	fq->tail &= fq->allocated - 1;
108		1414045	fq->total_frames_tail++;
109		1414045	fq->total_samples_tail += b->frame->nb_samples;
110		1414045	fq->samples_skipped = 0;
111		1414045	check_consistency(fq);
112		1414045	return b->frame;
113			}
114
115		149015	AVFrame ff_framequeue_peek(FFFrameQueue fq, size_t idx)
116			{
117			FFFrameBucket *b;
118
119		149015	check_consistency(fq);
120			av_assert1(idx < fq->queued);
121		149015	b = bucket(fq, idx);
122		149015	check_consistency(fq);
123		149015	return b->frame;
124			}
125
126		52820	void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
127			{
128			FFFrameBucket *b;
129			size_t bytes;
130			int planar, planes, i;
131
132		52820	check_consistency(fq);
133			av_assert1(fq->queued);
134		52820	b = bucket(fq, 0);
135			av_assert1(samples < b->frame->nb_samples);
136		52820	planar = av_sample_fmt_is_planar(b->frame->format);
137	✓✓	52820	planes = planar ? b->frame->channels : 1;
138		52820	bytes = samples * av_get_bytes_per_sample(b->frame->format);
139	✓✓	52820	if (!planar)
140		27534	bytes *= b->frame->channels;
141	✓✗	52820	if (b->frame->pts != AV_NOPTS_VALUE)
142		52820	b->frame->pts += av_rescale_q(samples, av_make_q(1, b->frame->sample_rate), time_base);
143		52820	b->frame->nb_samples -= samples;
144		52820	b->frame->linesize[0] -= bytes;
145	✓✓	131177	for (i = 0; i < planes; i++)
146		78357	b->frame->extended_data[i] += bytes;
147	✓✓✓✗	131177	for (i = 0; i < planes && i < AV_NUM_DATA_POINTERS; i++)
148		78357	b->frame->data[i] = b->frame->extended_data[i];
149		52820	fq->total_samples_tail += samples;
150		52820	fq->samples_skipped = 1;
151		52820	ff_framequeue_update_peeked(fq, 0);
152		52820	}