Paparazzi UAS  v7.0_unstable
Paparazzi is a free software Unmanned Aircraft System.
jpeg.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2  * jpeg.c - JPEG compression for SRV-1 robot
3  * Copyright (C) 2005-2009 Surveyor Corporation
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details (www.gnu.org/licenses)
14  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 #include "jpeg.h"
17 
23 static inline unsigned char svs_size_code(int w)
24 {
25  // 1=(40,30) 2=(128,96) 3=(160,120) 5=(320,240) 7=(640,480) 9=(1280,1024);
26  if (w <= 40) {
27  return '1';
28  }
29  if (w <= 128) {
30  return '2';
31  }
32  if (w <= 160) {
33  return '3';
34  }
35  if (w <= 320) {
36  return '4';
37  }
38  if (w <= 640) {
39  return '7';
40  }
41  return '9';
42 }
43 
44 int jpeg_create_svs_header(unsigned char *jpegbuf, int32_t size, int w)
45 {
46  // SVS Surveyor Jpeg UDP format
47  uint32_t s = size;
48  uint8_t *p = (uint8_t *) & s;
49  jpegbuf[0] = '#';
50  jpegbuf[1] = '#';
51  jpegbuf[2] = 'I';
52  jpegbuf[3] = 'M';
53  jpegbuf[4] = 'J';
54  jpegbuf[5] = svs_size_code(w);
55  jpegbuf[6] = p[0];
56  jpegbuf[7] = p[1];
57  jpegbuf[8] = p[2];
58  jpegbuf[9] = 0x00;
59  return size + 10;
60 }
61 
62 
63 #define JPEG_BLOCK_SIZE 64
64 
65 
66 typedef struct JPEG_ENCODER_STRUCTURE {
67 
68  // Encoder
69  uint16_t mcu_width;
70  uint16_t mcu_height;
71  uint16_t horizontal_mcus;
72  uint16_t vertical_mcus;
73  uint16_t cols_in_right_mcus;
74  uint16_t rows_in_bottom_mcus;
75 
76  uint16_t rows;
77  uint16_t cols;
78 
79  uint16_t length_minus_mcu_width;
80  uint16_t length_minus_width;
81  uint16_t incr;
82  uint16_t mcu_width_size;
83  uint16_t offset;
84 
85  int16_t ldc1;
86  int16_t ldc2;
87  int16_t ldc3;
88 
89  // Tables
90  uint8_t Lqt [JPEG_BLOCK_SIZE];
91  uint8_t Cqt [JPEG_BLOCK_SIZE];
92  uint16_t ILqt [JPEG_BLOCK_SIZE];
93  uint16_t ICqt [JPEG_BLOCK_SIZE];
94 
95  int16_t Y1 [JPEG_BLOCK_SIZE];
96  int16_t Y2 [JPEG_BLOCK_SIZE];
97  int16_t CB [JPEG_BLOCK_SIZE];
98  int16_t CR [JPEG_BLOCK_SIZE];
99  int16_t Temp [JPEG_BLOCK_SIZE];
100 
101  uint32_t lcode;
102  uint16_t bitindex;
103 
104 } JPEG_ENCODER_STRUCTURE;
105 
106 
107 static void jpeg_initialization(JPEG_ENCODER_STRUCTURE *, uint32_t, uint32_t, uint32_t);
108 
109 static uint8_t *jpeg_write_markers(JPEG_ENCODER_STRUCTURE *, uint8_t *, uint32_t, uint32_t, uint32_t);
110 
111 static void jpeg_read_400_format(JPEG_ENCODER_STRUCTURE *, uint8_t *);
112 static void jpeg_read_422_format(JPEG_ENCODER_STRUCTURE *, uint8_t *);
113 
114 static uint8_t *jpeg_encodeMCU(JPEG_ENCODER_STRUCTURE *, uint32_t, uint8_t *);
115 
116 static void jpeg_levelshift(int16_t *);
117 static void jpeg_DCT(int16_t *);
118 
119 static void jpeg_quantization(JPEG_ENCODER_STRUCTURE *, int16_t *, uint16_t *);
120 static uint8_t *jpeg_huffman(JPEG_ENCODER_STRUCTURE *, uint16_t, uint8_t *);
121 
122 static uint8_t *jpeg_close_bitstream(JPEG_ENCODER_STRUCTURE *, uint8_t *);
123 
124 static const uint16_t luminance_dc_code_table [] = {
125  0x0000, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006,
126  0x000E, 0x001E, 0x003E, 0x007E, 0x00FE, 0x01FE
127 };
128 
129 static const uint16_t luminance_dc_size_table [] = {
130  0x0002, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
131  0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009
132 };
133 
134 static const uint16_t chrominance_dc_code_table [] = {
135  0x0000, 0x0001, 0x0002, 0x0006, 0x000E, 0x001E,
136  0x003E, 0x007E, 0x00FE, 0x01FE, 0x03FE, 0x07FE
137 };
138 
139 static const uint16_t chrominance_dc_size_table [] = {
140  0x0002, 0x0002, 0x0002, 0x0003, 0x0004, 0x0005,
141  0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B
142 };
143 
144 static const uint16_t luminance_ac_code_table [] = {
145  0x000A,
146  0x0000, 0x0001, 0x0004, 0x000B, 0x001A, 0x0078, 0x00F8, 0x03F6, 0xFF82, 0xFF83,
147  0x000C, 0x001B, 0x0079, 0x01F6, 0x07F6, 0xFF84, 0xFF85, 0xFF86, 0xFF87, 0xFF88,
148  0x001C, 0x00F9, 0x03F7, 0x0FF4, 0xFF89, 0xFF8A, 0xFF8b, 0xFF8C, 0xFF8D, 0xFF8E,
149  0x003A, 0x01F7, 0x0FF5, 0xFF8F, 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95,
150  0x003B, 0x03F8, 0xFF96, 0xFF97, 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D,
151  0x007A, 0x07F7, 0xFF9E, 0xFF9F, 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5,
152  0x007B, 0x0FF6, 0xFFA6, 0xFFA7, 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD,
153  0x00FA, 0x0FF7, 0xFFAE, 0xFFAF, 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5,
154  0x01F8, 0x7FC0, 0xFFB6, 0xFFB7, 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD,
155  0x01F9, 0xFFBE, 0xFFBF, 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6,
156  0x01FA, 0xFFC7, 0xFFC8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF,
157  0x03F9, 0xFFD0, 0xFFD1, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7, 0xFFD8,
158  0x03FA, 0xFFD9, 0xFFDA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF, 0xFFE0, 0xFFE1,
159  0x07F8, 0xFFE2, 0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA,
160  0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF, 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4,
161  0xFFF5, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE,
162  0x07F9
163 };
164 
165 static const uint16_t luminance_ac_size_table [] = {
166  0x0004,
167  0x0002, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0008, 0x000A, 0x0010, 0x0010,
168  0x0004, 0x0005, 0x0007, 0x0009, 0x000B, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
169  0x0005, 0x0008, 0x000A, 0x000C, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
170  0x0006, 0x0009, 0x000C, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
171  0x0006, 0x000A, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
172  0x0007, 0x000B, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
173  0x0007, 0x000C, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
174  0x0008, 0x000C, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
175  0x0009, 0x000F, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
176  0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
177  0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
178  0x000A, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
179  0x000A, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
180  0x000B, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
181  0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
182  0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
183  0x000B
184 };
185 
186 static const uint16_t chrominance_ac_code_table [] = {
187  0x0000,
188  0x0001, 0x0004, 0x000A, 0x0018, 0x0019, 0x0038, 0x0078, 0x01F4, 0x03F6, 0x0FF4,
189  0x000B, 0x0039, 0x00F6, 0x01F5, 0x07F6, 0x0FF5, 0xFF88, 0xFF89, 0xFF8A, 0xFF8B,
190  0x001A, 0x00F7, 0x03F7, 0x0FF6, 0x7FC2, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F, 0xFF90,
191  0x001B, 0x00F8, 0x03F8, 0x0FF7, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96,
192  0x003A, 0x01F6, 0xFF97, 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E,
193  0x003B, 0x03F9, 0xFF9F, 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6,
194  0x0079, 0x07F7, 0xFFA7, 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE,
195  0x007A, 0x07F8, 0xFFAF, 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5, 0xFFB6,
196  0x00F9, 0xFFB7, 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD, 0xFFBE, 0xFFBF,
197  0x01F7, 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7, 0xFFC8,
198  0x01F8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF, 0xFFD0, 0xFFD1,
199  0x01F9, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7, 0xFFD8, 0xFFD9, 0xFFDA,
200  0x01FA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF, 0xFFE0, 0xFFE1, 0xFFE2, 0xFFE3,
201  0x07F9, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEb, 0xFFEC,
202  0x3FE0, 0xFFED, 0xFFEE, 0xFFEF, 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5,
203  0x7FC3, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE,
204  0x03FA
205 };
206 
207 static const uint16_t chrominance_ac_size_table [] = {
208  0x0002,
209  0x0002, 0x0003, 0x0004, 0x0005, 0x0005, 0x0006, 0x0007, 0x0009, 0x000A, 0x000C,
210  0x0004, 0x0006, 0x0008, 0x0009, 0x000B, 0x000C, 0x0010, 0x0010, 0x0010, 0x0010,
211  0x0005, 0x0008, 0x000A, 0x000C, 0x000F, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
212  0x0005, 0x0008, 0x000A, 0x000C, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
213  0x0006, 0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
214  0x0006, 0x000A, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
215  0x0007, 0x000B, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
216  0x0007, 0x000B, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
217  0x0008, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
218  0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
219  0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
220  0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
221  0x0009, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
222  0x000B, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
223  0x000E, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
224  0x000F, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
225  0x000A
226 };
227 
228 static const uint8_t bitsize [] = {
229  0, 1, 2, 2, 3, 3, 3, 3,
230  4, 4, 4, 4, 4, 4, 4, 4,
231  5, 5, 5, 5, 5, 5, 5, 5,
232  5, 5, 5, 5, 5, 5, 5, 5,
233  6, 6, 6, 6, 6, 6, 6, 6,
234  6, 6, 6, 6, 6, 6, 6, 6,
235  6, 6, 6, 6, 6, 6, 6, 6,
236  6, 6, 6, 6, 6, 6, 6, 6,
237  7, 7, 7, 7, 7, 7, 7, 7,
238  7, 7, 7, 7, 7, 7, 7, 7,
239  7, 7, 7, 7, 7, 7, 7, 7,
240  7, 7, 7, 7, 7, 7, 7, 7,
241  7, 7, 7, 7, 7, 7, 7, 7,
242  7, 7, 7, 7, 7, 7, 7, 7,
243  7, 7, 7, 7, 7, 7, 7, 7,
244  7, 7, 7, 7, 7, 7, 7, 7,
245  8, 8, 8, 8, 8, 8, 8, 8,
246  8, 8, 8, 8, 8, 8, 8, 8,
247  8, 8, 8, 8, 8, 8, 8, 8,
248  8, 8, 8, 8, 8, 8, 8, 8,
249  8, 8, 8, 8, 8, 8, 8, 8,
250  8, 8, 8, 8, 8, 8, 8, 8,
251  8, 8, 8, 8, 8, 8, 8, 8,
252  8, 8, 8, 8, 8, 8, 8, 8,
253  8, 8, 8, 8, 8, 8, 8, 8,
254  8, 8, 8, 8, 8, 8, 8, 8,
255  8, 8, 8, 8, 8, 8, 8, 8,
256  8, 8, 8, 8, 8, 8, 8, 8,
257  8, 8, 8, 8, 8, 8, 8, 8,
258  8, 8, 8, 8, 8, 8, 8, 8,
259  8, 8, 8, 8, 8, 8, 8, 8,
260  8, 8, 8, 8, 8, 8, 8, 8
261 };
262 
263 static const uint8_t markerdata [] = {
264  0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
265 
266  0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
267 
268  0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
269 
270  0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
271 };
272 
273 
274 static const uint8_t zigzag_table [] = {
275  0, 1, 5, 6, 14, 15, 27, 28,
276  2, 4, 7, 13, 16, 26, 29, 42,
277  3, 8, 12, 17, 25, 30, 41, 43,
278  9, 11, 18, 24, 31, 40, 44, 53,
279  10, 19, 23, 32, 39, 45, 52, 54,
280  20, 22, 33, 38, 46, 51, 55, 60,
281  21, 34, 37, 47, 50, 56, 59, 61,
282  35, 36, 48, 49, 57, 58, 62, 63
283 };
284 
285 
286 void (*read_format)(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *input_ptr);
287 
288 static void jpeg_initialization(JPEG_ENCODER_STRUCTURE *jpeg, uint32_t image_format, uint32_t image_width, uint32_t image_height)
289 {
290  uint16_t mcu_width, mcu_height, bytes_per_pixel;
291 
292  jpeg->lcode = 0;
293  jpeg->bitindex = 0;
294 
295  if (image_format == FOUR_ZERO_ZERO) {
296  jpeg->mcu_width = mcu_width = 8;
297  jpeg->mcu_height = mcu_height = 8;
298 
299  jpeg->horizontal_mcus = (uint16_t)((image_width + mcu_width - 1) >> 3);
300  jpeg->vertical_mcus = (uint16_t)((image_height + mcu_height - 1) >> 3);
301 
302  bytes_per_pixel = 1;
303  read_format = jpeg_read_400_format;
304  } else {
305  jpeg->mcu_width = mcu_width = 16;
306  jpeg->horizontal_mcus = (uint16_t)((image_width + mcu_width - 1) >> 4);
307 
308  jpeg->mcu_height = mcu_height = 8;
309  jpeg->vertical_mcus = (uint16_t)((image_height + mcu_height - 1) >> 3);
310  bytes_per_pixel = 2;
311  read_format = jpeg_read_422_format;
312  }
313 
314  jpeg->rows_in_bottom_mcus = (uint16_t)(image_height - (jpeg->vertical_mcus - 1) * mcu_height);
315  jpeg->cols_in_right_mcus = (uint16_t)(image_width - (jpeg->horizontal_mcus - 1) * mcu_width);
316 
317  jpeg->length_minus_mcu_width = (uint16_t)((image_width - mcu_width) * bytes_per_pixel);
318  jpeg->length_minus_width = (uint16_t)((image_width - jpeg->cols_in_right_mcus) * bytes_per_pixel);
319 
320  jpeg->mcu_width_size = (uint16_t)(mcu_width * bytes_per_pixel);
321 
322  jpeg->offset = (uint16_t)((image_width * (mcu_height - 1) - (mcu_width - jpeg->cols_in_right_mcus)) * bytes_per_pixel);
323 
324  jpeg->ldc1 = 0;
325  jpeg->ldc2 = 0;
326  jpeg->ldc3 = 0;
327 
328  jpeg->lcode = 0;
329  jpeg->bitindex = 0;
330 }
331 
333 
335 // Q = 0-99
336 
337 /*
338  * Table K.1 from JPEG spec.
339  */
340 static const int jpeg_luma_quantizer[64] = {
341  16, 11, 10, 16, 24, 40, 51, 61,
342  12, 12, 14, 19, 26, 58, 60, 55,
343  14, 13, 16, 24, 40, 57, 69, 56,
344  14, 17, 22, 29, 51, 87, 80, 62,
345  18, 22, 37, 56, 68, 109, 103, 77,
346  24, 35, 55, 64, 81, 104, 113, 92,
347  49, 64, 78, 87, 103, 121, 120, 101,
348  72, 92, 95, 98, 112, 100, 103, 99
349 };
350 
351 /*
352  * Table K.2 from JPEG spec.
353  */
354 static const int jpeg_chroma_quantizer[64] = {
355  17, 18, 24, 47, 99, 99, 99, 99,
356  18, 21, 26, 66, 99, 99, 99, 99,
357  24, 26, 56, 99, 99, 99, 99, 99,
358  47, 66, 99, 99, 99, 99, 99, 99,
359  99, 99, 99, 99, 99, 99, 99, 99,
360  99, 99, 99, 99, 99, 99, 99, 99,
361  99, 99, 99, 99, 99, 99, 99, 99,
362  99, 99, 99, 99, 99, 99, 99, 99
363 };
364 
365 /*
366  * Call MakeTables with the Q factor and two u_char[64] return arrays
367  */
368 void MakeTables(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, int q);
369 void MakeTables(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, int q)
370 {
371  int i;
372  int factor = q;
373 
374  if (q < 1) { factor = 1; }
375  if (q > 99) { factor = 99; }
376  if (q < 50) {
377  q = 5000 / factor;
378  } else {
379  q = 200 - factor * 2;
380  }
381 
382 
383  for (i = 0; i < 64; i++) {
384  int lq = (jpeg_luma_quantizer[i] * q + 50) / 100;
385  int cq = (jpeg_chroma_quantizer[i] * q + 50) / 100;
386 
387  /* Limit the quantizers to 1 <= q <= 255 */
388  if (lq < 1) { lq = 1; }
389  else if (lq > 255) { lq = 255; }
390  jpeg_encoder_structure->Lqt [i] = (uint8_t) lq;
391  jpeg_encoder_structure->ILqt [i] = 0x8000 / lq;
392 
393  if (cq < 1) { cq = 1; }
394  else if (cq > 255) { cq = 255; }
395  jpeg_encoder_structure->Cqt [i] = (uint8_t) cq;
396  //ICqt [i] = DSP_Division (0x8000, value);
397  jpeg_encoder_structure->ICqt [i] = 0x8000 / cq;
398  }
399 }
400 
408 void jpeg_encode_image(struct image_t *in, struct image_t *out, uint32_t quality_factor, bool add_dri_header)
409 {
410  uint16_t i, j;
411  uint8_t *output_ptr = out->buf;
412  uint8_t *input_ptr = in->buf;
413  uint32_t image_format = FOUR_ZERO_ZERO;
414 
415  if (in->type == IMAGE_YUV422) {
416  image_format = FOUR_TWO_TWO;
417  }
418  else if (in->type == IMAGE_GRAYSCALE) {
419  image_format = FOUR_ZERO_ZERO;
420  }
421 
422  JPEG_ENCODER_STRUCTURE JpegStruct;
423  JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure = &JpegStruct;
424 
425  /* Initialization of JPEG control structure */
426  jpeg_initialization(jpeg_encoder_structure, image_format, in->w, in->h);
427 
428  /* Quantization Table Initialization */
429  //jpeg_initialize_quantization_tables (quality_factor);
430 
431  MakeTables(jpeg_encoder_structure, quality_factor);
432 
433  /* Writing Marker Data */
434  if (add_dri_header) {
435  output_ptr = jpeg_write_markers(jpeg_encoder_structure, output_ptr, image_format, in->w, in->h);
436  }
437 
438  for (i = 1; i <= jpeg_encoder_structure->vertical_mcus; i++) {
439  if (i < jpeg_encoder_structure->vertical_mcus) {
440  jpeg_encoder_structure->rows = jpeg_encoder_structure->mcu_height;
441  } else {
442  jpeg_encoder_structure->rows = jpeg_encoder_structure->rows_in_bottom_mcus;
443  }
444 
445  for (j = 1; j <= jpeg_encoder_structure->horizontal_mcus; j++) {
446  if (j < jpeg_encoder_structure->horizontal_mcus) {
447  jpeg_encoder_structure->cols = jpeg_encoder_structure->mcu_width;
448  jpeg_encoder_structure->incr = jpeg_encoder_structure->length_minus_mcu_width;
449  } else {
450  jpeg_encoder_structure->cols = jpeg_encoder_structure->cols_in_right_mcus;
451  jpeg_encoder_structure->incr = jpeg_encoder_structure->length_minus_width;
452  }
453 
454  read_format(jpeg_encoder_structure, input_ptr);
455 
456  /* Encode the data in MCU */
457  output_ptr = jpeg_encodeMCU(jpeg_encoder_structure, image_format, output_ptr);
458 
459  input_ptr += jpeg_encoder_structure->mcu_width_size;
460  }
461 
462  input_ptr += jpeg_encoder_structure->offset;
463  }
464 
465  /* Close Routine */
466  output_ptr = jpeg_close_bitstream(jpeg_encoder_structure, output_ptr);
467  out->w = in->w;
468  out->h = in->h;
469  out->buf_size = output_ptr - (uint8_t *)out->buf;
470 }
471 
472 static uint8_t *jpeg_encodeMCU(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint32_t image_format, uint8_t *output_ptr)
473 {
474  jpeg_levelshift(jpeg_encoder_structure->Y1);
475  jpeg_DCT(jpeg_encoder_structure->Y1);
476  jpeg_quantization(jpeg_encoder_structure, jpeg_encoder_structure->Y1, jpeg_encoder_structure->ILqt);
477  output_ptr = jpeg_huffman(jpeg_encoder_structure, 1, output_ptr);
478 
479  if (image_format == FOUR_TWO_TWO) {
480  jpeg_levelshift(jpeg_encoder_structure->Y2);
481  jpeg_DCT(jpeg_encoder_structure->Y2);
482  jpeg_quantization(jpeg_encoder_structure, jpeg_encoder_structure->Y2, jpeg_encoder_structure->ILqt);
483  output_ptr = jpeg_huffman(jpeg_encoder_structure, 1, output_ptr);
484 
485  jpeg_levelshift(jpeg_encoder_structure->CB);
486  jpeg_DCT(jpeg_encoder_structure->CB);
487  jpeg_quantization(jpeg_encoder_structure, jpeg_encoder_structure->CB, jpeg_encoder_structure->ICqt);
488  output_ptr = jpeg_huffman(jpeg_encoder_structure, 2, output_ptr);
489 
490  jpeg_levelshift(jpeg_encoder_structure->CR);
491  jpeg_DCT(jpeg_encoder_structure->CR);
492  jpeg_quantization(jpeg_encoder_structure, jpeg_encoder_structure->CR, jpeg_encoder_structure->ICqt);
493  output_ptr = jpeg_huffman(jpeg_encoder_structure, 3, output_ptr);
494  }
495  return output_ptr;
496 }
497 
498 /* Level shifting to get 8 bit SIGNED values for the data */
499 static void jpeg_levelshift(int16_t *const data)
500 {
501  int16_t i;
502 
503  for (i = 63; i >= 0; i--) {
504  data [i] -= 128;
505  }
506 }
507 
508 /* DCT for One block(8x8) */
509 static void jpeg_DCT(int16_t *data)
510 {
511  //_r8x8dct(data, fdct_coeff, fdct_temp);
512 
513 
514  uint16_t i;
515  int32_t x0, x1, x2, x3, x4, x5, x6, x7, x8;
516 
517  static const uint16_t c1 = 1420; // cos PI/16 * root(2)
518  static const uint16_t c2 = 1338; // cos PI/8 * root(2)
519  static const uint16_t c3 = 1204; // cos 3PI/16 * root(2)
520  static const uint16_t c5 = 805; // cos 5PI/16 * root(2)
521  static const uint16_t c6 = 554; // cos 3PI/8 * root(2)
522  static const uint16_t c7 = 283; // cos 7PI/16 * root(2)
523 
524  static const uint16_t s1 = 3;
525  static const uint16_t s2 = 10;
526  static const uint16_t s3 = 13;
527 
528  for (i = 8; i > 0; i--) {
529  x8 = data [0] + data [7];
530  x0 = data [0] - data [7];
531 
532  x7 = data [1] + data [6];
533  x1 = data [1] - data [6];
534 
535  x6 = data [2] + data [5];
536  x2 = data [2] - data [5];
537 
538  x5 = data [3] + data [4];
539  x3 = data [3] - data [4];
540 
541  x4 = x8 + x5;
542  x8 -= x5;
543 
544  x5 = x7 + x6;
545  x7 -= x6;
546 
547  data [0] = (int16_t)(x4 + x5);
548  data [4] = (int16_t)(x4 - x5);
549 
550  data [2] = (int16_t)((x8 * c2 + x7 * c6) >> s2);
551  data [6] = (int16_t)((x8 * c6 - x7 * c2) >> s2);
552 
553  data [7] = (int16_t)((x0 * c7 - x1 * c5 + x2 * c3 - x3 * c1) >> s2);
554  data [5] = (int16_t)((x0 * c5 - x1 * c1 + x2 * c7 + x3 * c3) >> s2);
555  data [3] = (int16_t)((x0 * c3 - x1 * c7 - x2 * c1 - x3 * c5) >> s2);
556  data [1] = (int16_t)((x0 * c1 + x1 * c3 + x2 * c5 + x3 * c7) >> s2);
557 
558  data += 8;
559  }
560 
561  data -= 64;
562 
563  for (i = 8; i > 0; i--) {
564  x8 = data [0] + data [56];
565  x0 = data [0] - data [56];
566 
567  x7 = data [8] + data [48];
568  x1 = data [8] - data [48];
569 
570  x6 = data [16] + data [40];
571  x2 = data [16] - data [40];
572 
573  x5 = data [24] + data [32];
574  x3 = data [24] - data [32];
575 
576  x4 = x8 + x5;
577  x8 -= x5;
578 
579  x5 = x7 + x6;
580  x7 -= x6;
581 
582  data [0] = (int16_t)((x4 + x5) >> s1);
583  data [32] = (int16_t)((x4 - x5) >> s1);
584 
585  data [16] = (int16_t)((x8 * c2 + x7 * c6) >> s3);
586  data [48] = (int16_t)((x8 * c6 - x7 * c2) >> s3);
587 
588  data [56] = (int16_t)((x0 * c7 - x1 * c5 + x2 * c3 - x3 * c1) >> s3);
589  data [40] = (int16_t)((x0 * c5 - x1 * c1 + x2 * c7 + x3 * c3) >> s3);
590  data [24] = (int16_t)((x0 * c3 - x1 * c7 - x2 * c1 - x3 * c5) >> s3);
591  data [8] = (int16_t)((x0 * c1 + x1 * c3 + x2 * c5 + x3 * c7) >> s3);
592 
593  data++;
594  }
595 }
596 
597 #pragma GCC diagnostic ignored "-Wmisleading-indentation"
598 
599 #define PUTBITS \
600  { \
601  bits_in_next_word = (int16_t) (jpeg_encoder_structure->bitindex + numbits - 32); \
602  if (bits_in_next_word < 0) \
603  { \
604  jpeg_encoder_structure->lcode = (jpeg_encoder_structure->lcode << numbits) | data; \
605  jpeg_encoder_structure->bitindex += numbits; \
606  } \
607  else \
608  { \
609  jpeg_encoder_structure->lcode = (jpeg_encoder_structure->lcode << (32 - jpeg_encoder_structure->bitindex)) | (data >> bits_in_next_word); \
610  if ((*output_ptr++ = (uint8_t)(jpeg_encoder_structure->lcode >> 24)) == 0xff) \
611  *output_ptr++ = 0; \
612  if ((*output_ptr++ = (uint8_t)(jpeg_encoder_structure->lcode >> 16)) == 0xff) \
613  *output_ptr++ = 0; \
614  if ((*output_ptr++ = (uint8_t)(jpeg_encoder_structure->lcode >> 8)) == 0xff) \
615  *output_ptr++ = 0; \
616  if ((*output_ptr++ = (uint8_t) jpeg_encoder_structure->lcode) == 0xff) \
617  *output_ptr++ = 0; \
618  jpeg_encoder_structure->lcode = data; \
619  jpeg_encoder_structure->bitindex = bits_in_next_word; \
620  } \
621  }
622 
623 static uint8_t *jpeg_huffman(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint16_t component, uint8_t *output_ptr)
624 {
625  uint16_t i;
626  const uint16_t *DcCodeTable, *DcSizeTable, *AcCodeTable, *AcSizeTable;
627 
628  int16_t *Temp_Ptr, Coeff, LastDc;
629  uint16_t AbsCoeff, HuffCode, HuffSize, RunLength = 0, DataSize = 0, index;
630 
631  int16_t bits_in_next_word;
632  uint16_t numbits;
633  uint32_t data;
634 
635  Temp_Ptr = jpeg_encoder_structure->Temp;
636  Coeff = *Temp_Ptr++;
637 
638  if (component == 1) {
639  DcCodeTable = luminance_dc_code_table;
640  DcSizeTable = luminance_dc_size_table;
641  AcCodeTable = luminance_ac_code_table;
642  AcSizeTable = luminance_ac_size_table;
643 
644  LastDc = jpeg_encoder_structure->ldc1;
645  jpeg_encoder_structure->ldc1 = Coeff;
646  } else {
647  DcCodeTable = chrominance_dc_code_table;
648  DcSizeTable = chrominance_dc_size_table;
649  AcCodeTable = chrominance_ac_code_table;
650  AcSizeTable = chrominance_ac_size_table;
651 
652  if (component == 2) {
653  LastDc = jpeg_encoder_structure->ldc2;
654  jpeg_encoder_structure->ldc2 = Coeff;
655  } else {
656  LastDc = jpeg_encoder_structure->ldc3;
657  jpeg_encoder_structure->ldc3 = Coeff;
658  }
659  }
660 
661  Coeff -= LastDc;
662 
663  AbsCoeff = (Coeff < 0) ? -Coeff-- : Coeff;
664 
665  while (AbsCoeff != 0) {
666  AbsCoeff >>= 1;
667  DataSize++;
668  }
669 
670  HuffCode = DcCodeTable [DataSize];
671  HuffSize = DcSizeTable [DataSize];
672 
673  Coeff &= (1 << DataSize) - 1;
674  data = (HuffCode << DataSize) | Coeff;
675  numbits = HuffSize + DataSize;
676 
677  PUTBITS
678 
679  for (i = 63; i > 0; i--) {
680  if ((Coeff = *Temp_Ptr++) != 0) {
681  while (RunLength > 15) {
682  RunLength -= 16;
683  data = AcCodeTable [161];
684  numbits = AcSizeTable [161];
685  PUTBITS
686  }
687 
688  AbsCoeff = (Coeff < 0) ? -Coeff-- : Coeff;
689 
690  if (AbsCoeff >> 8 == 0) {
691  DataSize = bitsize [AbsCoeff];
692  } else {
693  DataSize = bitsize [AbsCoeff >> 8] + 8;
694  }
695 
696  index = RunLength * 10 + DataSize;
697  HuffCode = AcCodeTable [index];
698  HuffSize = AcSizeTable [index];
699 
700  Coeff &= (1 << DataSize) - 1;
701  data = (HuffCode << DataSize) | Coeff;
702  numbits = HuffSize + DataSize;
703 
704  PUTBITS
705  RunLength = 0;
706  } else {
707  RunLength++;
708  }
709  }
710 
711  if (RunLength != 0) {
712  data = AcCodeTable [0];
713  numbits = AcSizeTable [0];
714  PUTBITS
715  }
716  return output_ptr;
717 }
718 
719 #pragma GCC diagnostic pop
720 
721 /* For bit Stuffing and EOI marker */
722 static uint8_t *jpeg_close_bitstream(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *output_ptr)
723 {
724  uint16_t i, count;
725  uint8_t *ptr;
726 
727  if (jpeg_encoder_structure->bitindex > 0) {
728  jpeg_encoder_structure->lcode <<= (32 - jpeg_encoder_structure->bitindex);
729  //for (i=0; i<bitindex; i++)
730  // lcode |= (0x00000001 << i);
731 
732  count = (jpeg_encoder_structure->bitindex + 7) >> 3;
733 
734  ptr = (uint8_t *) &jpeg_encoder_structure->lcode + 3;
735 
736  for (i = 0; i < count; i++)
737  if ((*output_ptr++ = *ptr--) == 0xff) {
738  *output_ptr++ = 0;
739  }
740  }
741 
742  // End of image marker
743  *output_ptr++ = 0xFF;
744  *output_ptr++ = 0xD9;
745  return output_ptr;
746 }
747 
748 static uint8_t *jpeg_write_markers(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *output_ptr, uint32_t image_format, uint32_t image_width, uint32_t image_height)
749 {
750  uint16_t i, header_length;
751  uint8_t number_of_components;
752 
753  // Start of image marker
754  *output_ptr++ = 0xFF;
755  *output_ptr++ = 0xD8;
756 
757  // Quantization table marker
758  *output_ptr++ = 0xFF;
759  *output_ptr++ = 0xDB;
760 
761  // Quantization table length
762  *output_ptr++ = 0x00;
763  *output_ptr++ = 0x43;
764 
765  // Pq, Tq
766  *output_ptr++ = 0x00;
767 
768  // Lqt table
769  for (i = 0; i < 64; i++) {
770  *output_ptr++ = jpeg_encoder_structure->Lqt [i];
771  }
772 
773  // Quantization table marker
774  *output_ptr++ = 0xFF;
775  *output_ptr++ = 0xDB;
776 
777  // Quantization table length
778  *output_ptr++ = 0x00;
779  *output_ptr++ = 0x43;
780 
781  // Pq, Tq
782  *output_ptr++ = 0x01;
783 
784  // Cqt table
785  for (i = 0; i < 64; i++) {
786  *output_ptr++ = jpeg_encoder_structure->Cqt [i];
787  }
788 
789  if (image_format == FOUR_ZERO_ZERO) {
790  number_of_components = 1;
791  } else {
792  number_of_components = 3;
793  }
794 
795  // Frame header(SOF)
796 
797  // Start of frame marker
798  *output_ptr++ = 0xFF;
799  *output_ptr++ = 0xC0;
800 
801  header_length = (uint16_t)(8 + 3 * number_of_components);
802 
803  // Frame header length
804  *output_ptr++ = (uint8_t)(header_length >> 8);
805  *output_ptr++ = (uint8_t) header_length;
806 
807  // Precision (P)
808  *output_ptr++ = 0x08;
809 
810  // image height
811  *output_ptr++ = (uint8_t)(image_height >> 8);
812  *output_ptr++ = (uint8_t) image_height;
813 
814  // image width
815  *output_ptr++ = (uint8_t)(image_width >> 8);
816  *output_ptr++ = (uint8_t) image_width;
817 
818  // Nf
819  *output_ptr++ = number_of_components;
820 
821  if (image_format == FOUR_ZERO_ZERO) {
822  *output_ptr++ = 0x01;
823  *output_ptr++ = 0x11;
824  *output_ptr++ = 0x00;
825  } else {
826  *output_ptr++ = 0x01;
827 
828  if (image_format == FOUR_TWO_TWO) {
829  *output_ptr++ = 0x21;
830  } else {
831  *output_ptr++ = 0x11;
832  }
833 
834  *output_ptr++ = 0x00;
835 
836  *output_ptr++ = 0x02;
837  *output_ptr++ = 0x11;
838  *output_ptr++ = 0x01;
839 
840  *output_ptr++ = 0x03;
841  *output_ptr++ = 0x11;
842  *output_ptr++ = 0x01;
843  }
844 
845  // huffman table(DHT)
846 
847  for (i = 0; i < sizeof(markerdata); i++) {
848  *output_ptr++ = markerdata [i];
849  }
850 
851 
852  // Scan header(SOF)
853 
854  // Start of scan marker
855  *output_ptr++ = 0xFF;
856  *output_ptr++ = 0xDA;
857 
858  header_length = (uint16_t)(6 + (number_of_components << 1));
859 
860  // Scan header length
861  *output_ptr++ = (uint8_t)(header_length >> 8);
862  *output_ptr++ = (uint8_t) header_length;
863 
864  // Ns
865  *output_ptr++ = number_of_components;
866 
867  if (image_format == FOUR_ZERO_ZERO) {
868  *output_ptr++ = 0x01;
869  *output_ptr++ = 0x00;
870  } else {
871  *output_ptr++ = 0x01;
872  *output_ptr++ = 0x00;
873 
874  *output_ptr++ = 0x02;
875  *output_ptr++ = 0x11;
876 
877  *output_ptr++ = 0x03;
878  *output_ptr++ = 0x11;
879  }
880 
881  *output_ptr++ = 0x00;
882  *output_ptr++ = 0x3F;
883  *output_ptr++ = 0x00;
884  return output_ptr;
885 }
886 
887 /* Multiply Quantization table with quality factor to get LQT and CQT
888  factor ranges from 1 to 8; 1 = highest quality, 8 = lowest quality */
889 /*static void jpeg_initialize_quantization_tables(uint32_t quality_factor)
890 {
891  uint16_t i, index;
892  uint32_t value;
893 
894  if (quality_factor < 1) {
895  quality_factor = 1;
896  }
897  if (quality_factor > 8) {
898  quality_factor = 8;
899  }
900  quality_factor = ((quality_factor * 3) - 2) * 128; //converts range[1:8] to [1:22]
901 
902  for (i = 0; i < 64; i++) {
903  index = zigzag_table [i];
904 
905  // luminance quantization table * quality factor
906  value = luminance_quant_table [i] * quality_factor;
907  value = (value + 0x200) >> 10;
908 
909  if (value < 2) {
910  value = 2;
911  } else if (value > 255) {
912  value = 255;
913  }
914 
915  Lqt [index] = (uint8_t) value;
916  //ILqt [i] = DSP_Division (0x8000, value);
917  ILqt [i] = 0x8000 / value;
918 
919  // chrominance quantization table * quality factor
920  value = chrominance_quant_table [i] * quality_factor;
921  value = (value + 0x200) >> 10;
922 
923  if (value < 2) {
924  value = 2;
925  } else if (value > 255) {
926  value = 255;
927  }
928 
929  Cqt [index] = (uint8_t) value;
930  //ICqt [i] = DSP_Division (0x8000, value);
931  ICqt [i] = 0x8000 / value;
932  }
933 }*/
934 
935 /* multiply DCT Coefficients with Quantization table and store in ZigZag location */
936 static void jpeg_quantization(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, int16_t *const data, uint16_t *const quant_table_ptr)
937 {
938  int16_t i;
939  int32_t value;
940 
941  for (i = 63; i >= 0; i--) {
942  value = data [i] * quant_table_ptr [i];
943  value = (value + 0x4000) >> 15;
944 
945  jpeg_encoder_structure->Temp [zigzag_table [i]] = (int16_t) value;
946  }
947 }
948 
949 static void jpeg_read_400_format(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *input_ptr)
950 {
951  int32_t i, j;
952  int16_t *Y1_Ptr = jpeg_encoder_structure->Y1;
953 
954  uint16_t rows = jpeg_encoder_structure->rows;
955  uint16_t cols = jpeg_encoder_structure->cols;
956  uint16_t incr = jpeg_encoder_structure->incr;
957 
958  for (i = rows; i > 0; i--) {
959  for (j = cols; j > 0; j--) {
960  *Y1_Ptr++ = *input_ptr++;
961  }
962 
963  for (j = 8 - cols; j > 0; j--) {
964  *Y1_Ptr = *(Y1_Ptr - 1);
965  Y1_Ptr++;
966  }
967 
968  input_ptr += incr;
969  }
970 
971  for (i = 8 - rows; i > 0; i--) {
972  for (j = 8; j > 0; j--) {
973  *Y1_Ptr = *(Y1_Ptr - 8);
974  Y1_Ptr++;
975  }
976  }
977 }
978 
979 static void jpeg_read_422_format(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *input_ptr)
980 {
981  int32_t i, j;
982  uint16_t Y1_cols, Y2_cols;
983 
984  int16_t *Y1_Ptr = jpeg_encoder_structure->Y1;
985  int16_t *Y2_Ptr = jpeg_encoder_structure->Y2;
986  int16_t *CB_Ptr = jpeg_encoder_structure->CB;
987  int16_t *CR_Ptr = jpeg_encoder_structure->CR;
988 
989  uint16_t rows = jpeg_encoder_structure->rows;
990  uint16_t cols = jpeg_encoder_structure->cols;
991  uint16_t incr = jpeg_encoder_structure->incr;
992 
993  if (cols <= 8) {
994  Y1_cols = cols;
995  Y2_cols = 0;
996  } else {
997  Y1_cols = 8;
998  Y2_cols = (uint16_t)(cols - 8);
999  }
1000 
1001  for (i = rows; i > 0; i--) {
1002  for (j = Y1_cols >> 1; j > 0; j--) {
1003  *CB_Ptr++ = *input_ptr++;
1004  *Y1_Ptr++ = *input_ptr++;
1005  *CR_Ptr++ = *input_ptr++;
1006  *Y1_Ptr++ = *input_ptr++;
1007  }
1008 
1009  for (j = Y2_cols >> 1; j > 0; j--) {
1010  *CB_Ptr++ = *input_ptr++;
1011  *Y2_Ptr++ = *input_ptr++;
1012  *CR_Ptr++ = *input_ptr++;
1013  *Y2_Ptr++ = *input_ptr++;
1014  }
1015 
1016  if (cols <= 8) {
1017  for (j = 8 - Y1_cols; j > 0; j--) {
1018  *Y1_Ptr = *(Y1_Ptr - 1);
1019  Y1_Ptr++;
1020  }
1021 
1022  for (j = 8 - Y2_cols; j > 0; j--) {
1023  *Y2_Ptr = *(Y1_Ptr - 1);
1024  Y2_Ptr++;
1025  }
1026  } else {
1027  for (j = 8 - Y2_cols; j > 0; j--) {
1028  *Y2_Ptr = *(Y2_Ptr - 1);
1029  Y2_Ptr++;
1030  }
1031  }
1032 
1033  for (j = (16 - cols) >> 1; j > 0; j--) {
1034  *CB_Ptr = *(CB_Ptr - 1); CB_Ptr++;
1035  *CR_Ptr = *(CR_Ptr - 1); CR_Ptr++;
1036  }
1037 
1038  input_ptr += incr;
1039  }
1040 
1041  for (i = 8 - rows; i > 0; i--) {
1042  for (j = 8; j > 0; j--) {
1043  *Y1_Ptr = *(Y1_Ptr - 8); Y1_Ptr++;
1044  *Y2_Ptr = *(Y2_Ptr - 8); Y2_Ptr++;
1045  *CB_Ptr = *(CB_Ptr - 8); CB_Ptr++;
1046  *CR_Ptr = *(CR_Ptr - 8); CR_Ptr++;
1047  }
1048  }
1049 }
1050 
c6
static uint16_t c6
Definition: baro_MS5534A.c:203
c1
static uint16_t c1
Definition: baro_MS5534A.c:203
c3
static uint16_t c3
Definition: baro_MS5534A.c:203
c2
static uint16_t c2
Definition: baro_MS5534A.c:203
image_t::buf_size
uint32_t buf_size
The buffer size.
Definition: image.h:53
image_t::buf
void * buf
Image buffer (depending on the image_type)
Definition: image.h:54
image_t::h
uint16_t h
Image height.
Definition: image.h:47
image_t::w
uint16_t w
Image width.
Definition: image.h:46
image_t::type
enum image_type type
The image type.
Definition: image.h:45
IMAGE_GRAYSCALE
@ IMAGE_GRAYSCALE
Grayscale image with only the Y part (uint8 per pixel)
Definition: image.h:37
IMAGE_YUV422
@ IMAGE_YUV422
UYVY format (uint16 per pixel)
Definition: image.h:36
image_t
Definition: image.h:44
p
static float p[2][2]
Definition: ins_alt_float.c:257
JPEG_ENCODER_STRUCTURE::mcu_width_size
uint16_t mcu_width_size
Definition: jpeg.c:82
jpeg_write_markers
static uint8_t * jpeg_write_markers(JPEG_ENCODER_STRUCTURE *, uint8_t *, uint32_t, uint32_t, uint32_t)
Definition: jpeg.c:748
JPEG_ENCODER_STRUCTURE::lcode
uint32_t lcode
Definition: jpeg.c:101
JPEG_ENCODER_STRUCTURE::Y2
int16_t Y2[JPEG_BLOCK_SIZE]
Definition: jpeg.c:96
JPEG_ENCODER_STRUCTURE::ICqt
uint16_t ICqt[JPEG_BLOCK_SIZE]
Definition: jpeg.c:93
jpeg_quantization
static void jpeg_quantization(JPEG_ENCODER_STRUCTURE *, int16_t *, uint16_t *)
Definition: jpeg.c:936
jpeg_levelshift
static void jpeg_levelshift(int16_t *)
Definition: jpeg.c:499
jpeg_read_422_format
static void jpeg_read_422_format(JPEG_ENCODER_STRUCTURE *, uint8_t *)
Definition: jpeg.c:979
jpeg_huffman
static uint8_t * jpeg_huffman(JPEG_ENCODER_STRUCTURE *, uint16_t, uint8_t *)
Definition: jpeg.c:623
JPEG_ENCODER_STRUCTURE::Cqt
uint8_t Cqt[JPEG_BLOCK_SIZE]
Definition: jpeg.c:91
JPEG_ENCODER_STRUCTURE::ILqt
uint16_t ILqt[JPEG_BLOCK_SIZE]
Definition: jpeg.c:92
JPEG_ENCODER_STRUCTURE::cols_in_right_mcus
uint16_t cols_in_right_mcus
Definition: jpeg.c:73
luminance_ac_size_table
static const uint16_t luminance_ac_size_table[]
Definition: jpeg.c:165
chrominance_dc_size_table
static const uint16_t chrominance_dc_size_table[]
Definition: jpeg.c:139
chrominance_ac_code_table
static const uint16_t chrominance_ac_code_table[]
Definition: jpeg.c:186
zigzag_table
static const uint8_t zigzag_table[]
Definition: jpeg.c:274
jpeg_read_400_format
static void jpeg_read_400_format(JPEG_ENCODER_STRUCTURE *, uint8_t *)
Definition: jpeg.c:949
luminance_ac_code_table
static const uint16_t luminance_ac_code_table[]
Definition: jpeg.c:144
jpeg_DCT
static void jpeg_DCT(int16_t *)
Definition: jpeg.c:509
JPEG_ENCODER_STRUCTURE::bitindex
uint16_t bitindex
Definition: jpeg.c:102
JPEG_ENCODER_STRUCTURE::rows_in_bottom_mcus
uint16_t rows_in_bottom_mcus
Definition: jpeg.c:74
JPEG_ENCODER_STRUCTURE::CR
int16_t CR[JPEG_BLOCK_SIZE]
Definition: jpeg.c:98
jpeg_luma_quantizer
static const int jpeg_luma_quantizer[64]
Definition: jpeg.c:340
jpeg_initialization
static void jpeg_initialization(JPEG_ENCODER_STRUCTURE *, uint32_t, uint32_t, uint32_t)
Definition: jpeg.c:288
JPEG_ENCODER_STRUCTURE::cols
uint16_t cols
Definition: jpeg.c:77
JPEG_ENCODER_STRUCTURE::incr
uint16_t incr
Definition: jpeg.c:81
JPEG_ENCODER_STRUCTURE::Lqt
uint8_t Lqt[JPEG_BLOCK_SIZE]
Definition: jpeg.c:90
JPEG_ENCODER_STRUCTURE::rows
uint16_t rows
Definition: jpeg.c:76
PUTBITS
#define PUTBITS
Definition: jpeg.c:599
jpeg_close_bitstream
static uint8_t * jpeg_close_bitstream(JPEG_ENCODER_STRUCTURE *, uint8_t *)
Definition: jpeg.c:722
bitsize
static const uint8_t bitsize[]
Definition: jpeg.c:228
JPEG_ENCODER_STRUCTURE::Temp
int16_t Temp[JPEG_BLOCK_SIZE]
Definition: jpeg.c:99
JPEG_ENCODER_STRUCTURE::mcu_width
uint16_t mcu_width
Definition: jpeg.c:69
read_format
void(* read_format)(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *input_ptr)
Definition: jpeg.c:286
MakeTables
void MakeTables(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, int q)
Definition: jpeg.c:369
luminance_dc_code_table
static const uint16_t luminance_dc_code_table[]
Definition: jpeg.c:124
JPEG_ENCODER_STRUCTURE::length_minus_mcu_width
uint16_t length_minus_mcu_width
Definition: jpeg.c:79
markerdata
static const uint8_t markerdata[]
Definition: jpeg.c:263
jpeg_encodeMCU
static uint8_t * jpeg_encodeMCU(JPEG_ENCODER_STRUCTURE *, uint32_t, uint8_t *)
Definition: jpeg.c:472
JPEG_ENCODER_STRUCTURE::horizontal_mcus
uint16_t horizontal_mcus
Definition: jpeg.c:71
JPEG_ENCODER_STRUCTURE::mcu_height
uint16_t mcu_height
Definition: jpeg.c:70
jpeg_encode_image
void jpeg_encode_image(struct image_t *in, struct image_t *out, uint32_t quality_factor, bool add_dri_header)
Encode an YUV422 image.
Definition: jpeg.c:408
JPEG_BLOCK_SIZE
#define JPEG_BLOCK_SIZE
Definition: jpeg.c:63
JPEG_ENCODER_STRUCTURE::vertical_mcus
uint16_t vertical_mcus
Definition: jpeg.c:72
JPEG_ENCODER_STRUCTURE::Y1
int16_t Y1[JPEG_BLOCK_SIZE]
Definition: jpeg.c:95
chrominance_ac_size_table
static const uint16_t chrominance_ac_size_table[]
Definition: jpeg.c:207
jpeg_chroma_quantizer
static const int jpeg_chroma_quantizer[64]
Definition: jpeg.c:354
chrominance_dc_code_table
static const uint16_t chrominance_dc_code_table[]
Definition: jpeg.c:134
JPEG_ENCODER_STRUCTURE::length_minus_width
uint16_t length_minus_width
Definition: jpeg.c:80
JPEG_ENCODER_STRUCTURE
struct JPEG_ENCODER_STRUCTURE JPEG_ENCODER_STRUCTURE
JPEG_ENCODER_STRUCTURE::CB
int16_t CB[JPEG_BLOCK_SIZE]
Definition: jpeg.c:97
luminance_dc_size_table
static const uint16_t luminance_dc_size_table[]
Definition: jpeg.c:129
svs_size_code
static unsigned char svs_size_code(int w)
Definition: jpeg.c:23
jpeg_create_svs_header
int jpeg_create_svs_header(unsigned char *jpegbuf, int32_t size, int w)
Definition: jpeg.c:44
JPEG_ENCODER_STRUCTURE::offset
uint16_t offset
Definition: jpeg.c:83
JPEG_ENCODER_STRUCTURE
Definition: jpeg.c:66
jpeg.h
Encode images with the use of the JPEG encoding.
FOUR_ZERO_ZERO
#define FOUR_ZERO_ZERO
Definition: jpeg.h:28
FOUR_TWO_TWO
#define FOUR_TWO_TWO
Definition: jpeg.h:30
s
static uint32_t s
Definition: light_scheduler.c:33
logger_uart_parse.s1
s1
Definition: logger_uart_parse.py:9
logger_uart_parse.s2
s2
Definition: logger_uart_parse.py:9
logger_uart_parse.s3
s3
Definition: logger_uart_parse.py:9
uint16_t
unsigned short uint16_t
Typedef defining 16 bit unsigned short type.
Definition: vl53l1_types.h:88
int32_t
int int32_t
Typedef defining 32 bit int type.
Definition: vl53l1_types.h:83
uint32_t
unsigned int uint32_t
Typedef defining 32 bit unsigned int type.
Definition: vl53l1_types.h:78
int16_t
short int16_t
Typedef defining 16 bit short type.
Definition: vl53l1_types.h:93
uint8_t
unsigned char uint8_t
Typedef defining 8 bit unsigned char type.
Definition: vl53l1_types.h:98