FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/dolby_e_parse.c	Lines:	63	101	62.4 %
Date:	2021-04-20 15:25:36	Branches:	25	60	41.7 %


/*
 * Copyright (C) 2017 foo86
 *
 * 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 "get_bits.h"
#include "put_bits.h"
#include "dolby_e.h"

static const uint8_t nb_programs_tab[MAX_PROG_CONF + 1] = {
    2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 8, 1, 2, 3, 3, 4, 5, 6, 1, 2, 3, 4, 1, 1
};

static const uint8_t nb_channels_tab[MAX_PROG_CONF + 1] = {
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8
};

static const uint16_t sample_rate_tab[16] = {
    0, 42965, 43008, 44800, 53706, 53760
};

static int skip_input(DBEContext *s, int nb_words)
{
    if (nb_words > s->input_size) {
        return AVERROR_INVALIDDATA;
    }

    s->input      += nb_words * s->word_bytes;
    s->input_size -= nb_words;
    return 0;
}

static int parse_key(DBEContext *s)
{
    if (s->key_present) {
        const uint8_t *key = s->input;
        int      ret = skip_input(s, 1);
        if (ret < 0)
            return ret;
        return AV_RB24(key) >> 24 - s->word_bits;
    }
    return 0;
}

int ff_dolby_e_convert_input(DBEContext *s, int nb_words, int key)
{
    const uint8_t *src = s->input;
    uint8_t *dst = s->buffer;
    PutBitContext pb;
    int i;

    av_assert0(nb_words <= 1024u);

    if (nb_words > s->input_size) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
        return AVERROR_INVALIDDATA;
    }

    switch (s->word_bits) {
    case 16:
        for (i = 0; i < nb_words; i++, src += 2, dst += 2)
            AV_WB16(dst, AV_RB16(src) ^ key);
        break;
    case 20:
        init_put_bits(&pb, s->buffer, sizeof(s->buffer));
        for (i = 0; i < nb_words; i++, src += 3)
            put_bits(&pb, 20, AV_RB24(src) >> 4 ^ key);
        flush_put_bits(&pb);
        break;
    case 24:
        for (i = 0; i < nb_words; i++, src += 3, dst += 3)
            AV_WB24(dst, AV_RB24(src) ^ key);
        break;
    default:
        av_assert0(0);
    }

    return init_get_bits(&s->gb, s->buffer, nb_words * s->word_bits);
}

int ff_dolby_e_parse_header(DBEContext *s, const uint8_t *buf, int buf_size)
{
    DolbyEHeaderInfo *const header = &s->metadata;
    int hdr, ret, key, mtd_size;

    if (buf_size < 3)
        return AVERROR_INVALIDDATA;

    hdr = AV_RB24(buf);
    if ((hdr & 0xfffffe) == 0x7888e) {
        s->word_bits = 24;
    } else if ((hdr & 0xffffe0) == 0x788e0) {
        s->word_bits = 20;
    } else if ((hdr & 0xfffe00) == 0x78e00) {
        s->word_bits = 16;
    } else {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Invalid frame header\n");
        return AVERROR_INVALIDDATA;
    }

    s->word_bytes  = s->word_bits + 7 >> 3;
    s->input       = buf + s->word_bytes;
    s->input_size  = buf_size / s->word_bytes - 1;
    s->key_present = hdr >> 24 - s->word_bits & 1;

    if ((key = parse_key(s)) < 0)
        return key;
    if ((ret = ff_dolby_e_convert_input(s, 1, key)) < 0)
        return ret;

    skip_bits(&s->gb, 4);
    mtd_size = get_bits(&s->gb, 10);
    if (!mtd_size) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Invalid metadata size\n");
        return AVERROR_INVALIDDATA;
    }

    if ((ret = ff_dolby_e_convert_input(s, mtd_size, key)) < 0)
        return ret;

    skip_bits(&s->gb, 14);
    header->prog_conf = get_bits(&s->gb, 6);
    if (header->prog_conf > MAX_PROG_CONF) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Invalid program configuration\n");
        return AVERROR_INVALIDDATA;
    }

    header->nb_channels = nb_channels_tab[header->prog_conf];
    header->nb_programs = nb_programs_tab[header->prog_conf];

    header->fr_code      = get_bits(&s->gb, 4);
    header->fr_code_orig = get_bits(&s->gb, 4);
    if (!(header->sample_rate = sample_rate_tab[header->fr_code]) ||
        !sample_rate_tab[header->fr_code_orig]) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Invalid frame rate code\n");
        return AVERROR_INVALIDDATA;
    }

    skip_bits_long(&s->gb, 88);
    for (int i = 0; i < header->nb_channels; i++)
        header->ch_size[i] = get_bits(&s->gb, 10);
    header->mtd_ext_size = get_bits(&s->gb, 8);
    header->meter_size   = get_bits(&s->gb, 8);

    skip_bits_long(&s->gb, 10 * header->nb_programs);
    for (int i = 0; i < header->nb_channels; i++) {
        header->rev_id[i]     = get_bits(&s->gb,  4);
        skip_bits1(&s->gb);
        header->begin_gain[i] = get_bits(&s->gb, 10);
        header->end_gain[i]   = get_bits(&s->gb, 10);
    }

    if (get_bits_left(&s->gb) < 0) {
        if (s->avctx)
            av_log(s->avctx, AV_LOG_ERROR, "Read past end of metadata\n");
        return AVERROR_INVALIDDATA;
    }

    return skip_input(s, mtd_size + 1);
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Copyright (C) 2017 foo86
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 "get_bits.h"
22			#include "put_bits.h"
23			#include "dolby_e.h"
24
25			static const uint8_t nb_programs_tab[MAX_PROG_CONF + 1] = {
26			2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 8, 1, 2, 3, 3, 4, 5, 6, 1, 2, 3, 4, 1, 1
27			};
28
29			static const uint8_t nb_channels_tab[MAX_PROG_CONF + 1] = {
30			8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8
31			};
32
33			static const uint16_t sample_rate_tab[16] = {
34			0, 42965, 43008, 44800, 53706, 53760
35			};
36
37		1284	static int skip_input(DBEContext *s, int nb_words)
38			{
39	✗✓	1284	if (nb_words > s->input_size) {
40			return AVERROR_INVALIDDATA;
41			}
42
43		1284	s->input += nb_words * s->word_bytes;
44		1284	s->input_size -= nb_words;
45		1284	return 0;
46			}
47
48		642	static int parse_key(DBEContext *s)
49			{
50	✓✗	642	if (s->key_present) {
51		642	const uint8_t *key = s->input;
52		642	int ret = skip_input(s, 1);
53	✗✓	642	if (ret < 0)
54			return ret;
55		642	return AV_RB24(key) >> 24 - s->word_bits;
56			}
57			return 0;
58			}
59
60		4380	int ff_dolby_e_convert_input(DBEContext *s, int nb_words, int key)
61			{
62		4380	const uint8_t *src = s->input;
63		4380	uint8_t *dst = s->buffer;
64			PutBitContext pb;
65			int i;
66
67	✗✓	4380	av_assert0(nb_words <= 1024u);
68
69	✗✓	4380	if (nb_words > s->input_size) {
70			if (s->avctx)
71			av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
72			return AVERROR_INVALIDDATA;
73			}
74
75	✓✗✗✗	4380	switch (s->word_bits) {
76		4380	case 16:
77	✓✓	951144	for (i = 0; i < nb_words; i++, src += 2, dst += 2)
78		946764	AV_WB16(dst, AV_RB16(src) ^ key);
79		4380	break;
80			case 20:
81			init_put_bits(&pb, s->buffer, sizeof(s->buffer));
82			for (i = 0; i < nb_words; i++, src += 3)
83			put_bits(&pb, 20, AV_RB24(src) >> 4 ^ key);
84			flush_put_bits(&pb);
85			break;
86			case 24:
87			for (i = 0; i < nb_words; i++, src += 3, dst += 3)
88			AV_WB24(dst, AV_RB24(src) ^ key);
89			break;
90			default:
91			av_assert0(0);
92			}
93
94		4380	return init_get_bits(&s->gb, s->buffer, nb_words * s->word_bits);
95			}
96
97		643	int ff_dolby_e_parse_header(DBEContext s, const uint8_t buf, int buf_size)
98			{
99		643	DolbyEHeaderInfo *const header = &s->metadata;
100			int hdr, ret, key, mtd_size;
101
102	✓✓	643	if (buf_size < 3)
103		1	return AVERROR_INVALIDDATA;
104
105		642	hdr = AV_RB24(buf);
106	✗✓	642	if ((hdr & 0xfffffe) == 0x7888e) {
107			s->word_bits = 24;
108	✗✓	642	} else if ((hdr & 0xffffe0) == 0x788e0) {
109			s->word_bits = 20;
110	✓✗	642	} else if ((hdr & 0xfffe00) == 0x78e00) {
111		642	s->word_bits = 16;
112			} else {
113			if (s->avctx)
114			av_log(s->avctx, AV_LOG_ERROR, "Invalid frame header\n");
115			return AVERROR_INVALIDDATA;
116			}
117
118		642	s->word_bytes = s->word_bits + 7 >> 3;
119		642	s->input = buf + s->word_bytes;
120		642	s->input_size = buf_size / s->word_bytes - 1;
121		642	s->key_present = hdr >> 24 - s->word_bits & 1;
122
123	✗✓	642	if ((key = parse_key(s)) < 0)
124			return key;
125	✗✓	642	if ((ret = ff_dolby_e_convert_input(s, 1, key)) < 0)
126			return ret;
127
128		642	skip_bits(&s->gb, 4);
129		642	mtd_size = get_bits(&s->gb, 10);
130	✗✓	642	if (!mtd_size) {
131			if (s->avctx)
132			av_log(s->avctx, AV_LOG_ERROR, "Invalid metadata size\n");
133			return AVERROR_INVALIDDATA;
134			}
135
136	✗✓	642	if ((ret = ff_dolby_e_convert_input(s, mtd_size, key)) < 0)
137			return ret;
138
139		642	skip_bits(&s->gb, 14);
140		642	header->prog_conf = get_bits(&s->gb, 6);
141	✗✓	642	if (header->prog_conf > MAX_PROG_CONF) {
142			if (s->avctx)
143			av_log(s->avctx, AV_LOG_ERROR, "Invalid program configuration\n");
144			return AVERROR_INVALIDDATA;
145			}
146
147		642	header->nb_channels = nb_channels_tab[header->prog_conf];
148		642	header->nb_programs = nb_programs_tab[header->prog_conf];
149
150		642	header->fr_code = get_bits(&s->gb, 4);
151		642	header->fr_code_orig = get_bits(&s->gb, 4);
152	✓✗	642	if (!(header->sample_rate = sample_rate_tab[header->fr_code]) \|\|
153	✗✓	642	!sample_rate_tab[header->fr_code_orig]) {
154			if (s->avctx)
155			av_log(s->avctx, AV_LOG_ERROR, "Invalid frame rate code\n");
156			return AVERROR_INVALIDDATA;
157			}
158
159		642	skip_bits_long(&s->gb, 88);
160	✓✓	4494	for (int i = 0; i < header->nb_channels; i++)
161		3852	header->ch_size[i] = get_bits(&s->gb, 10);
162		642	header->mtd_ext_size = get_bits(&s->gb, 8);
163		642	header->meter_size = get_bits(&s->gb, 8);
164
165		642	skip_bits_long(&s->gb, 10 * header->nb_programs);
166	✓✓	4494	for (int i = 0; i < header->nb_channels; i++) {
167		3852	header->rev_id[i] = get_bits(&s->gb, 4);
168		3852	skip_bits1(&s->gb);
169		3852	header->begin_gain[i] = get_bits(&s->gb, 10);
170		3852	header->end_gain[i] = get_bits(&s->gb, 10);
171			}
172
173	✗✓	642	if (get_bits_left(&s->gb) < 0) {
174			if (s->avctx)
175			av_log(s->avctx, AV_LOG_ERROR, "Read past end of metadata\n");
176			return AVERROR_INVALIDDATA;
177			}
178
179		642	return skip_input(s, mtd_size + 1);
180			}