Head

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/hevc_mp4toannexb_bsf.c	Lines:	67	88	76.1 %
Date:	2020-01-27 20:17:04	Branches:	35	54	64.8 %


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

        for (i = 0; i < s->length_size; i++)
            nalu_size = (nalu_size << 8) | bytestream2_get_byte(&gb);

        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.1)

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