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 */
jpeg_get_byte(struct jpeg_stream * stream)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 */
jpeg_get_word_be(struct jpeg_stream * stream)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
jpeg_skip(struct jpeg_stream * stream,size_t len)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
jpeg_next_marker(struct jpeg_stream * stream)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 */
jpeg_reference_segment(struct jpeg_stream * stream,struct v4l2_jpeg_reference * segment)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
v4l2_jpeg_decode_subsampling(u8 nf,u8 h_v)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
jpeg_parse_frame_header(struct jpeg_stream * stream,u16 sof_marker,struct v4l2_jpeg_frame_header * frame_header)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
jpeg_parse_scan_header(struct jpeg_stream * stream,struct v4l2_jpeg_scan_header * scan_header)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 */
jpeg_parse_quantization_tables(struct jpeg_stream * stream,u8 precision,struct v4l2_jpeg_reference * tables)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 */
jpeg_parse_huffman_tables(struct jpeg_stream * stream,struct v4l2_jpeg_reference * tables)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 */
jpeg_parse_restart_interval(struct jpeg_stream * stream,u16 * restart_interval)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
jpeg_skip_segment(struct jpeg_stream * stream)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 */
jpeg_parse_app14_data(struct jpeg_stream * stream,enum v4l2_jpeg_app14_tf * tf)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 */
v4l2_jpeg_parse_header(void * buf,size_t len,struct v4l2_jpeg_header * out)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 */
v4l2_jpeg_parse_frame_header(void * buf,size_t len,struct v4l2_jpeg_frame_header * frame_header)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 */
v4l2_jpeg_parse_scan_header(void * buf,size_t len,struct v4l2_jpeg_scan_header * scan_header)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 */
v4l2_jpeg_parse_quantization_tables(void * buf,size_t len,u8 precision,struct v4l2_jpeg_reference * q_tables)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 */
v4l2_jpeg_parse_huffman_tables(void * buf,size_t len,struct v4l2_jpeg_reference * huffman_tables)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