FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/hevc_mp4toannexb_bsf.c	Lines:	70	94	74.5 %
Date:	2020-11-28 20:53:16	Branches:	39	60	65.0 %


/*
 * HEVC MP4 to Annex B byte stream format filter
 * copyright (c) 2015 Anton Khirnov
 *
 * 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 <string.h>

#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"

#include "avcodec.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "bytestream.h"
#include "hevc.h"

#define MIN_HEVCC_LENGTH 23

typedef struct HEVCBSFContext {
    uint8_t  length_size;
    int      extradata_parsed;
} HEVCBSFContext;

static int hevc_extradata_to_annexb(AVBSFContext *ctx)
{
    GetByteContext gb;
    int length_size, num_arrays, i, j;
    int ret = 0;

    uint8_t *new_extradata = NULL;
    size_t   new_extradata_size = 0;

    bytestream2_init(&gb, ctx->par_in->extradata, ctx->par_in->extradata_size);

    bytestream2_skip(&gb, 21);
    length_size = (bytestream2_get_byte(&gb) & 3) + 1;
    num_arrays  = bytestream2_get_byte(&gb);

    for (i = 0; i < num_arrays; i++) {
        int type = bytestream2_get_byte(&gb) & 0x3f;
        int cnt  = bytestream2_get_be16(&gb);

        if (!(type == HEVC_NAL_VPS || type == HEVC_NAL_SPS || type == HEVC_NAL_PPS ||
              type == HEVC_NAL_SEI_PREFIX || type == HEVC_NAL_SEI_SUFFIX)) {
            av_log(ctx, AV_LOG_ERROR, "Invalid NAL unit type in extradata: %d\n",
                   type);
            ret = AVERROR_INVALIDDATA;
            goto fail;
        }

        for (j = 0; j < cnt; j++) {
            int nalu_len = bytestream2_get_be16(&gb);

            if (4 + AV_INPUT_BUFFER_PADDING_SIZE + nalu_len > SIZE_MAX - new_extradata_size) {
                ret = AVERROR_INVALIDDATA;
                goto fail;
            }
            ret = av_reallocp(&new_extradata, new_extradata_size + nalu_len + 4 + AV_INPUT_BUFFER_PADDING_SIZE);
            if (ret < 0)
                goto fail;

            AV_WB32(new_extradata + new_extradata_size, 1); // add the startcode
            bytestream2_get_buffer(&gb, new_extradata + new_extradata_size + 4, nalu_len);
            new_extradata_size += 4 + nalu_len;
            memset(new_extradata + new_extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
        }
    }

    av_freep(&ctx->par_out->extradata);
    ctx->par_out->extradata      = new_extradata;
    ctx->par_out->extradata_size = new_extradata_size;

    if (!new_extradata_size)
        av_log(ctx, AV_LOG_WARNING, "No parameter sets in the extradata\n");

    return length_size;
fail:
    av_freep(&new_extradata);
    return ret;
}

static int hevc_mp4toannexb_init(AVBSFContext *ctx)
{
    HEVCBSFContext *s = ctx->priv_data;
    int ret;

    if (ctx->par_in->extradata_size < MIN_HEVCC_LENGTH ||
        AV_RB24(ctx->par_in->extradata) == 1           ||
        AV_RB32(ctx->par_in->extradata) == 1) {
        av_log(ctx, AV_LOG_VERBOSE,
               "The input looks like it is Annex B already\n");
    } else {
        ret = hevc_extradata_to_annexb(ctx);
        if (ret < 0)
            return ret;
        s->length_size      = ret;
        s->extradata_parsed = 1;
    }

    return 0;
}

static int hevc_mp4toannexb_filter(AVBSFContext *ctx, AVPacket *out)
{
    HEVCBSFContext *s = ctx->priv_data;
    AVPacket *in;
    GetByteContext gb;

    int got_irap = 0;
    int i, ret = 0;

    ret = ff_bsf_get_packet(ctx, &in);
    if (ret < 0)
        return ret;

    if (!s->extradata_parsed) {
        av_packet_move_ref(out, in);
        av_packet_free(&in);
        return 0;
    }

    bytestream2_init(&gb, in->data, in->size);

    while (bytestream2_get_bytes_left(&gb)) {
        uint32_t nalu_size = 0;
        int      nalu_type;
        int is_irap, add_extradata, extra_size, prev_size;

        if (bytestream2_get_bytes_left(&gb) < s->length_size) {
            ret = AVERROR_INVALIDDATA;
            goto fail;
        }
        for (i = 0; i < s->length_size; i++)
            nalu_size = (nalu_size << 8) | bytestream2_get_byte(&gb);

        if (nalu_size < 2 || nalu_size > bytestream2_get_bytes_left(&gb)) {
            ret = AVERROR_INVALIDDATA;
            goto fail;
        }

        nalu_type = (bytestream2_peek_byte(&gb) >> 1) & 0x3f;

        /* prepend extradata to IRAP frames */
        is_irap       = nalu_type >= 16 && nalu_type <= 23;
        add_extradata = is_irap && !got_irap;
        extra_size    = add_extradata * ctx->par_out->extradata_size;
        got_irap     |= is_irap;

        if (FFMIN(INT_MAX, SIZE_MAX) < 4ULL + nalu_size + extra_size) {
            ret = AVERROR_INVALIDDATA;
            goto fail;
        }

        prev_size = out->size;

        ret = av_grow_packet(out, 4 + nalu_size + extra_size);
        if (ret < 0)
            goto fail;

        if (extra_size)
            memcpy(out->data + prev_size, ctx->par_out->extradata, extra_size);
        AV_WB32(out->data + prev_size + extra_size, 1);
        bytestream2_get_buffer(&gb, out->data + prev_size + 4 + extra_size, nalu_size);
    }

    ret = av_packet_copy_props(out, in);
    if (ret < 0)
        goto fail;

fail:
    if (ret < 0)
        av_packet_unref(out);
    av_packet_free(&in);

    return ret;
}

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

const AVBitStreamFilter ff_hevc_mp4toannexb_bsf = {
    .name           = "hevc_mp4toannexb",
    .priv_data_size = sizeof(HEVCBSFContext),
    .init           = hevc_mp4toannexb_init,
    .filter         = hevc_mp4toannexb_filter,
    .codec_ids      = codec_ids,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* HEVC MP4 to Annex B byte stream format filter
3			* copyright (c) 2015 Anton Khirnov
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 <string.h>
23
24			#include "libavutil/intreadwrite.h"
25			#include "libavutil/mem.h"
26
27			#include "avcodec.h"
28			#include "bsf.h"
29			#include "bsf_internal.h"
30			#include "bytestream.h"
31			#include "hevc.h"
32
33			#define MIN_HEVCC_LENGTH 23
34
35			typedef struct HEVCBSFContext {
36			uint8_t length_size;
37			int extradata_parsed;
38			} HEVCBSFContext;
39
40		1	static int hevc_extradata_to_annexb(AVBSFContext *ctx)
41			{
42			GetByteContext gb;
43			int length_size, num_arrays, i, j;
44		1	int ret = 0;
45
46		1	uint8_t *new_extradata = NULL;
47		1	size_t new_extradata_size = 0;
48
49		1	bytestream2_init(&gb, ctx->par_in->extradata, ctx->par_in->extradata_size);
50
51		1	bytestream2_skip(&gb, 21);
52		1	length_size = (bytestream2_get_byte(&gb) & 3) + 1;
53		1	num_arrays = bytestream2_get_byte(&gb);
54
55	✓✓	4	for (i = 0; i < num_arrays; i++) {
56		3	int type = bytestream2_get_byte(&gb) & 0x3f;
57		3	int cnt = bytestream2_get_be16(&gb);
58
59	✓✓✓✓ ✗✓✗✗ ✗✗	3	if (!(type == HEVC_NAL_VPS \|\| type == HEVC_NAL_SPS \|\| type == HEVC_NAL_PPS \|\|
60			type == HEVC_NAL_SEI_PREFIX \|\| type == HEVC_NAL_SEI_SUFFIX)) {
61			av_log(ctx, AV_LOG_ERROR, "Invalid NAL unit type in extradata: %d\n",
62			type);
63			ret = AVERROR_INVALIDDATA;
64			goto fail;
65			}
66
67	✓✓	6	for (j = 0; j < cnt; j++) {
68		3	int nalu_len = bytestream2_get_be16(&gb);
69
70	✗✓	3	if (4 + AV_INPUT_BUFFER_PADDING_SIZE + nalu_len > SIZE_MAX - new_extradata_size) {
71			ret = AVERROR_INVALIDDATA;
72			goto fail;
73			}
74		3	ret = av_reallocp(&new_extradata, new_extradata_size + nalu_len + 4 + AV_INPUT_BUFFER_PADDING_SIZE);
75	✗✓	3	if (ret < 0)
76			goto fail;
77
78		3	AV_WB32(new_extradata + new_extradata_size, 1); // add the startcode
79		3	bytestream2_get_buffer(&gb, new_extradata + new_extradata_size + 4, nalu_len);
80		3	new_extradata_size += 4 + nalu_len;
81		3	memset(new_extradata + new_extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
82			}
83			}
84
85		1	av_freep(&ctx->par_out->extradata);
86		1	ctx->par_out->extradata = new_extradata;
87		1	ctx->par_out->extradata_size = new_extradata_size;
88
89	✗✓	1	if (!new_extradata_size)
90			av_log(ctx, AV_LOG_WARNING, "No parameter sets in the extradata\n");
91
92		1	return length_size;
93			fail:
94			av_freep(&new_extradata);
95			return ret;
96			}
97
98		1	static int hevc_mp4toannexb_init(AVBSFContext *ctx)
99			{
100		1	HEVCBSFContext *s = ctx->priv_data;
101			int ret;
102
103	✓✗	1	if (ctx->par_in->extradata_size < MIN_HEVCC_LENGTH \|\|
104	✓✗	1	AV_RB24(ctx->par_in->extradata) == 1 \|\|
105	✗✓	1	AV_RB32(ctx->par_in->extradata) == 1) {
106			av_log(ctx, AV_LOG_VERBOSE,
107			"The input looks like it is Annex B already\n");
108			} else {
109		1	ret = hevc_extradata_to_annexb(ctx);
110	✗✓	1	if (ret < 0)
111			return ret;
112		1	s->length_size = ret;
113		1	s->extradata_parsed = 1;
114			}
115
116		1	return 0;
117			}
118
119		97	static int hevc_mp4toannexb_filter(AVBSFContext ctx, AVPacket out)
120			{
121		97	HEVCBSFContext *s = ctx->priv_data;
122			AVPacket *in;
123			GetByteContext gb;
124
125		97	int got_irap = 0;
126		97	int i, ret = 0;
127
128		97	ret = ff_bsf_get_packet(ctx, &in);
129	✓✓	97	if (ret < 0)
130		49	return ret;
131
132	✗✓	48	if (!s->extradata_parsed) {
133			av_packet_move_ref(out, in);
134			av_packet_free(&in);
135			return 0;
136			}
137
138		48	bytestream2_init(&gb, in->data, in->size);
139
140	✓✓	430	while (bytestream2_get_bytes_left(&gb)) {
141		382	uint32_t nalu_size = 0;
142			int nalu_type;
143			int is_irap, add_extradata, extra_size, prev_size;
144
145	✗✓	382	if (bytestream2_get_bytes_left(&gb) < s->length_size) {
146			ret = AVERROR_INVALIDDATA;
147			goto fail;
148			}
149	✓✓	1910	for (i = 0; i < s->length_size; i++)
150		1528	nalu_size = (nalu_size << 8) \| bytestream2_get_byte(&gb);
151
152	✓✗✗✓	382	if (nalu_size < 2 \|\| nalu_size > bytestream2_get_bytes_left(&gb)) {
153			ret = AVERROR_INVALIDDATA;
154			goto fail;
155			}
156
157		382	nalu_type = (bytestream2_peek_byte(&gb) >> 1) & 0x3f;
158
159			/* prepend extradata to IRAP frames */
160	✓✓✓✓	382	is_irap = nalu_type >= 16 && nalu_type <= 23;
161	✓✓✓✗	382	add_extradata = is_irap && !got_irap;
162		382	extra_size = add_extradata * ctx->par_out->extradata_size;
163		382	got_irap \|= is_irap;
164
165	✗✓	382	if (FFMIN(INT_MAX, SIZE_MAX) < 4ULL + nalu_size + extra_size) {
166			ret = AVERROR_INVALIDDATA;
167			goto fail;
168			}
169
170		382	prev_size = out->size;
171
172		382	ret = av_grow_packet(out, 4 + nalu_size + extra_size);
173	✗✓	382	if (ret < 0)
174			goto fail;
175
176	✓✓	382	if (extra_size)
177		1	memcpy(out->data + prev_size, ctx->par_out->extradata, extra_size);
178		382	AV_WB32(out->data + prev_size + extra_size, 1);
179		382	bytestream2_get_buffer(&gb, out->data + prev_size + 4 + extra_size, nalu_size);
180			}
181
182		48	ret = av_packet_copy_props(out, in);
183	✓✗	48	if (ret < 0)
184			goto fail;
185
186		48	fail:
187	✗✓	48	if (ret < 0)
188			av_packet_unref(out);
189		48	av_packet_free(&in);
190
191		48	return ret;
192			}
193
194			static const enum AVCodecID codec_ids[] = {
195			AV_CODEC_ID_HEVC, AV_CODEC_ID_NONE,
196			};
197
198			const AVBitStreamFilter ff_hevc_mp4toannexb_bsf = {
199			.name = "hevc_mp4toannexb",
200			.priv_data_size = sizeof(HEVCBSFContext),
201			.init = hevc_mp4toannexb_init,
202			.filter = hevc_mp4toannexb_filter,
203			.codec_ids = codec_ids,
204			};