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 |
if (d <= 0) |
191 |
|
|
return AVERROR_INVALIDDATA; |
192 |
|
6 |
header->bscale = d; |
193 |
✓✓✓✗
|
2248 |
} else if (!strcmp(keyword, "BZERO") && sscanf(value, "%lf", &d) == 1) { |
194 |
|
165 |
header->bzero = d; |
195 |
✓✓✓✓
|
2083 |
} else if (!strcmp(keyword, "CTYPE3") && !strncmp(value, "'RGB", 4)) { |
196 |
|
296 |
header->rgb = 1; |
197 |
✓✓✓✓
|
1787 |
} else if (!strcmp(keyword, "DATAMAX") && sscanf(value, "%lf", &d) == 1) { |
198 |
|
3 |
header->data_max_found = 1; |
199 |
|
3 |
header->data_max = d; |
200 |
✓✓✓✓
|
1784 |
} else if (!strcmp(keyword, "DATAMIN") && sscanf(value, "%lf", &d) == 1) { |
201 |
|
3 |
header->data_min_found = 1; |
202 |
|
3 |
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 |
header->gcount = t; |
209 |
✓✓✓✗
|
1018 |
} else if (!strcmp(keyword, "PCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) { |
210 |
|
349 |
header->pcount = t; |
211 |
|
|
} |
212 |
|
1843 |
dict_set_if_not_null(metadata, keyword, value); |
213 |
|
1843 |
break; |
214 |
|
|
} |
215 |
|
3994 |
return 0; |
216 |
|
|
} |