794 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*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.pdf10 */11 12#include <linux/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 19MODULE_DESCRIPTION("V4L2 JPEG header parser helpers");20MODULE_AUTHOR("Philipp Zabel <kernel@pengutronix.de>");21MODULE_LICENSE("GPL");22 23/* Table B.1 - Marker code assignments */24#define SOF0 0xffc0 /* start of frame */25#define SOF1 0xffc126#define SOF2 0xffc227#define SOF3 0xffc328#define SOF5 0xffc529#define SOF7 0xffc730#define JPG 0xffc8 /* extensions */31#define SOF9 0xffc932#define SOF11 0xffcb33#define SOF13 0xffcd34#define SOF15 0xffcf35#define DHT 0xffc4 /* huffman table */36#define DAC 0xffcc /* arithmetic coding conditioning */37#define RST0 0xffd0 /* restart */38#define RST7 0xffd739#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 0xffef50#define JPG0 0xfff0 /* extensions */51#define JPG13 0xfffd52#define COM 0xfffe /* comment */53#define TEM 0xff01 /* temporary */54 55/* Luma and chroma qp tables to achieve 50% compression quality56 * This is as per example in Annex K.1 of ITU-T.8157 */58const 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, 9967};68EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_luma_qt);69 70const 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, 9979};80EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_chroma_qt);81 82/* Zigzag scan pattern indexes */83const 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, 6392};93EXPORT_SYMBOL_GPL(v4l2_jpeg_zigzag_scan_index);94 95/*96 * Contains the data that needs to be sent in the marker segment of an97 * interchange format JPEG stream or an abbreviated format table specification98 * data stream. Specifies the huffman table used for encoding the luminance DC99 * coefficient differences. The table represents Table K.3 of ITU-T.81100 */101const 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, 0x0B105};106EXPORT_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 an110 * interchange format JPEG stream or an abbreviated format table specification111 * data stream. Specifies the huffman table used for encoding the luminance AC112 * coefficients. The table represents Table K.5 of ITU-T.81113 */114const 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, 0xFA130};131EXPORT_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 JPEG135 * 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.81138 */139const 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, 0x0B143};144EXPORT_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 an148 * interchange format JPEG stream or an abbreviated format table specification149 * data stream. Specifies the huffman table used for encoding the chrominance150 * AC coefficients. The table represents Table K.6 of ITU-T.81151 */152const 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, 0xFA168};169EXPORT_SYMBOL_GPL(v4l2_jpeg_ref_table_chroma_ac_ht);170 171/**172 * struct jpeg_stream - JPEG byte stream173 * @curr: current position in stream174 * @end: end position, after last byte175 */176struct jpeg_stream {177 u8 *curr;178 u8 *end;179};180 181/* returns a value that fits into u8, or negative error */182static 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 */191static 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 204static 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 214static 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 */230static 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 248static 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 271static 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 4314 * 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 367static 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 */420static 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. Extended445 * sequential DCT with 12-bit sample precision also supports446 * 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 */474static 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 */532static 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 552static 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 */565static 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 headers599 * @buf: address of the JPEG buffer, should start with a SOI marker600 * @len: length of the JPEG buffer601 * @out: returns marker segment positions and optionally parsed headers602 *603 * The out->scan_header pointer must be initialized to NULL or point to a valid604 * v4l2_jpeg_scan_header structure. The out->huffman_tables and605 * out->quantization_tables pointers must be initialized to NULL or point to a606 * valid array of 4 v4l2_jpeg_reference structures each.607 *608 * Returns 0 or negative error if parsing failed.609 */610int 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 of691 * the entropy coded segment692 */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}713EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_header);714 715/**716 * v4l2_jpeg_parse_frame_header - parse frame header717 * @buf: address of the frame header, after the SOF0 marker718 * @len: length of the frame header719 * @frame_header: returns the parsed frame header720 *721 * Returns 0 or negative error if parsing failed.722 */723int 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}732EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_frame_header);733 734/**735 * v4l2_jpeg_parse_scan_header - parse scan header736 * @buf: address of the scan header, after the SOS marker737 * @len: length of the scan header738 * @scan_header: returns the parsed scan header739 *740 * Returns 0 or negative error if parsing failed.741 */742int 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}751EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_scan_header);752 753/**754 * v4l2_jpeg_parse_quantization_tables - parse quantization tables segment755 * @buf: address of the quantization table segment, after the DQT marker756 * @len: length of the quantization table segment757 * @precision: sample precision (P) in bits per component758 * @q_tables: returns four references into the buffer for the759 * four possible quantization table destinations760 *761 * Returns 0 or negative error if parsing failed.762 */763int 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}772EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_quantization_tables);773 774/**775 * v4l2_jpeg_parse_huffman_tables - parse huffman tables segment776 * @buf: address of the Huffman table segment, after the DHT marker777 * @len: length of the Huffman table segment778 * @huffman_tables: returns four references into the buffer for the779 * four possible Huffman table destinations, in780 * the order DC0, DC1, AC0, AC1781 *782 * Returns 0 or negative error if parsing failed.783 */784int 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}793EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_huffman_tables);794