FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/vp9_superframe_bsf.c	Lines:	34	102	33.3 %
Date:	2020-10-23 17:01:47	Branches:	23	69	33.3 %


/*
 * Vp9 invisible (alt-ref) frame to superframe merge bitstream filter
 * Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
 *
 * 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 "bsf.h"
#include "bsf_internal.h"
#include "get_bits.h"

#define MAX_CACHE 8
typedef struct VP9BSFContext {
    int n_cache;
    AVPacket *cache[MAX_CACHE];
} VP9BSFContext;

static void stats(AVPacket * const *in, int n_in,
                  unsigned *_max, unsigned *_sum)
{
    int n;
    unsigned max = 0, sum = 0;

    for (n = 0; n < n_in; n++) {
        unsigned sz = in[n]->size;

        if (sz > max)
            max = sz;
        sum += sz;
    }

    *_max = max;
    *_sum = sum;
}

static int merge_superframe(AVPacket * const *in, int n_in, AVPacket *out)
{
    unsigned max, sum, mag, marker, n, sz;
    uint8_t *ptr;
    int res;

    stats(in, n_in, &max, &sum);
    mag = av_log2(max) >> 3;
    marker = 0xC0 + (mag << 3) + (n_in - 1);
    sz = sum + 2 + (mag + 1) * n_in;
    res = av_new_packet(out, sz);
    if (res < 0)
        return res;
    ptr = out->data;
    for (n = 0; n < n_in; n++) {
        memcpy(ptr, in[n]->data, in[n]->size);
        ptr += in[n]->size;
    }

#define wloop(mag, wr) \
    do { \
        for (n = 0; n < n_in; n++) { \
            wr; \
            ptr += mag + 1; \
        } \
    } while (0)

    // write superframe with marker 110[mag:2][nframes:3]
    *ptr++ = marker;
    switch (mag) {
    case 0:
        wloop(mag, *ptr = in[n]->size);
        break;
    case 1:
        wloop(mag, AV_WL16(ptr, in[n]->size));
        break;
    case 2:
        wloop(mag, AV_WL24(ptr, in[n]->size));
        break;
    case 3:
        wloop(mag, AV_WL32(ptr, in[n]->size));
        break;
    }
    *ptr++ = marker;
    av_assert0(ptr == &out->data[out->size]);

    return 0;
}

static int vp9_superframe_filter(AVBSFContext *ctx, AVPacket *pkt)
{
    GetBitContext gb;
    VP9BSFContext *s = ctx->priv_data;
    int res, invisible, profile, marker, uses_superframe_syntax = 0, n;

    res = ff_bsf_get_packet_ref(ctx, pkt);
    if (res < 0)
        return res;

    marker = pkt->data[pkt->size - 1];
    if ((marker & 0xe0) == 0xc0) {
        int nbytes = 1 + ((marker >> 3) & 0x3);
        int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;

        uses_superframe_syntax = pkt->size >= idx_sz && pkt->data[pkt->size - idx_sz] == marker;
    }

    if ((res = init_get_bits8(&gb, pkt->data, pkt->size)) < 0)
        goto done;

    get_bits(&gb, 2); // frame marker
    profile  = get_bits1(&gb);
    profile |= get_bits1(&gb) << 1;
    if (profile == 3) profile += get_bits1(&gb);

    if (get_bits1(&gb)) {
        invisible = 0;
    } else {
        get_bits1(&gb); // keyframe
        invisible = !get_bits1(&gb);
    }

    if (uses_superframe_syntax && s->n_cache > 0) {
        av_log(ctx, AV_LOG_ERROR,
               "Mixing of superframe syntax and naked VP9 frames not supported\n");
        res = AVERROR(ENOSYS);
        goto done;
    } else if ((!invisible || uses_superframe_syntax) && !s->n_cache) {
        // passthrough
        return 0;
    } else if (s->n_cache + 1 >= MAX_CACHE) {
        av_log(ctx, AV_LOG_ERROR,
               "Too many invisible frames\n");
        res = AVERROR_INVALIDDATA;
        goto done;
    }

    av_packet_move_ref(s->cache[s->n_cache++], pkt);

    if (invisible) {
        return AVERROR(EAGAIN);
    }
    av_assert0(s->n_cache > 0);

    // build superframe
    if ((res = merge_superframe(s->cache, s->n_cache, pkt)) < 0)
        goto done;

    res = av_packet_copy_props(pkt, s->cache[s->n_cache - 1]);
    if (res < 0)
        goto done;

    for (n = 0; n < s->n_cache; n++)
        av_packet_unref(s->cache[n]);
    s->n_cache = 0;

done:
    if (res < 0)
        av_packet_unref(pkt);
    return res;
}

static int vp9_superframe_init(AVBSFContext *ctx)
{
    VP9BSFContext *s = ctx->priv_data;
    int n;

    // alloc cache packets
    for (n = 0; n < MAX_CACHE; n++) {
        s->cache[n] = av_packet_alloc();
        if (!s->cache[n])
            return AVERROR(ENOMEM);
    }

    return 0;
}

static void vp9_superframe_flush(AVBSFContext *ctx)
{
    VP9BSFContext *s = ctx->priv_data;
    int n;

    // unref cached data
    for (n = 0; n < s->n_cache; n++)
        av_packet_unref(s->cache[n]);
    s->n_cache = 0;
}

static void vp9_superframe_close(AVBSFContext *ctx)
{
    VP9BSFContext *s = ctx->priv_data;
    int n;

    // free cached data
    for (n = 0; n < MAX_CACHE; n++)
        av_packet_free(&s->cache[n]);
}

static const enum AVCodecID codec_ids[] = {
    AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
};

const AVBitStreamFilter ff_vp9_superframe_bsf = {
    .name           = "vp9_superframe",
    .priv_data_size = sizeof(VP9BSFContext),
    .filter         = vp9_superframe_filter,
    .init           = vp9_superframe_init,
    .flush          = vp9_superframe_flush,
    .close          = vp9_superframe_close,
    .codec_ids      = codec_ids,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Vp9 invisible (alt-ref) frame to superframe merge bitstream filter
3			* Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
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
9			* License 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 GNU
15			* Lesser General Public License for more details.
16			*
17			* You should have received a copy of the GNU Lesser General Public
18			* License along with FFmpeg; if not, write to the Free Software
19			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20			*/
21
22			#include "libavutil/avassert.h"
23
24			#include "bsf.h"
25			#include "bsf_internal.h"
26			#include "get_bits.h"
27
28			#define MAX_CACHE 8
29			typedef struct VP9BSFContext {
30			int n_cache;
31			AVPacket *cache[MAX_CACHE];
32			} VP9BSFContext;
33
34			static void stats(AVPacket * const *in, int n_in,
35			unsigned _max, unsigned _sum)
36			{
37			int n;
38			unsigned max = 0, sum = 0;
39
40			for (n = 0; n < n_in; n++) {
41			unsigned sz = in[n]->size;
42
43			if (sz > max)
44			max = sz;
45			sum += sz;
46			}
47
48			*_max = max;
49			*_sum = sum;
50			}
51
52			static int merge_superframe(AVPacket * const in, int n_in, AVPacket out)
53			{
54			unsigned max, sum, mag, marker, n, sz;
55			uint8_t *ptr;
56			int res;
57
58			stats(in, n_in, &max, &sum);
59			mag = av_log2(max) >> 3;
60			marker = 0xC0 + (mag << 3) + (n_in - 1);
61			sz = sum + 2 + (mag + 1) * n_in;
62			res = av_new_packet(out, sz);
63			if (res < 0)
64			return res;
65			ptr = out->data;
66			for (n = 0; n < n_in; n++) {
67			memcpy(ptr, in[n]->data, in[n]->size);
68			ptr += in[n]->size;
69			}
70
71			#define wloop(mag, wr) \
72			do { \
73			for (n = 0; n < n_in; n++) { \
74			wr; \
75			ptr += mag + 1; \
76			} \
77			} while (0)
78
79			// write superframe with marker 110[mag:2][nframes:3]
80			*ptr++ = marker;
81			switch (mag) {
82			case 0:
83			wloop(mag, *ptr = in[n]->size);
84			break;
85			case 1:
86			wloop(mag, AV_WL16(ptr, in[n]->size));
87			break;
88			case 2:
89			wloop(mag, AV_WL24(ptr, in[n]->size));
90			break;
91			case 3:
92			wloop(mag, AV_WL32(ptr, in[n]->size));
93			break;
94			}
95			*ptr++ = marker;
96			av_assert0(ptr == &out->data[out->size]);
97
98			return 0;
99			}
100
101		481	static int vp9_superframe_filter(AVBSFContext ctx, AVPacket pkt)
102			{
103			GetBitContext gb;
104		481	VP9BSFContext *s = ctx->priv_data;
105		481	int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
106
107		481	res = ff_bsf_get_packet_ref(ctx, pkt);
108	✓✓	481	if (res < 0)
109		248	return res;
110
111		233	marker = pkt->data[pkt->size - 1];
112	✓✓	233	if ((marker & 0xe0) == 0xc0) {
113		16	int nbytes = 1 + ((marker >> 3) & 0x3);
114		16	int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
115
116	✓✗✓✗	16	uses_superframe_syntax = pkt->size >= idx_sz && pkt->data[pkt->size - idx_sz] == marker;
117			}
118
119	✗✓	233	if ((res = init_get_bits8(&gb, pkt->data, pkt->size)) < 0)
120			goto done;
121
122		233	get_bits(&gb, 2); // frame marker
123		233	profile = get_bits1(&gb);
124		233	profile \|= get_bits1(&gb) << 1;
125	✓✓	233	if (profile == 3) profile += get_bits1(&gb);
126
127	✓✓	233	if (get_bits1(&gb)) {
128		14	invisible = 0;
129			} else {
130		219	get_bits1(&gb); // keyframe
131		219	invisible = !get_bits1(&gb);
132			}
133
134	✓✓✗✓	233	if (uses_superframe_syntax && s->n_cache > 0) {
135			av_log(ctx, AV_LOG_ERROR,
136			"Mixing of superframe syntax and naked VP9 frames not supported\n");
137			res = AVERROR(ENOSYS);
138			goto done;
139	✓✓✓✗ ✓✗	233	} else if ((!invisible \|\| uses_superframe_syntax) && !s->n_cache) {
140			// passthrough
141		233	return 0;
142			} else if (s->n_cache + 1 >= MAX_CACHE) {
143			av_log(ctx, AV_LOG_ERROR,
144			"Too many invisible frames\n");
145			res = AVERROR_INVALIDDATA;
146			goto done;
147			}
148
149			av_packet_move_ref(s->cache[s->n_cache++], pkt);
150
151			if (invisible) {
152			return AVERROR(EAGAIN);
153			}
154			av_assert0(s->n_cache > 0);
155
156			// build superframe
157			if ((res = merge_superframe(s->cache, s->n_cache, pkt)) < 0)
158			goto done;
159
160			res = av_packet_copy_props(pkt, s->cache[s->n_cache - 1]);
161			if (res < 0)
162			goto done;
163
164			for (n = 0; n < s->n_cache; n++)
165			av_packet_unref(s->cache[n]);
166			s->n_cache = 0;
167
168			done:
169			if (res < 0)
170			av_packet_unref(pkt);
171			return res;
172			}
173
174		15	static int vp9_superframe_init(AVBSFContext *ctx)
175			{
176		15	VP9BSFContext *s = ctx->priv_data;
177			int n;
178
179			// alloc cache packets
180	✓✓	135	for (n = 0; n < MAX_CACHE; n++) {
181		120	s->cache[n] = av_packet_alloc();
182	✗✓	120	if (!s->cache[n])
183			return AVERROR(ENOMEM);
184			}
185
186		15	return 0;
187			}
188
189			static void vp9_superframe_flush(AVBSFContext *ctx)
190			{
191			VP9BSFContext *s = ctx->priv_data;
192			int n;
193
194			// unref cached data
195			for (n = 0; n < s->n_cache; n++)
196			av_packet_unref(s->cache[n]);
197			s->n_cache = 0;
198			}
199
200		15	static void vp9_superframe_close(AVBSFContext *ctx)
201			{
202		15	VP9BSFContext *s = ctx->priv_data;
203			int n;
204
205			// free cached data
206	✓✓	135	for (n = 0; n < MAX_CACHE; n++)
207		120	av_packet_free(&s->cache[n]);
208		15	}
209
210			static const enum AVCodecID codec_ids[] = {
211			AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
212			};
213
214			const AVBitStreamFilter ff_vp9_superframe_bsf = {
215			.name = "vp9_superframe",
216			.priv_data_size = sizeof(VP9BSFContext),
217			.filter = vp9_superframe_filter,
218			.init = vp9_superframe_init,
219			.flush = vp9_superframe_flush,
220			.close = vp9_superframe_close,
221			.codec_ids = codec_ids,
222			};