drivers/media/v4l2-core/v4l2-jpeg.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * V4L2 JPEG header parser helpers.
   4  *
   5  * Copyright (C) 2019 Pengutronix, Philipp Zabel <[email protected]>
   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 <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
  19 MODULE_DESCRIPTION("V4L2 JPEG header parser helpers");
  20 MODULE_AUTHOR("Philipp Zabel <[email protected]>");
  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);