1/*
2 * Small jpeg decoder library
3 *
4 * Copyright (c) 2006, Luc Saillard <luc@saillard.org>
5 * All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * - Redistributions of source code must retain the above copyright notice,
10 *  this list of conditions and the following disclaimer.
11 *
12 * - Redistributions in binary form must reproduce the above copyright notice,
13 *  this list of conditions and the following disclaimer in the documentation
14 *  and/or other materials provided with the distribution.
15 *
16 * - Neither the name of the author nor the names of its contributors may be
17 *  used to endorse or promote products derived from this software without
18 *  specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
33
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <stdint.h>
38
39#include "tinyjpeg.h"
40#include "tinyjpeg-internal.h"
41
42/*******************************************************************************
43 *
44 * Colorspace conversion routine
45 *
46 *
47 * Note:
48 * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
49 * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
50 * The conversion equations to be implemented are therefore
51 *      R = Y                + 1.40200 * Cr
52 *      G = Y - 0.34414 * Cb - 0.71414 * Cr
53 *      B = Y + 1.77200 * Cb
54 *
55 ******************************************************************************/
56static unsigned char clamp(int i)
57{
58  if (i<0)
59    return 0;
60  else if (i>255)
61    return 255;
62  else
63    return i;
64}
65
66/**
67 *  YCrCb -> BGR24 (1x1)
68 *  .---.
69 *  | 1 |
70 *  `---'
71 */
72static void YCrCB_to_BGR24_1x1(struct jdec_private *priv, int sx, int sy)
73{
74  const unsigned char *Y, *Cb, *Cr;
75  unsigned char *p;
76  int i,j;
77  int offset_to_next_row;
78
79#define SCALEBITS       10
80#define ONE_HALF        (1UL << (SCALEBITS-1))
81#define FIX(x)          ((int)((x) * (1UL<<SCALEBITS) + 0.5))
82
83  p = priv->plane[0];
84  Y = priv->Y;
85  Cb = priv->Cb;
86  Cr = priv->Cr;
87  offset_to_next_row = priv->bytes_per_row[0] - 8*3;
88  for (i = sy; i > 0; i--) {
89    for (j = sx; j > 0; j--) {
90
91       int y, cb, cr;
92       int add_r, add_g, add_b;
93       int r, g , b;
94
95       y  = Y[0] << SCALEBITS;
96       cb = *Cb++ - 128;
97       cr = *Cr++ - 128;
98       add_r = FIX(1.40200) * cr + ONE_HALF;
99       add_g = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
100       add_b = FIX(1.77200) * cb + ONE_HALF;
101
102       b = (y + add_b) >> SCALEBITS;
103       *p++ = clamp(b);
104       g = (y + add_g) >> SCALEBITS;
105       *p++ = clamp(g);
106       r = (y + add_r) >> SCALEBITS;
107       *p++ = clamp(r);
108
109       Y++;
110    }
111
112    p += offset_to_next_row;
113  }
114
115#undef SCALEBITS
116#undef ONE_HALF
117#undef FIX
118
119}
120
121
122/*
123 *  YCrCb -> BGR24 (2x1)
124 *  .-------.
125 *  | 1 | 2 |
126 *  `-------'
127 */
128static void YCrCB_to_BGR24_2x1(struct jdec_private *priv, int sx, int sy)
129{
130  const unsigned char *Y, *Cb, *Cr;
131  unsigned char *p;
132  int i,j;
133  int offset_to_next_row;
134
135#define SCALEBITS       10
136#define ONE_HALF        (1UL << (SCALEBITS-1))
137#define FIX(x)          ((int)((x) * (1UL<<SCALEBITS) + 0.5))
138
139  p = priv->plane[0];
140  Y = priv->Y;
141  Cb = priv->Cb;
142  Cr = priv->Cr;
143  offset_to_next_row = priv->bytes_per_row[0] - 16*3;
144  for (i = sy; i > 0; i--) {
145    for (j = sx; j > 0; j -= 2) {
146
147       int y, cb, cr;
148       int add_r, add_g, add_b;
149       int r, g , b;
150
151       cb = *Cb++ - 128;
152       cr = *Cr++ - 128;
153       add_r = FIX(1.40200) * cr + ONE_HALF;
154       add_g = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
155       add_b = FIX(1.77200) * cb + ONE_HALF;
156
157       y  = Y[0] << SCALEBITS;
158       b = (y + add_b) >> SCALEBITS;
159       *p++ = clamp(b);
160       g = (y + add_g) >> SCALEBITS;
161       *p++ = clamp(g);
162       r = (y + add_r) >> SCALEBITS;
163       *p++ = clamp(r);
164
165       if (j > 1) {
166	   y  = Y[1] << SCALEBITS;
167	   b = (y + add_b) >> SCALEBITS;
168	   *p++ = clamp(b);
169	   g = (y + add_g) >> SCALEBITS;
170	   *p++ = clamp(g);
171	   r = (y + add_r) >> SCALEBITS;
172	   *p++ = clamp(r);
173       }
174
175       Y += 2;
176    }
177
178    p += offset_to_next_row;
179  }
180
181#undef SCALEBITS
182#undef ONE_HALF
183#undef FIX
184
185}
186
187/*
188 *  YCrCb -> BGR24 (1x2)
189 *  .---.
190 *  | 1 |
191 *  |---|
192 *  | 2 |
193 *  `---'
194 */
195static void YCrCB_to_BGR24_1x2(struct jdec_private *priv, int sx, int sy)
196{
197  const unsigned char *Y, *Cb, *Cr;
198  unsigned char *p, *p2;
199  int i,j;
200  int offset_to_next_row;
201
202#define SCALEBITS       10
203#define ONE_HALF        (1UL << (SCALEBITS-1))
204#define FIX(x)          ((int)((x) * (1UL<<SCALEBITS) + 0.5))
205
206  p = priv->plane[0];
207  p2 = priv->plane[0] + priv->bytes_per_row[0];
208  Y = priv->Y;
209  Cb = priv->Cb;
210  Cr = priv->Cr;
211  offset_to_next_row = 2*priv->bytes_per_row[0] - 8*3;
212  for (i = sy; i > 0; i -= 2) {
213    for (j = sx; j > 0 ; j--) {
214
215       int y, cb, cr;
216       int add_r, add_g, add_b;
217       int r, g , b;
218
219       cb = *Cb++ - 128;
220       cr = *Cr++ - 128;
221       add_r = FIX(1.40200) * cr + ONE_HALF;
222       add_g = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
223       add_b = FIX(1.77200) * cb + ONE_HALF;
224
225       y  = Y[0] << SCALEBITS;
226       b = (y + add_b) >> SCALEBITS;
227       *p++ = clamp(b);
228       g = (y + add_g) >> SCALEBITS;
229       *p++ = clamp(g);
230       r = (y + add_r) >> SCALEBITS;
231       *p++ = clamp(r);
232
233       if (i > 1) {
234	   y  = Y[8] << SCALEBITS;
235	   b = (y + add_b) >> SCALEBITS;
236	   *p2++ = clamp(b);
237	   g = (y + add_g) >> SCALEBITS;
238	   *p2++ = clamp(g);
239	   r = (y + add_r) >> SCALEBITS;
240	   *p2++ = clamp(r);
241       }
242
243       Y++;
244    }
245    Y += 8;
246    p += offset_to_next_row;
247    p2 += offset_to_next_row;
248  }
249
250#undef SCALEBITS
251#undef ONE_HALF
252#undef FIX
253
254}
255
256
257/*
258 *  YCrCb -> BGR24 (2x2)
259 *  .-------.
260 *  | 1 | 2 |
261 *  |---+---|
262 *  | 3 | 4 |
263 *  `-------'
264 */
265static void YCrCB_to_BGR24_2x2(struct jdec_private *priv, int sx, int sy)
266{
267  const unsigned char *Y, *Cb, *Cr;
268  unsigned char *p, *p2;
269  int i,j;
270  int offset_to_next_row;
271
272#define SCALEBITS       10
273#define ONE_HALF        (1UL << (SCALEBITS-1))
274#define FIX(x)          ((int)((x) * (1UL<<SCALEBITS) + 0.5))
275
276  p = priv->plane[0];
277  p2 = priv->plane[0] + priv->bytes_per_row[0];
278  Y = priv->Y;
279  Cb = priv->Cb;
280  Cr = priv->Cr;
281  offset_to_next_row = 2*priv->bytes_per_row[0] - 16*3;
282  for (i = sy; i > 0; i -= 2) {
283    for (j = sx; j > 0; j -= 2) {
284
285       int y, cb, cr;
286       int add_r, add_g, add_b;
287       int r, g , b;
288
289       cb = *Cb++ - 128;
290       cr = *Cr++ - 128;
291       add_r = FIX(1.40200) * cr + ONE_HALF;
292       add_g = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
293       add_b = FIX(1.77200) * cb + ONE_HALF;
294
295       y  = Y[0] << SCALEBITS;
296       b = (y + add_b) >> SCALEBITS;
297       *p++ = clamp(b);
298       g = (y + add_g) >> SCALEBITS;
299       *p++ = clamp(g);
300       r = (y + add_r) >> SCALEBITS;
301       *p++ = clamp(r);
302
303       if (j > 1) {
304	   y  = Y[1] << SCALEBITS;
305	   b = (y + add_b) >> SCALEBITS;
306	   *p++ = clamp(b);
307	   g = (y + add_g) >> SCALEBITS;
308	   *p++ = clamp(g);
309	   r = (y + add_r) >> SCALEBITS;
310	   *p++ = clamp(r);
311       }
312
313       if (i > 1) {
314	   y  = Y[16+0] << SCALEBITS;
315	   b = (y + add_b) >> SCALEBITS;
316	   *p2++ = clamp(b);
317	   g = (y + add_g) >> SCALEBITS;
318	   *p2++ = clamp(g);
319	   r = (y + add_r) >> SCALEBITS;
320	   *p2++ = clamp(r);
321
322	   if (j > 1) {
323	       y  = Y[16+1] << SCALEBITS;
324	       b = (y + add_b) >> SCALEBITS;
325	       *p2++ = clamp(b);
326	       g = (y + add_g) >> SCALEBITS;
327	       *p2++ = clamp(g);
328	       r = (y + add_r) >> SCALEBITS;
329	       *p2++ = clamp(r);
330	   }
331       }
332
333       Y += 2;
334    }
335    Y  += 16;
336    p  += offset_to_next_row;
337    p2 += offset_to_next_row;
338  }
339
340#undef SCALEBITS
341#undef ONE_HALF
342#undef FIX
343
344}
345
346static int initialize_bgr24(struct jdec_private *priv,
347			    unsigned int *bytes_per_blocklines,
348			    unsigned int *bytes_per_mcu)
349{
350  if (!priv->bytes_per_row[0])
351    priv->bytes_per_row[0] = priv->width * 3;
352  if (!priv->components[0])
353    priv->components[0] = malloc(priv->height * priv->bytes_per_row[0]);
354
355  bytes_per_blocklines[0] = priv->bytes_per_row[0] << 3;
356  bytes_per_mcu[0] = 3*8;
357
358  return !priv->components[0];
359}
360
361static const struct tinyjpeg_colorspace format_bgr24 =
362  {
363    {
364      YCrCB_to_BGR24_1x1,
365      YCrCB_to_BGR24_1x2,
366      YCrCB_to_BGR24_2x1,
367      YCrCB_to_BGR24_2x2,
368    },
369    tinyjpeg_decode_mcu_3comp_table,
370    initialize_bgr24
371  };
372
373const tinyjpeg_colorspace_t TINYJPEG_FMT_BGR24 = &format_bgr24;
374