Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * V4L2 JPEG header parser helpers.
0004  *
0005  * Copyright (C) 2019 Pengutronix, Philipp Zabel <kernel@pengutronix.de>
0006  *
0007  * For reference, see JPEG ITU-T.81 (ISO/IEC 10918-1) [1]
0008  *
0009  * [1] https://www.w3.org/Graphics/JPEG/itu-t81.pdf
0010  */
0011 
0012 #include <asm/unaligned.h>
0013 #include <linux/errno.h>
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/types.h>
0017 #include <media/v4l2-jpeg.h>
0018 
0019 MODULE_DESCRIPTION("V4L2 JPEG header parser helpers");
0020 MODULE_AUTHOR("Philipp Zabel <kernel@pengutronix.de>");
0021 MODULE_LICENSE("GPL");
0022 
0023 /* Table B.1 - Marker code assignments */
0024 #define SOF0    0xffc0  /* start of frame */
0025 #define SOF1    0xffc1
0026 #define SOF2    0xffc2
0027 #define SOF3    0xffc3
0028 #define SOF5    0xffc5
0029 #define SOF7    0xffc7
0030 #define JPG 0xffc8  /* extensions */
0031 #define SOF9    0xffc9
0032 #define SOF11   0xffcb
0033 #define SOF13   0xffcd
0034 #define SOF15   0xffcf
0035 #define DHT 0xffc4  /* huffman table */
0036 #define DAC 0xffcc  /* arithmetic coding conditioning */
0037 #define RST0    0xffd0  /* restart */
0038 #define RST7    0xffd7
0039 #define SOI 0xffd8  /* start of image */
0040 #define EOI 0xffd9  /* end of image */
0041 #define SOS 0xffda  /* start of stream */
0042 #define DQT 0xffdb  /* quantization table */
0043 #define DNL 0xffdc  /* number of lines */
0044 #define DRI 0xffdd  /* restart interval */
0045 #define DHP 0xffde  /* hierarchical progression */
0046 #define EXP 0xffdf  /* expand reference */
0047 #define APP0    0xffe0  /* application data */
0048 #define APP14   0xffee  /* application data for colour encoding */
0049 #define APP15   0xffef
0050 #define JPG0    0xfff0  /* extensions */
0051 #define JPG13   0xfffd
0052 #define COM 0xfffe  /* comment */
0053 #define TEM 0xff01  /* temporary */
0054 
0055 /**
0056  * struct jpeg_stream - JPEG byte stream
0057  * @curr: current position in stream
0058  * @end: end position, after last byte
0059  */
0060 struct jpeg_stream {
0061     u8 *curr;
0062     u8 *end;
0063 };
0064 
0065 /* returns a value that fits into u8, or negative error */
0066 static int jpeg_get_byte(struct jpeg_stream *stream)
0067 {
0068     if (stream->curr >= stream->end)
0069         return -EINVAL;
0070 
0071     return *stream->curr++;
0072 }
0073 
0074 /* returns a value that fits into u16, or negative error */
0075 static int jpeg_get_word_be(struct jpeg_stream *stream)
0076 {
0077     u16 word;
0078 
0079     if (stream->curr + sizeof(__be16) > stream->end)
0080         return -EINVAL;
0081 
0082     word = get_unaligned_be16(stream->curr);
0083     stream->curr += sizeof(__be16);
0084 
0085     return word;
0086 }
0087 
0088 static int jpeg_skip(struct jpeg_stream *stream, size_t len)
0089 {
0090     if (stream->curr + len > stream->end)
0091         return -EINVAL;
0092 
0093     stream->curr += len;
0094 
0095     return 0;
0096 }
0097 
0098 static int jpeg_next_marker(struct jpeg_stream *stream)
0099 {
0100     int byte;
0101     u16 marker = 0;
0102 
0103     while ((byte = jpeg_get_byte(stream)) >= 0) {
0104         marker = (marker << 8) | byte;
0105         /* skip stuffing bytes and REServed markers */
0106         if (marker == TEM || (marker > 0xffbf && marker < 0xffff))
0107             return marker;
0108     }
0109 
0110     return byte;
0111 }
0112 
0113 /* this does not advance the current position in the stream */
0114 static int jpeg_reference_segment(struct jpeg_stream *stream,
0115                   struct v4l2_jpeg_reference *segment)
0116 {
0117     u16 len;
0118 
0119     if (stream->curr + sizeof(__be16) > stream->end)
0120         return -EINVAL;
0121 
0122     len = get_unaligned_be16(stream->curr);
0123     if (stream->curr + len > stream->end)
0124         return -EINVAL;
0125 
0126     segment->start = stream->curr;
0127     segment->length = len;
0128 
0129     return 0;
0130 }
0131 
0132 static int v4l2_jpeg_decode_subsampling(u8 nf, u8 h_v)
0133 {
0134     if (nf == 1)
0135         return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
0136 
0137     /* no chroma subsampling for 4-component images */
0138     if (nf == 4 && h_v != 0x11)
0139         return -EINVAL;
0140 
0141     switch (h_v) {
0142     case 0x11:
0143         return V4L2_JPEG_CHROMA_SUBSAMPLING_444;
0144     case 0x21:
0145         return V4L2_JPEG_CHROMA_SUBSAMPLING_422;
0146     case 0x22:
0147         return V4L2_JPEG_CHROMA_SUBSAMPLING_420;
0148     case 0x41:
0149         return V4L2_JPEG_CHROMA_SUBSAMPLING_411;
0150     default:
0151         return -EINVAL;
0152     }
0153 }
0154 
0155 static int jpeg_parse_frame_header(struct jpeg_stream *stream, u16 sof_marker,
0156                    struct v4l2_jpeg_frame_header *frame_header)
0157 {
0158     int len = jpeg_get_word_be(stream);
0159 
0160     if (len < 0)
0161         return len;
0162     /* Lf = 8 + 3 * Nf, Nf >= 1 */
0163     if (len < 8 + 3)
0164         return -EINVAL;
0165 
0166     if (frame_header) {
0167         /* Table B.2 - Frame header parameter sizes and values */
0168         int p, y, x, nf;
0169         int i;
0170 
0171         p = jpeg_get_byte(stream);
0172         if (p < 0)
0173             return p;
0174         /*
0175          * Baseline DCT only supports 8-bit precision.
0176          * Extended sequential DCT also supports 12-bit precision.
0177          */
0178         if (p != 8 && (p != 12 || sof_marker != SOF1))
0179             return -EINVAL;
0180 
0181         y = jpeg_get_word_be(stream);
0182         if (y < 0)
0183             return y;
0184         if (y == 0)
0185             return -EINVAL;
0186 
0187         x = jpeg_get_word_be(stream);
0188         if (x < 0)
0189             return x;
0190         if (x == 0)
0191             return -EINVAL;
0192 
0193         nf = jpeg_get_byte(stream);
0194         if (nf < 0)
0195             return nf;
0196         /*
0197          * The spec allows 1 <= Nf <= 255, but we only support up to 4
0198          * components.
0199          */
0200         if (nf < 1 || nf > V4L2_JPEG_MAX_COMPONENTS)
0201             return -EINVAL;
0202         if (len != 8 + 3 * nf)
0203             return -EINVAL;
0204 
0205         frame_header->precision = p;
0206         frame_header->height = y;
0207         frame_header->width = x;
0208         frame_header->num_components = nf;
0209 
0210         for (i = 0; i < nf; i++) {
0211             struct v4l2_jpeg_frame_component_spec *component;
0212             int c, h_v, tq;
0213 
0214             c = jpeg_get_byte(stream);
0215             if (c < 0)
0216                 return c;
0217 
0218             h_v = jpeg_get_byte(stream);
0219             if (h_v < 0)
0220                 return h_v;
0221             if (i == 0) {
0222                 int subs;
0223 
0224                 subs = v4l2_jpeg_decode_subsampling(nf, h_v);
0225                 if (subs < 0)
0226                     return subs;
0227                 frame_header->subsampling = subs;
0228             } else if (h_v != 0x11) {
0229                 /* all chroma sampling factors must be 1 */
0230                 return -EINVAL;
0231             }
0232 
0233             tq = jpeg_get_byte(stream);
0234             if (tq < 0)
0235                 return tq;
0236 
0237             component = &frame_header->component[i];
0238             component->component_identifier = c;
0239             component->horizontal_sampling_factor =
0240                 (h_v >> 4) & 0xf;
0241             component->vertical_sampling_factor = h_v & 0xf;
0242             component->quantization_table_selector = tq;
0243         }
0244     } else {
0245         return jpeg_skip(stream, len - 2);
0246     }
0247 
0248     return 0;
0249 }
0250 
0251 static int jpeg_parse_scan_header(struct jpeg_stream *stream,
0252                   struct v4l2_jpeg_scan_header *scan_header)
0253 {
0254     size_t skip;
0255     int len = jpeg_get_word_be(stream);
0256 
0257     if (len < 0)
0258         return len;
0259     /* Ls = 8 + 3 * Ns, Ns >= 1 */
0260     if (len < 6 + 2)
0261         return -EINVAL;
0262 
0263     if (scan_header) {
0264         int ns;
0265         int i;
0266 
0267         ns = jpeg_get_byte(stream);
0268         if (ns < 0)
0269             return ns;
0270         if (ns < 1 || ns > 4 || len != 6 + 2 * ns)
0271             return -EINVAL;
0272 
0273         scan_header->num_components = ns;
0274 
0275         for (i = 0; i < ns; i++) {
0276             struct v4l2_jpeg_scan_component_spec *component;
0277             int cs, td_ta;
0278 
0279             cs = jpeg_get_byte(stream);
0280             if (cs < 0)
0281                 return cs;
0282 
0283             td_ta = jpeg_get_byte(stream);
0284             if (td_ta < 0)
0285                 return td_ta;
0286 
0287             component = &scan_header->component[i];
0288             component->component_selector = cs;
0289             component->dc_entropy_coding_table_selector =
0290                 (td_ta >> 4) & 0xf;
0291             component->ac_entropy_coding_table_selector =
0292                 td_ta & 0xf;
0293         }
0294 
0295         skip = 3; /* skip Ss, Se, Ah, and Al */
0296     } else {
0297         skip = len - 2;
0298     }
0299 
0300     return jpeg_skip(stream, skip);
0301 }
0302 
0303 /* B.2.4.1 Quantization table-specification syntax */
0304 static int jpeg_parse_quantization_tables(struct jpeg_stream *stream,
0305                       u8 precision,
0306                       struct v4l2_jpeg_reference *tables)
0307 {
0308     int len = jpeg_get_word_be(stream);
0309 
0310     if (len < 0)
0311         return len;
0312     /* Lq = 2 + n * 65 (for baseline DCT), n >= 1 */
0313     if (len < 2 + 65)
0314         return -EINVAL;
0315 
0316     len -= 2;
0317     while (len >= 65) {
0318         u8 pq, tq, *qk;
0319         int ret;
0320         int pq_tq = jpeg_get_byte(stream);
0321 
0322         if (pq_tq < 0)
0323             return pq_tq;
0324 
0325         /* quantization table element precision */
0326         pq = (pq_tq >> 4) & 0xf;
0327         /*
0328          * Only 8-bit Qk values for 8-bit sample precision. Extended
0329          * sequential DCT with 12-bit sample precision also supports
0330          * 16-bit Qk values.
0331          */
0332         if (pq != 0 && (pq != 1 || precision != 12))
0333             return -EINVAL;
0334 
0335         /* quantization table destination identifier */
0336         tq = pq_tq & 0xf;
0337         if (tq > 3)
0338             return -EINVAL;
0339 
0340         /* quantization table element */
0341         qk = stream->curr;
0342         ret = jpeg_skip(stream, pq ? 128 : 64);
0343         if (ret < 0)
0344             return -EINVAL;
0345 
0346         if (tables) {
0347             tables[tq].start = qk;
0348             tables[tq].length = pq ? 128 : 64;
0349         }
0350 
0351         len -= pq ? 129 : 65;
0352     }
0353 
0354     return 0;
0355 }
0356 
0357 /* B.2.4.2 Huffman table-specification syntax */
0358 static int jpeg_parse_huffman_tables(struct jpeg_stream *stream,
0359                      struct v4l2_jpeg_reference *tables)
0360 {
0361     int mt;
0362     int len = jpeg_get_word_be(stream);
0363 
0364     if (len < 0)
0365         return len;
0366     /* Table B.5 - Huffman table specification parameter sizes and values */
0367     if (len < 2 + 17)
0368         return -EINVAL;
0369 
0370     for (len -= 2; len >= 17; len -= 17 + mt) {
0371         u8 tc, th, *table;
0372         int tc_th = jpeg_get_byte(stream);
0373         int i, ret;
0374 
0375         if (tc_th < 0)
0376             return tc_th;
0377 
0378         /* table class - 0 = DC, 1 = AC */
0379         tc = (tc_th >> 4) & 0xf;
0380         if (tc > 1)
0381             return -EINVAL;
0382 
0383         /* huffman table destination identifier */
0384         th = tc_th & 0xf;
0385         /* only two Huffman tables for baseline DCT */
0386         if (th > 1)
0387             return -EINVAL;
0388 
0389         /* BITS - number of Huffman codes with length i */
0390         table = stream->curr;
0391         mt = 0;
0392         for (i = 0; i < 16; i++) {
0393             int li;
0394 
0395             li = jpeg_get_byte(stream);
0396             if (li < 0)
0397                 return li;
0398 
0399             mt += li;
0400         }
0401         /* HUFFVAL - values associated with each Huffman code */
0402         ret = jpeg_skip(stream, mt);
0403         if (ret < 0)
0404             return ret;
0405 
0406         if (tables) {
0407             tables[(tc << 1) | th].start = table;
0408             tables[(tc << 1) | th].length = stream->curr - table;
0409         }
0410     }
0411 
0412     return jpeg_skip(stream, len - 2);
0413 }
0414 
0415 /* B.2.4.4 Restart interval definition syntax */
0416 static int jpeg_parse_restart_interval(struct jpeg_stream *stream,
0417                        u16 *restart_interval)
0418 {
0419     int len = jpeg_get_word_be(stream);
0420     int ri;
0421 
0422     if (len < 0)
0423         return len;
0424     if (len != 4)
0425         return -EINVAL;
0426 
0427     ri = jpeg_get_word_be(stream);
0428     if (ri < 0)
0429         return ri;
0430 
0431     *restart_interval = ri;
0432 
0433     return 0;
0434 }
0435 
0436 static int jpeg_skip_segment(struct jpeg_stream *stream)
0437 {
0438     int len = jpeg_get_word_be(stream);
0439 
0440     if (len < 0)
0441         return len;
0442     if (len < 2)
0443         return -EINVAL;
0444 
0445     return jpeg_skip(stream, len - 2);
0446 }
0447 
0448 /* Rec. ITU-T T.872 (06/2012) 6.5.3 */
0449 static int jpeg_parse_app14_data(struct jpeg_stream *stream,
0450                  enum v4l2_jpeg_app14_tf *tf)
0451 {
0452     int ret;
0453     int lp;
0454     int skip;
0455 
0456     lp = jpeg_get_word_be(stream);
0457     if (lp < 0)
0458         return lp;
0459 
0460     /* Check for "Adobe\0" in Ap1..6 */
0461     if (stream->curr + 6 > stream->end ||
0462         strncmp(stream->curr, "Adobe\0", 6))
0463         return -EINVAL;
0464 
0465     /* get to Ap12 */
0466     ret = jpeg_skip(stream, 11);
0467     if (ret < 0)
0468         return ret;
0469 
0470     ret = jpeg_get_byte(stream);
0471     if (ret < 0)
0472         return ret;
0473 
0474     *tf = ret;
0475 
0476     /* skip the rest of the segment, this ensures at least it is complete */
0477     skip = lp - 2 - 11;
0478     return jpeg_skip(stream, skip);
0479 }
0480 
0481 /**
0482  * v4l2_jpeg_parse_header - locate marker segments and optionally parse headers
0483  * @buf: address of the JPEG buffer, should start with a SOI marker
0484  * @len: length of the JPEG buffer
0485  * @out: returns marker segment positions and optionally parsed headers
0486  *
0487  * The out->scan_header pointer must be initialized to NULL or point to a valid
0488  * v4l2_jpeg_scan_header structure. The out->huffman_tables and
0489  * out->quantization_tables pointers must be initialized to NULL or point to a
0490  * valid array of 4 v4l2_jpeg_reference structures each.
0491  *
0492  * Returns 0 or negative error if parsing failed.
0493  */
0494 int v4l2_jpeg_parse_header(void *buf, size_t len, struct v4l2_jpeg_header *out)
0495 {
0496     struct jpeg_stream stream;
0497     int marker;
0498     int ret = 0;
0499 
0500     stream.curr = buf;
0501     stream.end = stream.curr + len;
0502 
0503     out->num_dht = 0;
0504     out->num_dqt = 0;
0505 
0506     /* the first bytes must be SOI, B.2.1 High-level syntax */
0507     if (jpeg_get_word_be(&stream) != SOI)
0508         return -EINVAL;
0509 
0510     /* init value to signal if this marker is not present */
0511     out->app14_tf = V4L2_JPEG_APP14_TF_UNKNOWN;
0512 
0513     /* loop through marker segments */
0514     while ((marker = jpeg_next_marker(&stream)) >= 0) {
0515         switch (marker) {
0516         /* baseline DCT, extended sequential DCT */
0517         case SOF0 ... SOF1:
0518             ret = jpeg_reference_segment(&stream, &out->sof);
0519             if (ret < 0)
0520                 return ret;
0521             ret = jpeg_parse_frame_header(&stream, marker,
0522                               &out->frame);
0523             break;
0524         /* progressive, lossless */
0525         case SOF2 ... SOF3:
0526         /* differential coding */
0527         case SOF5 ... SOF7:
0528         /* arithmetic coding */
0529         case SOF9 ... SOF11:
0530         case SOF13 ... SOF15:
0531         case DAC:
0532         case TEM:
0533             return -EINVAL;
0534 
0535         case DHT:
0536             ret = jpeg_reference_segment(&stream,
0537                     &out->dht[out->num_dht++ % 4]);
0538             if (ret < 0)
0539                 return ret;
0540             if (!out->huffman_tables) {
0541                 ret = jpeg_skip_segment(&stream);
0542                 break;
0543             }
0544             ret = jpeg_parse_huffman_tables(&stream,
0545                             out->huffman_tables);
0546             break;
0547         case DQT:
0548             ret = jpeg_reference_segment(&stream,
0549                     &out->dqt[out->num_dqt++ % 4]);
0550             if (ret < 0)
0551                 return ret;
0552             if (!out->quantization_tables) {
0553                 ret = jpeg_skip_segment(&stream);
0554                 break;
0555             }
0556             ret = jpeg_parse_quantization_tables(&stream,
0557                     out->frame.precision,
0558                     out->quantization_tables);
0559             break;
0560         case DRI:
0561             ret = jpeg_parse_restart_interval(&stream,
0562                             &out->restart_interval);
0563             break;
0564         case APP14:
0565             ret = jpeg_parse_app14_data(&stream,
0566                             &out->app14_tf);
0567             break;
0568         case SOS:
0569             ret = jpeg_reference_segment(&stream, &out->sos);
0570             if (ret < 0)
0571                 return ret;
0572             ret = jpeg_parse_scan_header(&stream, out->scan);
0573             /*
0574              * stop parsing, the scan header marks the beginning of
0575              * the entropy coded segment
0576              */
0577             out->ecs_offset = stream.curr - (u8 *)buf;
0578             return ret;
0579 
0580         /* markers without parameters */
0581         case RST0 ... RST7: /* restart */
0582         case SOI: /* start of image */
0583         case EOI: /* end of image */
0584             break;
0585 
0586         /* skip unknown or unsupported marker segments */
0587         default:
0588             ret = jpeg_skip_segment(&stream);
0589             break;
0590         }
0591         if (ret < 0)
0592             return ret;
0593     }
0594 
0595     return marker;
0596 }
0597 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_header);
0598 
0599 /**
0600  * v4l2_jpeg_parse_frame_header - parse frame header
0601  * @buf: address of the frame header, after the SOF0 marker
0602  * @len: length of the frame header
0603  * @frame_header: returns the parsed frame header
0604  *
0605  * Returns 0 or negative error if parsing failed.
0606  */
0607 int v4l2_jpeg_parse_frame_header(void *buf, size_t len,
0608                  struct v4l2_jpeg_frame_header *frame_header)
0609 {
0610     struct jpeg_stream stream;
0611 
0612     stream.curr = buf;
0613     stream.end = stream.curr + len;
0614     return jpeg_parse_frame_header(&stream, SOF0, frame_header);
0615 }
0616 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_frame_header);
0617 
0618 /**
0619  * v4l2_jpeg_parse_scan_header - parse scan header
0620  * @buf: address of the scan header, after the SOS marker
0621  * @len: length of the scan header
0622  * @scan_header: returns the parsed scan header
0623  *
0624  * Returns 0 or negative error if parsing failed.
0625  */
0626 int v4l2_jpeg_parse_scan_header(void *buf, size_t len,
0627                 struct v4l2_jpeg_scan_header *scan_header)
0628 {
0629     struct jpeg_stream stream;
0630 
0631     stream.curr = buf;
0632     stream.end = stream.curr + len;
0633     return jpeg_parse_scan_header(&stream, scan_header);
0634 }
0635 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_scan_header);
0636 
0637 /**
0638  * v4l2_jpeg_parse_quantization_tables - parse quantization tables segment
0639  * @buf: address of the quantization table segment, after the DQT marker
0640  * @len: length of the quantization table segment
0641  * @precision: sample precision (P) in bits per component
0642  * @q_tables: returns four references into the buffer for the
0643  *            four possible quantization table destinations
0644  *
0645  * Returns 0 or negative error if parsing failed.
0646  */
0647 int v4l2_jpeg_parse_quantization_tables(void *buf, size_t len, u8 precision,
0648                     struct v4l2_jpeg_reference *q_tables)
0649 {
0650     struct jpeg_stream stream;
0651 
0652     stream.curr = buf;
0653     stream.end = stream.curr + len;
0654     return jpeg_parse_quantization_tables(&stream, precision, q_tables);
0655 }
0656 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_quantization_tables);
0657 
0658 /**
0659  * v4l2_jpeg_parse_huffman_tables - parse huffman tables segment
0660  * @buf: address of the Huffman table segment, after the DHT marker
0661  * @len: length of the Huffman table segment
0662  * @huffman_tables: returns four references into the buffer for the
0663  *                  four possible Huffman table destinations, in
0664  *                  the order DC0, DC1, AC0, AC1
0665  *
0666  * Returns 0 or negative error if parsing failed.
0667  */
0668 int v4l2_jpeg_parse_huffman_tables(void *buf, size_t len,
0669                    struct v4l2_jpeg_reference *huffman_tables)
0670 {
0671     struct jpeg_stream stream;
0672 
0673     stream.curr = buf;
0674     stream.end = stream.curr + len;
0675     return jpeg_parse_huffman_tables(&stream, huffman_tables);
0676 }
0677 EXPORT_SYMBOL_GPL(v4l2_jpeg_parse_huffman_tables);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!