Paparazzi UAS v7.0_unstable
Paparazzi is a free software Unmanned Aircraft System.
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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
23static 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
44int 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
105
106
107static void jpeg_initialization(JPEG_ENCODER_STRUCTURE *, uint32_t, uint32_t, uint32_t);
108
109static uint8_t *jpeg_write_markers(JPEG_ENCODER_STRUCTURE *, uint8_t *, uint32_t, uint32_t, uint32_t);
110
111static void jpeg_read_400_format(JPEG_ENCODER_STRUCTURE *, uint8_t *);
112static void jpeg_read_422_format(JPEG_ENCODER_STRUCTURE *, uint8_t *);
113
114static uint8_t *jpeg_encodeMCU(JPEG_ENCODER_STRUCTURE *, uint32_t, uint8_t *);
115
116static void jpeg_levelshift(int16_t *);
117static void jpeg_DCT(int16_t *);
118
119static void jpeg_quantization(JPEG_ENCODER_STRUCTURE *, int16_t *, uint16_t *);
120static uint8_t *jpeg_huffman(JPEG_ENCODER_STRUCTURE *, uint16_t, uint8_t *);
121
122static uint8_t *jpeg_close_bitstream(JPEG_ENCODER_STRUCTURE *, uint8_t *);
123
124static const uint16_t luminance_dc_code_table [] = {
125 0x0000, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006,
126 0x000E, 0x001E, 0x003E, 0x007E, 0x00FE, 0x01FE
127};
128
129static const uint16_t luminance_dc_size_table [] = {
130 0x0002, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
131 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009
132};
133
134static const uint16_t chrominance_dc_code_table [] = {
135 0x0000, 0x0001, 0x0002, 0x0006, 0x000E, 0x001E,
136 0x003E, 0x007E, 0x00FE, 0x01FE, 0x03FE, 0x07FE
137};
138
139static const uint16_t chrominance_dc_size_table [] = {
140 0x0002, 0x0002, 0x0002, 0x0003, 0x0004, 0x0005,
141 0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B
142};
143
144static 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
165static 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
186static 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
207static 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
228static 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
263static 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
274static 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
286void (*read_format)(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, uint8_t *input_ptr);
287
288static 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 */
340static 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 */
354static 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 */
368void MakeTables(JPEG_ENCODER_STRUCTURE *jpeg_encoder_structure, int q);
369void 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
408void 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
497
498/* Level shifting to get 8 bit SIGNED values for the data */
499static 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) */
509static 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
623static 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 */
722static 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
748static 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 */
936static 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
949static 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
979static 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_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:273
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::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::Lqt
uint8_t Lqt[JPEG_BLOCK_SIZE]
Definition jpeg.c:90
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::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
foo
uint16_t foo
Definition main_demo5.c:58
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