FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/fits.c	Lines:	104	119	87.4 %
Date:	2020-04-02 05:41:20	Branches:	75	107	70.1 %


/*
 * FITS implementation of common functions
 * Copyright (c) 2017 Paras Chadha
 *
 * 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 "avcodec.h"
#include "libavutil/dict.h"
#include "fits.h"

int avpriv_fits_header_init(FITSHeader *header, FITSHeaderState state)
{
    header->state = state;
    header->naxis_index = 0;
    header->blank_found = 0;
    header->pcount = 0;
    header->gcount = 1;
    header->groups = 0;
    header->rgb = 0;
    header->image_extension = 0;
    header->bscale = 1.0;
    header->bzero = 0;
    header->data_min_found = 0;
    header->data_max_found = 0;
    return 0;
}

static int dict_set_if_not_null(AVDictionary ***metadata, char *keyword, char *value)
{
    if (metadata)
        av_dict_set(*metadata, keyword, value, 0);
    return 0;
}

/**
 * Extract keyword and value from a header line (80 bytes) and store them in keyword and value strings respectively
 * @param ptr8 pointer to the data
 * @param keyword pointer to the char array in which keyword is to be stored
 * @param value pointer to the char array in which value is to be stored
 * @return 0 if calculated successfully otherwise AVERROR_INVALIDDATA
 */
static int read_keyword_value(const uint8_t *ptr8, char *keyword, char *value)
{
    int i;

    for (i = 0; i < 8 && ptr8[i] != ' '; i++) {
        keyword[i] = ptr8[i];
    }
    keyword[i] = '\0';

    if (ptr8[8] == '=') {
        i = 10;
        while (i < 80 && ptr8[i] == ' ') {
            i++;
        }

        if (i < 80) {
            *value++ = ptr8[i];
            i++;
            if (ptr8[i-1] == '\'') {
                for (; i < 80 && ptr8[i] != '\''; i++) {
                    *value++ = ptr8[i];
                }
                *value++ = '\'';
            } else if (ptr8[i-1] == '(') {
                for (; i < 80 && ptr8[i] != ')'; i++) {
                    *value++ = ptr8[i];
                }
                *value++ = ')';
            } else {
                for (; i < 80 && ptr8[i] != ' ' && ptr8[i] != '/'; i++) {
                    *value++ = ptr8[i];
                }
            }
        }
    }
    *value = '\0';
    return 0;
}

#define CHECK_KEYWORD(key) \
    if (strcmp(keyword, key)) { \
        av_log(avcl, AV_LOG_ERROR, "expected %s keyword, found %s = %s\n", key, keyword, value); \
        return AVERROR_INVALIDDATA; \
    }

#define CHECK_VALUE(key, val) \
    if (sscanf(value, "%d", &header->val) != 1) { \
        av_log(avcl, AV_LOG_ERROR, "invalid value of %s keyword, %s = %s\n", key, keyword, value); \
        return AVERROR_INVALIDDATA; \
    }

int avpriv_fits_header_parse_line(void *avcl, FITSHeader *header, const uint8_t line[80], AVDictionary ***metadata)
{
    int dim_no, ret;
    int64_t t;
    double d;
    char keyword[10], value[72], c;

    read_keyword_value(line, keyword, value);
    switch (header->state) {
    case STATE_SIMPLE:
        CHECK_KEYWORD("SIMPLE");

        if (value[0] == 'F') {
            av_log(avcl, AV_LOG_WARNING, "not a standard FITS file\n");
        } else if (value[0] != 'T') {
            av_log(avcl, AV_LOG_ERROR, "invalid value of SIMPLE keyword, SIMPLE = %c\n", value[0]);
            return AVERROR_INVALIDDATA;
        }

        header->state = STATE_BITPIX;
        break;
    case STATE_XTENSION:
        CHECK_KEYWORD("XTENSION");

        if (!strcmp(value, "'IMAGE   '")) {
            header->image_extension = 1;
        }

        header->state = STATE_BITPIX;
        break;
    case STATE_BITPIX:
        CHECK_KEYWORD("BITPIX");
        CHECK_VALUE("BITPIX", bitpix);

        switch(header->bitpix) {
        case   8:
        case  16:
        case  32: case -32:
        case  64: case -64: break;
        default:
            av_log(avcl, AV_LOG_ERROR, "invalid value of BITPIX %d\n", header->bitpix); \
            return AVERROR_INVALIDDATA;
        }

        dict_set_if_not_null(metadata, keyword, value);

        header->state = STATE_NAXIS;
        break;
    case STATE_NAXIS:
        CHECK_KEYWORD("NAXIS");
        CHECK_VALUE("NAXIS", naxis);
        dict_set_if_not_null(metadata, keyword, value);

        if (header->naxis) {
            header->state = STATE_NAXIS_N;
        } else {
            header->state = STATE_REST;
        }
        break;
    case STATE_NAXIS_N:
        ret = sscanf(keyword, "NAXIS%d", &dim_no);
        if (ret != 1 || dim_no != header->naxis_index + 1) {
            av_log(avcl, AV_LOG_ERROR, "expected NAXIS%d keyword, found %s = %s\n", header->naxis_index + 1, keyword, value);
            return AVERROR_INVALIDDATA;
        }

        if (sscanf(value, "%d", &header->naxisn[header->naxis_index]) != 1) {
            av_log(avcl, AV_LOG_ERROR, "invalid value of NAXIS%d keyword, %s = %s\n", header->naxis_index + 1, keyword, value);
            return AVERROR_INVALIDDATA;
        }

        dict_set_if_not_null(metadata, keyword, value);
        header->naxis_index++;
        if (header->naxis_index == header->naxis) {
            header->state = STATE_REST;
        }
        break;
    case STATE_REST:
        if (!strcmp(keyword, "BLANK") && sscanf(value, "%"SCNd64"", &t) == 1) {
            header->blank = t;
            header->blank_found = 1;
        } else if (!strcmp(keyword, "BSCALE") && sscanf(value, "%lf", &d) == 1) {
            header->bscale = d;
        } else if (!strcmp(keyword, "BZERO") && sscanf(value, "%lf", &d) == 1) {
            header->bzero = d;
        } else if (!strcmp(keyword, "CTYPE3") && !strncmp(value, "'RGB", 4)) {
            header->rgb = 1;
        } else if (!strcmp(keyword, "DATAMAX") && sscanf(value, "%lf", &d) == 1) {
            header->data_max_found = 1;
            header->data_max = d;
        } else if (!strcmp(keyword, "DATAMIN") && sscanf(value, "%lf", &d) == 1) {
            header->data_min_found = 1;
            header->data_min = d;
        } else if (!strcmp(keyword, "END")) {
            return 1;
        } else if (!strcmp(keyword, "GROUPS") && sscanf(value, "%c", &c) == 1) {
            header->groups = (c == 'T');
        } else if (!strcmp(keyword, "GCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
            header->gcount = t;
        } else if (!strcmp(keyword, "PCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
            header->pcount = t;
        }
        dict_set_if_not_null(metadata, keyword, value);
        break;
    }
    return 0;
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* FITS implementation of common functions
3			* Copyright (c) 2017 Paras Chadha
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 "avcodec.h"
23			#include "libavutil/dict.h"
24			#include "fits.h"
25
26		452	int avpriv_fits_header_init(FITSHeader *header, FITSHeaderState state)
27			{
28		452	header->state = state;
29		452	header->naxis_index = 0;
30		452	header->blank_found = 0;
31		452	header->pcount = 0;
32		452	header->gcount = 1;
33		452	header->groups = 0;
34		452	header->rgb = 0;
35		452	header->image_extension = 0;
36		452	header->bscale = 1.0;
37		452	header->bzero = 0;
38		452	header->data_min_found = 0;
39		452	header->data_max_found = 0;
40		452	return 0;
41			}
42
43		3795	static int dict_set_if_not_null(AVDictionary **metadata, char keyword, char *value)
44			{
45	✓✓	3795	if (metadata)
46		1984	av_dict_set(*metadata, keyword, value, 0);
47		3795	return 0;
48			}
49
50			/**
51			* Extract keyword and value from a header line (80 bytes) and store them in keyword and value strings respectively
52			* @param ptr8 pointer to the data
53			* @param keyword pointer to the char array in which keyword is to be stored
54			* @param value pointer to the char array in which value is to be stored
55			* @return 0 if calculated successfully otherwise AVERROR_INVALIDDATA
56			*/
57		4408	static int read_keyword_value(const uint8_t ptr8, char keyword, char *value)
58			{
59			int i;
60
61	✓✓✓✓	29136	for (i = 0; i < 8 && ptr8[i] != ' '; i++) {
62		24728	keyword[i] = ptr8[i];
63			}
64		4408	keyword[i] = '\0';
65
66	✓✓	4408	if (ptr8[8] == '=') {
67		3823	i = 10;
68	✓✗✓✓	8308	while (i < 80 && ptr8[i] == ' ') {
69		4485	i++;
70			}
71
72	✓✗	3823	if (i < 80) {
73		3823	*value++ = ptr8[i];
74		3823	i++;
75	✓✓	3823	if (ptr8[i-1] == '\'') {
76	✓✗✓✓	9063	for (; i < 80 && ptr8[i] != '\''; i++) {
77		8314	*value++ = ptr8[i];
78			}
79		749	*value++ = '\'';
80	✗✓	3074	} else if (ptr8[i-1] == '(') {
81			for (; i < 80 && ptr8[i] != ')'; i++) {
82			*value++ = ptr8[i];
83			}
84			*value++ = ')';
85			} else {
86	✓✗✓✓ ✓✗	6847	for (; i < 80 && ptr8[i] != ' ' && ptr8[i] != '/'; i++) {
87		3773	*value++ = ptr8[i];
88			}
89			}
90			}
91			}
92		4408	*value = '\0';
93		4408	return 0;
94			}
95
96			#define CHECK_KEYWORD(key) \
97			if (strcmp(keyword, key)) { \
98			av_log(avcl, AV_LOG_ERROR, "expected %s keyword, found %s = %s\n", key, keyword, value); \
99			return AVERROR_INVALIDDATA; \
100			}
101
102			#define CHECK_VALUE(key, val) \
103			if (sscanf(value, "%d", &header->val) != 1) { \
104			av_log(avcl, AV_LOG_ERROR, "invalid value of %s keyword, %s = %s\n", key, keyword, value); \
105			return AVERROR_INVALIDDATA; \
106			}
107
108		4408	int avpriv_fits_header_parse_line(void avcl, FITSHeader header, const uint8_t line[80], AVDictionary ***metadata)
109			{
110			int dim_no, ret;
111			int64_t t;
112			double d;
113			char keyword[10], value[72], c;
114
115		4408	read_keyword_value(line, keyword, value);
116	✓✓✓✓ ✓✓✗	4408	switch (header->state) {
117		22	case STATE_SIMPLE:
118	✗✓	22	CHECK_KEYWORD("SIMPLE");
119
120	✗✓	22	if (value[0] == 'F') {
121			av_log(avcl, AV_LOG_WARNING, "not a standard FITS file\n");
122	✗✓	22	} else if (value[0] != 'T') {
123			av_log(avcl, AV_LOG_ERROR, "invalid value of SIMPLE keyword, SIMPLE = %c\n", value[0]);
124			return AVERROR_INVALIDDATA;
125			}
126
127		22	header->state = STATE_BITPIX;
128		22	break;
129		177	case STATE_XTENSION:
130	✗✓	177	CHECK_KEYWORD("XTENSION");
131
132	✓✓	177	if (!strcmp(value, "'IMAGE '")) {
133		176	header->image_extension = 1;
134			}
135
136		177	header->state = STATE_BITPIX;
137		177	break;
138		414	case STATE_BITPIX:
139	✗✓	414	CHECK_KEYWORD("BITPIX");
140	✗✓	414	CHECK_VALUE("BITPIX", bitpix);
141
142	✓✗	414	switch(header->bitpix) {
143		414	case 8:
144			case 16:
145			case 32: case -32:
146		414	case 64: case -64: break;
147			default:
148			av_log(avcl, AV_LOG_ERROR, "invalid value of BITPIX %d\n", header->bitpix); \
149			return AVERROR_INVALIDDATA;
150			}
151
152		414	dict_set_if_not_null(metadata, keyword, value);
153
154		414	header->state = STATE_NAXIS;
155		414	break;
156		414	case STATE_NAXIS:
157	✗✓	414	CHECK_KEYWORD("NAXIS");
158	✗✓	414	CHECK_VALUE("NAXIS", naxis);
159		414	dict_set_if_not_null(metadata, keyword, value);
160
161	✓✗	414	if (header->naxis) {
162		414	header->state = STATE_NAXIS_N;
163			} else {
164			header->state = STATE_REST;
165			}
166		414	break;
167		1124	case STATE_NAXIS_N:
168		1124	ret = sscanf(keyword, "NAXIS%d", &dim_no);
169	✓✗✗✓	1124	if (ret != 1 \|\| dim_no != header->naxis_index + 1) {
170			av_log(avcl, AV_LOG_ERROR, "expected NAXIS%d keyword, found %s = %s\n", header->naxis_index + 1, keyword, value);
171			return AVERROR_INVALIDDATA;
172			}
173
174	✗✓	1124	if (sscanf(value, "%d", &header->naxisn[header->naxis_index]) != 1) {
175			av_log(avcl, AV_LOG_ERROR, "invalid value of NAXIS%d keyword, %s = %s\n", header->naxis_index + 1, keyword, value);
176			return AVERROR_INVALIDDATA;
177			}
178
179		1124	dict_set_if_not_null(metadata, keyword, value);
180		1124	header->naxis_index++;
181	✓✓	1124	if (header->naxis_index == header->naxis) {
182		414	header->state = STATE_REST;
183			}
184		1124	break;
185		2257	case STATE_REST:
186	✓✓✓✗	2257	if (!strcmp(keyword, "BLANK") && sscanf(value, "%"SCNd64"", &t) == 1) {
187		3	header->blank = t;
188		3	header->blank_found = 1;
189	✓✓✓✗	2254	} else if (!strcmp(keyword, "BSCALE") && sscanf(value, "%lf", &d) == 1) {
190		6	header->bscale = d;
191	✓✓✓✗	2248	} else if (!strcmp(keyword, "BZERO") && sscanf(value, "%lf", &d) == 1) {
192		165	header->bzero = d;
193	✓✓✓✓	2083	} else if (!strcmp(keyword, "CTYPE3") && !strncmp(value, "'RGB", 4)) {
194		296	header->rgb = 1;
195	✓✓✓✓	1787	} else if (!strcmp(keyword, "DATAMAX") && sscanf(value, "%lf", &d) == 1) {
196		3	header->data_max_found = 1;
197		3	header->data_max = d;
198	✓✓✓✓	1784	} else if (!strcmp(keyword, "DATAMIN") && sscanf(value, "%lf", &d) == 1) {
199		3	header->data_min_found = 1;
200		3	header->data_min = d;
201	✓✓	1781	} else if (!strcmp(keyword, "END")) {
202		414	return 1;
203	✗✓✗✗	1367	} else if (!strcmp(keyword, "GROUPS") && sscanf(value, "%c", &c) == 1) {
204			header->groups = (c == 'T');
205	✓✓✓✗	1367	} else if (!strcmp(keyword, "GCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
206		349	header->gcount = t;
207	✓✓✓✗	1018	} else if (!strcmp(keyword, "PCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
208		349	header->pcount = t;
209			}
210		1843	dict_set_if_not_null(metadata, keyword, value);
211		1843	break;
212			}
213		3994	return 0;
214			}