]> Creatis software - gdcm.git/blob - src/jpeg/ljpg/jpegutil.c
FIX: Some warnings
[gdcm.git] / src / jpeg / ljpg / jpegutil.c
1 /*
2  * jpegutil.c --
3  *
4  * Various utility routines used in the jpeg encoder/decoder.  Large parts
5  * are stolen from the IJG code
6  */
7 /*
8  * $Id: jpegutil.c,v 1.2 2004/08/18 02:26:08 malaterre Exp $
9  */
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include "jpeg.h"
14 #include "mcu.h"
15 #include "proto.h"
16
17 /*
18  * To fix memory leaks, memory is allocated once for the mcu buffers.
19  * Enough memory is reserved to accomodate up to 1024-wide images
20  * with up to 4 components.
21  */
22 static char mcuROW1Memory[1024 * sizeof(MCU)];
23 static char mcuROW2Memory[1024 * sizeof(MCU)];
24 static char buf1Memory[1024 * 4 * sizeof(ComponentType)];
25 static char buf2Memory[1024 * 4 * sizeof(ComponentType)];
26
27
28 unsigned int bitMask[] = {  0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff,
29                             0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff,
30                             0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff,
31                             0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff,
32                             0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff,
33                             0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff,
34                             0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f,
35                             0x0000000f, 0x00000007, 0x00000003, 0x00000001};
36 /*
37  *--------------------------------------------------------------
38  *
39  * JroundUp --
40  *
41  *        Compute a rounded up to next multiple of b; a >= 0, b > 0 
42  *
43  * Results:
44  *        Rounded up value.
45  *
46  * Side effects:
47  *        None.
48  *
49  *--------------------------------------------------------------
50  */
51 int JroundUp (int a, int b)
52 {
53     a += b - 1;
54     return a - (a % b);
55 }
56
57 /*
58  *--------------------------------------------------------------
59  *
60  * DecoderStructInit --
61  *
62  *        Initalize the rest of the fields in the decompression
63  *        structure.
64  *
65  * Results:
66  *        None.
67  *
68  * Side effects:
69  *        None.
70  *
71  *--------------------------------------------------------------
72  */
73
74 void DecoderStructInit (DecompressInfo *dcPtr)
75 {
76     char *buf1,*buf2;
77     short ci,i;
78     JpegComponentInfo *compPtr;
79     int mcuSize;
80
81     /*
82      * Check sampling factor validity.
83      */
84     for (ci = 0; ci < dcPtr->numComponents; ci++) {
85         compPtr = &dcPtr->compInfo[ci];
86         if ((compPtr->hSampFactor != 1) || (compPtr->vSampFactor != 1)) {
87            fprintf (stderr, "Error: Downsampling is not supported.\n");
88            /* exit(-1); */
89            dcPtr->error = -1; return; 
90         }
91     }
92
93     /*
94      * Prepare array describing MCU composition
95      */
96     if (dcPtr->compsInScan == 1) {
97         dcPtr->MCUmembership[0] = 0;
98     } else {
99         short ci;
100
101         if (dcPtr->compsInScan > 4) {
102             fprintf (stderr, "Too many components for interleaved scan\n");
103             /* exit (1); */
104             dcPtr->error = -1; return;
105         }
106
107         for (ci = 0; ci < dcPtr->compsInScan; ci++) {
108             dcPtr->MCUmembership[ci] = ci;
109         }
110     }
111
112     /*
113      * Initialize mucROW1 and mcuROW2 which buffer two rows of
114      * pixels for predictor calculation.
115      */
116
117     mcuROW1 = (MCU *) mcuROW1Memory;
118     mcuROW2 = (MCU *) mcuROW2Memory;
119
120     mcuSize=dcPtr->compsInScan * sizeof(ComponentType);
121
122     buf1 = buf1Memory;
123     buf2 = buf2Memory;
124
125     for (i=0;i<dcPtr->imageWidth;i++) {
126         mcuROW1[i]=(MCU)(buf1+i*mcuSize);
127         mcuROW2[i]=(MCU)(buf2+i*mcuSize);
128     }
129
130     dcPtr->error = 0;
131
132 }/*endof DecoderStructInit*/
133
134
135 /*
136  *--------------------------------------------------------------
137  *
138  * FixHuffTbl --
139  *
140  *      Compute derived values for a Huffman table one the DHT marker
141  *      has been processed.  This generates both the encoding and
142  *      decoding tables.
143  *
144  * Results:
145  *      None.
146  *
147  * Side effects:
148  *      None.
149  *
150  *--------------------------------------------------------------
151  */
152 void FixHuffTbl (HuffmanTable *htbl)
153 {
154     int p, i, l, lastp, si;
155     char huffsize[257];
156     Ushort huffcode[257];
157     Ushort code;
158     int size;
159     int value, ll, ul;
160
161     /*
162      * Figure C.1: make table of Huffman code length for each symbol
163      * Note that this is in code-length order.
164      */
165     p = 0;
166     for (l = 1; l <= 16; l++) {
167         for (i = 1; i <= (int)htbl->bits[l]; i++)
168             huffsize[p++] = (char)l;
169     }
170     huffsize[p] = 0;
171     lastp = p;
172
173
174     /*
175      * Figure C.2: generate the codes themselves
176      * Note that this is in code-length order.
177      */
178     code = 0;
179     si = huffsize[0];
180     p = 0;
181     while (huffsize[p]) {
182         while (((int)huffsize[p]) == si) {
183             huffcode[p++] = code;
184             code++;
185         }
186         code <<= 1;
187         si++;
188     }
189
190     /*
191      * Figure C.3: generate encoding tables
192      * These are code and size indexed by symbol value
193      * Set any codeless symbols to have code length 0; this allows
194      * EmitBits to detect any attempt to emit such symbols.
195      */
196     MEMSET(htbl->ehufsi, 0, sizeof(htbl->ehufsi));
197
198     for (p = 0; p < lastp; p++) {
199         htbl->ehufco[htbl->huffval[p]] = huffcode[p];
200         htbl->ehufsi[htbl->huffval[p]] = huffsize[p];
201     }
202
203     /*
204      * Figure F.15: generate decoding tables
205      */
206     p = 0;
207     for (l = 1; l <= 16; l++) {
208         if (htbl->bits[l]) {
209             htbl->valptr[l] = p;
210             htbl->mincode[l] = huffcode[p];
211             p += htbl->bits[l];
212             htbl->maxcode[l] = huffcode[p - 1];
213         } else {
214             htbl->maxcode[l] = -1;
215         }
216     }
217
218     /*
219      * We put in this value to ensure HuffDecode terminates.
220      */
221     htbl->maxcode[17] = 0xFFFFFL;
222
223     /*
224      * Build the numbits, value lookup tables.
225      * These table allow us to gather 8 bits from the bits stream,
226      * and immediately lookup the size and value of the huffman codes.
227      * If size is zero, it means that more than 8 bits are in the huffman
228      * code (this happens about 3-4% of the time).
229      */
230     /*bzero (htbl->numbits, sizeof(htbl->numbits));*/
231     memset(htbl->numbits, 0, sizeof(htbl->numbits));
232
233     for (p=0; p<lastp; p++) {
234         size = huffsize[p];
235         if (size <= 8) {
236             value = htbl->huffval[p];
237             code = huffcode[p];
238             ll = code << (8-size);
239             if (size < 8) {
240                 ul = ll | bitMask[24+size];
241             } else {
242                 ul = ll;
243             }
244             for (i=ll; i<=ul; i++) {
245                 htbl->numbits[i] = size;
246                 htbl->value[i] = value;
247             }
248         }
249     }
250 }
251
252