xref: /linux/drivers/media/v4l2-core/v4l2-jpeg.c (revision a3a02a52bcfcbcc4a637d4b68bf1bc391c9fad02)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * V4L2 JPEG header parser helpers.
4  *
5  * Copyright (C) 2019 Pengutronix, Philipp Zabel <kernel@pengutronix.de>
6  *
7  * For reference, see JPEG ITU-T.81 (ISO/IEC 10918-1) [1]
8  *
9  * [1] https://www.w3.org/Graphics/JPEG/itu-t81.pdf
10  */
11 
12 #include <asm/unaligned.h>
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <media/v4l2-jpeg.h>
18 
19 MODULE_DESCRIPTION("V4L2 JPEG header parser helpers");
20 MODULE_AUTHOR("Philipp Zabel <kernel@pengutronix.de>");
21 MODULE_LICENSE("GPL");
22 
23 /* Table B.1 - Marker code assignments */
24 #define SOF0	0xffc0	/* start of frame */
25 #define SOF1	0xffc1
26 #define SOF2	0xffc2
27 #define SOF3	0xffc3
28 #define SOF5	0xffc5
29 #define SOF7	0xffc7
30 #define JPG	0xffc8	/* extensions */
31 #define SOF9	0xffc9
32 #define SOF11	0xffcb
33 #define SOF13	0xffcd
34 #define SOF15	0xffcf
35 #define DHT	0xffc4	/* huffman table */
36 #define DAC	0xffcc	/* arithmetic coding conditioning */
37 #define RST0	0xffd0	/* restart */
38 #define RST7	0xffd7
39 #define SOI	0xffd8	/* start of image */
40 #define EOI	0xffd9	/* end of image */
41 #define SOS	0xffda	/* start of stream */
42 #define DQT	0xffdb	/* quantization table */
43 #define DNL	0xffdc	/* number of lines */
44 #define DRI	0xffdd	/* restart interval */
45 #define DHP	0xffde	/* hierarchical progression */
46 #define EXP	0xffdf	/* expand reference */
47 #define APP0	0xffe0	/* application data */
48 #define APP14	0xffee	/* application data for colour encoding */
49 #define APP15	0xffef
50 #define JPG0	0xfff0	/* extensions */
51 #define JPG13	0xfffd
52 #define COM	0xfffe	/* comment */
53 #define TEM	0xff01	/* temporary */
54 
55 /* Luma and chroma qp tables to achieve 50% compression quality
56  * This is as per example in Annex K.1 of ITU-T.81
57  */
58 const u8 v4l2_jpeg_ref_table_luma_qt[V4L2_JPEG_PIXELS_IN_BLOCK] = {
59 	16, 11, 10, 16, 24, 40, 51, 61,
60 	12, 12, 14, 19, 26, 58, 60, 55,
61 	14, 13, 16, 24, 40, 57, 69, 56,
62 	14, 17, 22, 29, 51, 87, 80, 62,
63 	18, 22, 37, 56, 68, 109, 103, 77,
64 	24, 35, 55, 64, 81, 104, 113, 92,
65 	49, 64, 78, 87, 103, 121, 120, 101,
66 	72, 92, 95, 98, 112, 100, 103, 99
67 };
68 EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_luma_qt);
69 
70 const u8 v4l2_jpeg_ref_table_chroma_qt[V4L2_JPEG_PIXELS_IN_BLOCK] = {
71 	17, 18, 24, 47, 99, 99, 99, 99,
72 	18, 21, 26, 66, 99, 99, 99, 99,
73 	24, 26, 56, 99, 99, 99, 99, 99,
74 	47, 66, 99, 99, 99, 99, 99, 99,
75 	99, 99, 99, 99, 99, 99, 99, 99,
76 	99, 99, 99, 99, 99, 99, 99, 99,
77 	99, 99, 99, 99, 99, 99, 99, 99,
78 	99, 99, 99, 99, 99, 99, 99, 99
79 };
80 EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_chroma_qt);
81 
82 /* Zigzag scan pattern indexes */
83 const u8 v4l2_jpeg_zigzag_scan_index[V4L2_JPEG_PIXELS_IN_BLOCK] = {
84 	0,   1,  8, 16,  9,  2,  3, 10,
85 	17, 24, 32, 25, 18, 11,  4,  5,
86 	12, 19, 26, 33, 40, 48, 41, 34,
87 	27, 20, 13,  6,  7, 14, 21, 28,
88 	35, 42, 49, 56, 57, 50, 43, 36,
89 	29, 22, 15, 23, 30, 37, 44, 51,
90 	58, 59, 52, 45, 38, 31, 39, 46,
91 	53, 60, 61, 54, 47, 55, 62, 63
92 };
93 EXPORT_SYMBOL_GPL(v4l2_jpeg_zigzag_scan_index);
94 
95 /*
96  * Contains the data that needs to be sent in the marker segment of an
97  * interchange format JPEG stream or an abbreviated format table specification
98  * data stream. Specifies the huffman table used for encoding the luminance DC
99  * coefficient differences. The table represents Table K.3 of ITU-T.81
100  */
101 const u8 v4l2_jpeg_ref_table_luma_dc_ht[V4L2_JPEG_REF_HT_DC_LEN] = {
102 	0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
103 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
104 	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B
105 };
106 EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_luma_dc_ht);
107 
108 /*
109  * Contains the data that needs to be sent in the marker segment of an
110  * interchange format JPEG stream or an abbreviated format table specification
111  * data stream. Specifies the huffman table used for encoding the luminance AC
112  * coefficients. The table represents Table K.5 of ITU-T.81
113  */
114 const u8 v4l2_jpeg_ref_table_luma_ac_ht[V4L2_JPEG_REF_HT_AC_LEN] = {
115 	0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04,
116 	0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
117 	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,
118 	0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
119 	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A,
120 	0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
121 	0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55,
122 	0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
123 	0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85,
124 	0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
125 	0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2,
126 	0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
127 	0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
128 	0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
129 	0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA
130 };
131 EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_luma_ac_ht);
132 
133 /*
134  * Contains the data that needs to be sent in the marker segment of an interchange format JPEG
135  * stream or an abbreviated format table specification data stream.
136  * Specifies the huffman table used for encoding the chrominance DC coefficient differences.
137  * The table represents Table K.4 of ITU-T.81
138  */
139 const u8 v4l2_jpeg_ref_table_chroma_dc_ht[V4L2_JPEG_REF_HT_DC_LEN] = {
140 	0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
141 	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
142 	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B
143 };
144 EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_chroma_dc_ht);
145 
146 /*
147  * Contains the data that needs to be sent in the marker segment of an
148  * interchange format JPEG stream or an abbreviated format table specification
149  * data stream. Specifies the huffman table used for encoding the chrominance
150  * AC coefficients. The table represents Table K.6 of ITU-T.81
151  */
152 const u8 v4l2_jpeg_ref_table_chroma_ac_ht[V4L2_JPEG_REF_HT_AC_LEN] = {
153 	0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04,
154 	0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
155 	0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81,
156 	0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
157 	0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17,
158 	0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
159 	0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
160 	0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
161 	0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83,
162 	0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
163 	0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9,
164 	0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
165 	0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
166 	0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
167 	0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA
168 };
169 EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_chroma_ac_ht);
170 
171 /**
172  * struct jpeg_stream - JPEG byte stream
173  * @curr: current position in stream
174  * @end: end position, after last byte
175  */
176 struct jpeg_stream {
177 	u8 *curr;
178 	u8 *end;
179 };
180 
181 /* returns a value that fits into u8, or negative error */
182 static int jpeg_get_byte(struct jpeg_stream *stream)
183 {
184 	if (stream->curr >= stream->end)
185 		return -EINVAL;
186 
187 	return *stream->curr++;
188 }
189 
190 /* returns a value that fits into u16, or negative error */
191 static int jpeg_get_word_be(struct jpeg_stream *stream)
192 {
193 	u16 word;
194 
195 	if (stream->curr + sizeof(__be16) > stream->end)
196 		return -EINVAL;
197 
198 	word = get_unaligned_be16(stream->curr);
199 	stream->curr += sizeof(__be16);
200 
201 	return word;
202 }
203 
204 static int jpeg_skip(struct jpeg_stream *stream, size_t len)
205 {
206 	if (stream->curr + len > stream->end)
207 		return -EINVAL;
208 
209 	stream->curr += len;
210 
211 	return 0;
212 }
213 
214 static int jpeg_next_marker(struct jpeg_stream *stream)
215 {
216 	int byte;
217 	u16 marker = 0;
218 
219 	while ((byte = jpeg_get_byte(stream)) >= 0) {
220 		marker = (marker << 8) | byte;
221 		/* skip stuffing bytes and REServed markers */
222 		if (marker == TEM || (marker > 0xffbf && marker < 0xffff))
223 			return marker;
224 	}
225 
226 	return byte;
227 }
228 
229 /* this does not advance the current position in the stream */
230 static int jpeg_reference_segment(struct jpeg_stream *stream,
231 				  struct v4l2_jpeg_reference *segment)
232 {
233 	u16 len;
234 
235 	if (stream->curr + sizeof(__be16) > stream->end)
236 		return -EINVAL;
237 
238 	len = get_unaligned_be16(stream->curr);
239 	if (stream->curr + len > stream->end)
240 		return -EINVAL;
241 
242 	segment->start = stream->curr;
243 	segment->length = len;
244 
245 	return 0;
246 }
247 
248 static int v4l2_jpeg_decode_subsampling(u8 nf, u8 h_v)
249 {
250 	if (nf == 1)
251 		return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
252 
253 	/* no chroma subsampling for 4-component images */
254 	if (nf == 4 && h_v != 0x11)
255 		return -EINVAL;
256 
257 	switch (h_v) {
258 	case 0x11:
259 		return V4L2_JPEG_CHROMA_SUBSAMPLING_444;
260 	case 0x21:
261 		return V4L2_JPEG_CHROMA_SUBSAMPLING_422;
262 	case 0x22:
263 		return V4L2_JPEG_CHROMA_SUBSAMPLING_420;
264 	case 0x41:
265 		return V4L2_JPEG_CHROMA_SUBSAMPLING_411;
266 	default:
267 		return -EINVAL;
268 	}
269 }
270 
271 static int jpeg_parse_frame_header(struct jpeg_stream *stream, u16 sof_marker,
272 				   struct v4l2_jpeg_frame_header *frame_header)
273 {
274 	int len = jpeg_get_word_be(stream);
275 
276 	if (len < 0)
277 		return len;
278 	/* Lf = 8 + 3 * Nf, Nf >= 1 */
279 	if (len < 8 + 3)
280 		return -EINVAL;
281 
282 	if (frame_header) {
283 		/* Table B.2 - Frame header parameter sizes and values */
284 		int p, y, x, nf;
285 		int i;
286 
287 		p = jpeg_get_byte(stream);
288 		if (p < 0)
289 			return p;
290 		/*
291 		 * Baseline DCT only supports 8-bit precision.
292 		 * Extended sequential DCT also supports 12-bit precision.
293 		 */
294 		if (p != 8 && (p != 12 || sof_marker != SOF1))
295 			return -EINVAL;
296 
297 		y = jpeg_get_word_be(stream);
298 		if (y < 0)
299 			return y;
300 		if (y == 0)
301 			return -EINVAL;
302 
303 		x = jpeg_get_word_be(stream);
304 		if (x < 0)
305 			return x;
306 		if (x == 0)
307 			return -EINVAL;
308 
309 		nf = jpeg_get_byte(stream);
310 		if (nf < 0)
311 			return nf;
312 		/*
313 		 * The spec allows 1 <= Nf <= 255, but we only support up to 4
314 		 * components.
315 		 */
316 		if (nf < 1 || nf > V4L2_JPEG_MAX_COMPONENTS)
317 			return -EINVAL;
318 		if (len != 8 + 3 * nf)
319 			return -EINVAL;
320 
321 		frame_header->precision = p;
322 		frame_header->height = y;
323 		frame_header->width = x;
324 		frame_header->num_components = nf;
325 
326 		for (i = 0; i < nf; i++) {
327 			struct v4l2_jpeg_frame_component_spec *component;
328 			int c, h_v, tq;
329 
330 			c = jpeg_get_byte(stream);
331 			if (c < 0)
332 				return c;
333 
334 			h_v = jpeg_get_byte(stream);
335 			if (h_v < 0)
336 				return h_v;
337 			if (i == 0) {
338 				int subs;
339 
340 				subs = v4l2_jpeg_decode_subsampling(nf, h_v);
341 				if (subs < 0)
342 					return subs;
343 				frame_header->subsampling = subs;
344 			} else if (h_v != 0x11) {
345 				/* all chroma sampling factors must be 1 */
346 				return -EINVAL;
347 			}
348 
349 			tq = jpeg_get_byte(stream);
350 			if (tq < 0)
351 				return tq;
352 
353 			component = &frame_header->component[i];
354 			component->component_identifier = c;
355 			component->horizontal_sampling_factor =
356 				(h_v >> 4) & 0xf;
357 			component->vertical_sampling_factor = h_v & 0xf;
358 			component->quantization_table_selector = tq;
359 		}
360 	} else {
361 		return jpeg_skip(stream, len - 2);
362 	}
363 
364 	return 0;
365 }
366 
367 static int jpeg_parse_scan_header(struct jpeg_stream *stream,
368 				  struct v4l2_jpeg_scan_header *scan_header)
369 {
370 	size_t skip;
371 	int len = jpeg_get_word_be(stream);
372 
373 	if (len < 0)
374 		return len;
375 	/* Ls = 8 + 3 * Ns, Ns >= 1 */
376 	if (len < 6 + 2)
377 		return -EINVAL;
378 
379 	if (scan_header) {
380 		int ns;
381 		int i;
382 
383 		ns = jpeg_get_byte(stream);
384 		if (ns < 0)
385 			return ns;
386 		if (ns < 1 || ns > 4 || len != 6 + 2 * ns)
387 			return -EINVAL;
388 
389 		scan_header->num_components = ns;
390 
391 		for (i = 0; i < ns; i++) {
392 			struct v4l2_jpeg_scan_component_spec *component;
393 			int cs, td_ta;
394 
395 			cs = jpeg_get_byte(stream);
396 			if (cs < 0)
397 				return cs;
398 
399 			td_ta = jpeg_get_byte(stream);
400 			if (td_ta < 0)
401 				return td_ta;
402 
403 			component = &scan_header->component[i];
404 			component->component_selector = cs;
405 			component->dc_entropy_coding_table_selector =
406 				(td_ta >> 4) & 0xf;
407 			component->ac_entropy_coding_table_selector =
408 				td_ta & 0xf;
409 		}
410 
411 		skip = 3; /* skip Ss, Se, Ah, and Al */
412 	} else {
413 		skip = len - 2;
414 	}
415 
416 	return jpeg_skip(stream, skip);
417 }
418 
419 /* B.2.4.1 Quantization table-specification syntax */
420 static int jpeg_parse_quantization_tables(struct jpeg_stream *stream,
421 					  u8 precision,
422 					  struct v4l2_jpeg_reference *tables)
423 {
424 	int len = jpeg_get_word_be(stream);
425 
426 	if (len < 0)
427 		return len;
428 	/* Lq = 2 + n * 65 (for baseline DCT), n >= 1 */
429 	if (len < 2 + 65)
430 		return -EINVAL;
431 
432 	len -= 2;
433 	while (len >= 65) {
434 		u8 pq, tq, *qk;
435 		int ret;
436 		int pq_tq = jpeg_get_byte(stream);
437 
438 		if (pq_tq < 0)
439 			return pq_tq;
440 
441 		/* quantization table element precision */
442 		pq = (pq_tq >> 4) & 0xf;
443 		/*
444 		 * Only 8-bit Qk values for 8-bit sample precision. Extended
445 		 * sequential DCT with 12-bit sample precision also supports
446 		 * 16-bit Qk values.
447 		 */
448 		if (pq != 0 && (pq != 1 || precision != 12))
449 			return -EINVAL;
450 
451 		/* quantization table destination identifier */
452 		tq = pq_tq & 0xf;
453 		if (tq > 3)
454 			return -EINVAL;
455 
456 		/* quantization table element */
457 		qk = stream->curr;
458 		ret = jpeg_skip(stream, pq ? 128 : 64);
459 		if (ret < 0)
460 			return -EINVAL;
461 
462 		if (tables) {
463 			tables[tq].start = qk;
464 			tables[tq].length = pq ? 128 : 64;
465 		}
466 
467 		len -= pq ? 129 : 65;
468 	}
469 
470 	return 0;
471 }
472 
473 /* B.2.4.2 Huffman table-specification syntax */
474 static int jpeg_parse_huffman_tables(struct jpeg_stream *stream,
475 				     struct v4l2_jpeg_reference *tables)
476 {
477 	int mt;
478 	int len = jpeg_get_word_be(stream);
479 
480 	if (len < 0)
481 		return len;
482 	/* Table B.5 - Huffman table specification parameter sizes and values */
483 	if (len < 2 + 17)
484 		return -EINVAL;
485 
486 	for (len -= 2; len >= 17; len -= 17 + mt) {
487 		u8 tc, th, *table;
488 		int tc_th = jpeg_get_byte(stream);
489 		int i, ret;
490 
491 		if (tc_th < 0)
492 			return tc_th;
493 
494 		/* table class - 0 = DC, 1 = AC */
495 		tc = (tc_th >> 4) & 0xf;
496 		if (tc > 1)
497 			return -EINVAL;
498 
499 		/* huffman table destination identifier */
500 		th = tc_th & 0xf;
501 		/* only two Huffman tables for baseline DCT */
502 		if (th > 1)
503 			return -EINVAL;
504 
505 		/* BITS - number of Huffman codes with length i */
506 		table = stream->curr;
507 		mt = 0;
508 		for (i = 0; i < 16; i++) {
509 			int li;
510 
511 			li = jpeg_get_byte(stream);
512 			if (li < 0)
513 				return li;
514 
515 			mt += li;
516 		}
517 		/* HUFFVAL - values associated with each Huffman code */
518 		ret = jpeg_skip(stream, mt);
519 		if (ret < 0)
520 			return ret;
521 
522 		if (tables) {
523 			tables[(tc << 1) | th].start = table;
524 			tables[(tc << 1) | th].length = stream->curr - table;
525 		}
526 	}
527 
528 	return jpeg_skip(stream, len - 2);
529 }
530 
531 /* B.2.4.4 Restart interval definition syntax */
532 static int jpeg_parse_restart_interval(struct jpeg_stream *stream,
533 				       u16 *restart_interval)
534 {
535 	int len = jpeg_get_word_be(stream);
536 	int ri;
537 
538 	if (len < 0)
539 		return len;
540 	if (len != 4)
541 		return -EINVAL;
542 
543 	ri = jpeg_get_word_be(stream);
544 	if (ri < 0)
545 		return ri;
546 
547 	*restart_interval = ri;
548 
549 	return 0;
550 }
551 
552 static int jpeg_skip_segment(struct jpeg_stream *stream)
553 {
554 	int len = jpeg_get_word_be(stream);
555 
556 	if (len < 0)
557 		return len;
558 	if (len < 2)
559 		return -EINVAL;
560 
561 	return jpeg_skip(stream, len - 2);
562 }
563 
564 /* Rec. ITU-T T.872 (06/2012) 6.5.3 */
565 static int jpeg_parse_app14_data(struct jpeg_stream *stream,
566 				 enum v4l2_jpeg_app14_tf *tf)
567 {
568 	int ret;
569 	int lp;
570 	int skip;
571 
572 	lp = jpeg_get_word_be(stream);
573 	if (lp < 0)
574 		return lp;
575 
576 	/* Check for "Adobe\0" in Ap1..6 */
577 	if (stream->curr + 6 > stream->end ||
578 	    strncmp(stream->curr, "Adobe\0", 6))
579 		return jpeg_skip(stream, lp - 2);
580 
581 	/* get to Ap12 */
582 	ret = jpeg_skip(stream, 11);
583 	if (ret < 0)
584 		return ret;
585 
586 	ret = jpeg_get_byte(stream);
587 	if (ret < 0)
588 		return ret;
589 
590 	*tf = ret;
591 
592 	/* skip the rest of the segment, this ensures at least it is complete */
593 	skip = lp - 2 - 11 - 1;
594 	return jpeg_skip(stream, skip);
595 }
596 
597 /**
598  * v4l2_jpeg_parse_header - locate marker segments and optionally parse headers
599  * @buf: address of the JPEG buffer, should start with a SOI marker
600  * @len: length of the JPEG buffer
601  * @out: returns marker segment positions and optionally parsed headers
602  *
603  * The out->scan_header pointer must be initialized to NULL or point to a valid
604  * v4l2_jpeg_scan_header structure. The out->huffman_tables and
605  * out->quantization_tables pointers must be initialized to NULL or point to a
606  * valid array of 4 v4l2_jpeg_reference structures each.
607  *
608  * Returns 0 or negative error if parsing failed.
609  */
610 int v4l2_jpeg_parse_header(void *buf, size_t len, struct v4l2_jpeg_header *out)
611 {
612 	struct jpeg_stream stream;
613 	int marker;
614 	int ret = 0;
615 
616 	stream.curr = buf;
617 	stream.end = stream.curr + len;
618 
619 	out->num_dht = 0;
620 	out->num_dqt = 0;
621 
622 	/* the first bytes must be SOI, B.2.1 High-level syntax */
623 	if (jpeg_get_word_be(&stream) != SOI)
624 		return -EINVAL;
625 
626 	/* init value to signal if this marker is not present */
627 	out->app14_tf = V4L2_JPEG_APP14_TF_UNKNOWN;
628 
629 	/* loop through marker segments */
630 	while ((marker = jpeg_next_marker(&stream)) >= 0) {
631 		switch (marker) {
632 		/* baseline DCT, extended sequential DCT */
633 		case SOF0 ... SOF1:
634 			ret = jpeg_reference_segment(&stream, &out->sof);
635 			if (ret < 0)
636 				return ret;
637 			ret = jpeg_parse_frame_header(&stream, marker,
638 						      &out->frame);
639 			break;
640 		/* progressive, lossless */
641 		case SOF2 ... SOF3:
642 		/* differential coding */
643 		case SOF5 ... SOF7:
644 		/* arithmetic coding */
645 		case SOF9 ... SOF11:
646 		case SOF13 ... SOF15:
647 		case DAC:
648 		case TEM:
649 			return -EINVAL;
650 
651 		case DHT:
652 			ret = jpeg_reference_segment(&stream,
653 					&out->dht[out->num_dht++ % 4]);
654 			if (ret < 0)
655 				return ret;
656 			if (!out->huffman_tables) {
657 				ret = jpeg_skip_segment(&stream);
658 				break;
659 			}
660 			ret = jpeg_parse_huffman_tables(&stream,
661 							out->huffman_tables);
662 			break;
663 		case DQT:
664 			ret = jpeg_reference_segment(&stream,
665 					&out->dqt[out->num_dqt++ % 4]);
666 			if (ret < 0)
667 				return ret;
668 			if (!out->quantization_tables) {
669 				ret = jpeg_skip_segment(&stream);
670 				break;
671 			}
672 			ret = jpeg_parse_quantization_tables(&stream,
673 					out->frame.precision,
674 					out->quantization_tables);
675 			break;
676 		case DRI:
677 			ret = jpeg_parse_restart_interval(&stream,
678 							&out->restart_interval);
679 			break;
680 		case APP14:
681 			ret = jpeg_parse_app14_data(&stream,
682 						    &out->app14_tf);
683 			break;
684 		case SOS:
685 			ret = jpeg_reference_segment(&stream, &out->sos);
686 			if (ret < 0)
687 				return ret;
688 			ret = jpeg_parse_scan_header(&stream, out->scan);
689 			/*
690 			 * stop parsing, the scan header marks the beginning of
691 			 * the entropy coded segment
692 			 */
693 			out->ecs_offset = stream.curr - (u8 *)buf;
694 			return ret;
695 
696 		/* markers without parameters */
697 		case RST0 ... RST7: /* restart */
698 		case SOI: /* start of image */
699 		case EOI: /* end of image */
700 			break;
701 
702 		/* skip unknown or unsupported marker segments */
703 		default:
704 			ret = jpeg_skip_segment(&stream);
705 			break;
706 		}
707 		if (ret < 0)
708 			return ret;
709 	}
710 
711 	return marker;
712 }
713 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_header);
714 
715 /**
716  * v4l2_jpeg_parse_frame_header - parse frame header
717  * @buf: address of the frame header, after the SOF0 marker
718  * @len: length of the frame header
719  * @frame_header: returns the parsed frame header
720  *
721  * Returns 0 or negative error if parsing failed.
722  */
723 int v4l2_jpeg_parse_frame_header(void *buf, size_t len,
724 				 struct v4l2_jpeg_frame_header *frame_header)
725 {
726 	struct jpeg_stream stream;
727 
728 	stream.curr = buf;
729 	stream.end = stream.curr + len;
730 	return jpeg_parse_frame_header(&stream, SOF0, frame_header);
731 }
732 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_frame_header);
733 
734 /**
735  * v4l2_jpeg_parse_scan_header - parse scan header
736  * @buf: address of the scan header, after the SOS marker
737  * @len: length of the scan header
738  * @scan_header: returns the parsed scan header
739  *
740  * Returns 0 or negative error if parsing failed.
741  */
742 int v4l2_jpeg_parse_scan_header(void *buf, size_t len,
743 				struct v4l2_jpeg_scan_header *scan_header)
744 {
745 	struct jpeg_stream stream;
746 
747 	stream.curr = buf;
748 	stream.end = stream.curr + len;
749 	return jpeg_parse_scan_header(&stream, scan_header);
750 }
751 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_scan_header);
752 
753 /**
754  * v4l2_jpeg_parse_quantization_tables - parse quantization tables segment
755  * @buf: address of the quantization table segment, after the DQT marker
756  * @len: length of the quantization table segment
757  * @precision: sample precision (P) in bits per component
758  * @q_tables: returns four references into the buffer for the
759  *            four possible quantization table destinations
760  *
761  * Returns 0 or negative error if parsing failed.
762  */
763 int v4l2_jpeg_parse_quantization_tables(void *buf, size_t len, u8 precision,
764 					struct v4l2_jpeg_reference *q_tables)
765 {
766 	struct jpeg_stream stream;
767 
768 	stream.curr = buf;
769 	stream.end = stream.curr + len;
770 	return jpeg_parse_quantization_tables(&stream, precision, q_tables);
771 }
772 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_quantization_tables);
773 
774 /**
775  * v4l2_jpeg_parse_huffman_tables - parse huffman tables segment
776  * @buf: address of the Huffman table segment, after the DHT marker
777  * @len: length of the Huffman table segment
778  * @huffman_tables: returns four references into the buffer for the
779  *                  four possible Huffman table destinations, in
780  *                  the order DC0, DC1, AC0, AC1
781  *
782  * Returns 0 or negative error if parsing failed.
783  */
784 int v4l2_jpeg_parse_huffman_tables(void *buf, size_t len,
785 				   struct v4l2_jpeg_reference *huffman_tables)
786 {
787 	struct jpeg_stream stream;
788 
789 	stream.curr = buf;
790 	stream.end = stream.curr + len;
791 	return jpeg_parse_huffman_tables(&stream, huffman_tables);
792 }
793 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_huffman_tables);
794