GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/fits.c Lines: 107 125 85.6 %
Date: 2021-04-19 06:27:07 Branches: 80 117 68.4 %

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
4597
static int dict_set_if_not_null(AVDictionary ***metadata, char *keyword, char *value)
44
{
45
4597
    if (metadata)
46
2398
        av_dict_set(*metadata, keyword, value, 0);
47
4597
    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
5210
static int read_keyword_value(const uint8_t *ptr8, char *keyword, char *value)
58
{
59
    int i;
60
61

35552
    for (i = 0; i < 8 && ptr8[i] != ' '; i++) {
62
30342
        keyword[i] = ptr8[i];
63
    }
64
5210
    keyword[i] = '\0';
65
66
5210
    if (ptr8[8] == '=') {
67
4625
        i = 10;
68

9110
        while (i < 80 && ptr8[i] == ' ') {
69
4485
            i++;
70
        }
71
72
4625
        if (i < 80) {
73
4625
            *value++ = ptr8[i];
74
4625
            i++;
75
4625
            if (ptr8[i-1] == '\'') {
76

9063
                for (; i < 80 && ptr8[i] != '\''; i++) {
77
8314
                    *value++ = ptr8[i];
78
                }
79
749
                *value++ = '\'';
80
3876
            } else if (ptr8[i-1] == '(') {
81
                for (; i < 80 && ptr8[i] != ')'; i++) {
82
                    *value++ = ptr8[i];
83
                }
84
                *value++ = ')';
85
            } else {
86

8769
                for (; i < 80 && ptr8[i] != ' ' && ptr8[i] != '/'; i++) {
87
4893
                    *value++ = ptr8[i];
88
                }
89
            }
90
        }
91
    }
92
5210
    *value = '\0';
93
5210
    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
5210
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
5210
    read_keyword_value(line, keyword, value);
116

5210
    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
3059
    case STATE_REST:
186

3059
        if (!strcmp(keyword, "BLANK") && sscanf(value, "%"SCNd64"", &t) == 1) {
187
3
            header->blank = t;
188
3
            header->blank_found = 1;
189

3056
        } else if (!strcmp(keyword, "BSCALE") && sscanf(value, "%lf", &d) == 1) {
190
6
            if (d <= 0)
191
                return AVERROR_INVALIDDATA;
192
6
            header->bscale = d;
193

3050
        } else if (!strcmp(keyword, "BZERO") && sscanf(value, "%lf", &d) == 1) {
194
165
            header->bzero = d;
195

2885
        } else if (!strcmp(keyword, "CTYPE3") && !strncmp(value, "'RGB", 4)) {
196
296
            header->rgb = 1;
197

2589
        } else if (!strcmp(keyword, "DATAMAX") && sscanf(value, "%lf", &d) == 1) {
198
404
            header->data_max_found = 1;
199
404
            header->data_max = d;
200

2185
        } else if (!strcmp(keyword, "DATAMIN") && sscanf(value, "%lf", &d) == 1) {
201
404
            header->data_min_found = 1;
202
404
            header->data_min = d;
203
1781
        } else if (!strcmp(keyword, "END")) {
204
414
            return 1;
205

1367
        } else if (!strcmp(keyword, "GROUPS") && sscanf(value, "%c", &c) == 1) {
206
            header->groups = (c == 'T');
207

1367
        } else if (!strcmp(keyword, "GCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
208

349
            if (t < 0 || t > INT_MAX)
209
                return AVERROR_INVALIDDATA;
210
349
            header->gcount = t;
211

1018
        } else if (!strcmp(keyword, "PCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
212

349
            if (t < 0 || t > INT_MAX)
213
                return AVERROR_INVALIDDATA;
214
349
            header->pcount = t;
215
        }
216
2645
        dict_set_if_not_null(metadata, keyword, value);
217
2645
        break;
218
    }
219
4796
    return 0;
220
}