7 * Copyright (C) 1991-1995, Thomas G. Lane.
9 * This file is part of the Independent JPEG Group's software.
11 * For conditions of distribution and use, see the accompanying README file.
15 * This file contains tables and miscellaneous utility routines needed
17 * for both compression and decompression.
19 * Note we prefix all global names with "j" to minimize conflicts with
21 * a surrounding application.
27 #define JPEG_INTERNALS
31 #include "radiant_jpeglib.h"
39 * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
41 * of a DCT block read in natural order (left to right, top to bottom).
47 const int jpeg_zigzag_order[DCTSIZE2] = {
49 0, 1, 5, 6, 14, 15, 27, 28,
51 2, 4, 7, 13, 16, 26, 29, 42,
53 3, 8, 12, 17, 25, 30, 41, 43,
55 9, 11, 18, 24, 31, 40, 44, 53,
57 10, 19, 23, 32, 39, 45, 52, 54,
59 20, 22, 33, 38, 46, 51, 55, 60,
61 21, 34, 37, 47, 50, 56, 59, 61,
63 35, 36, 48, 49, 57, 58, 62, 63
71 * jpeg_natural_order[i] is the natural-order position of the i'th element
77 * When reading corrupted data, the Huffman decoders could attempt
79 * to reference an entry beyond the end of this array (if the decoded
81 * zero run length reaches past the end of the block). To prevent
83 * wild stores without adding an inner-loop test, we put some extra
85 * "63"s after the real entries. This will cause the extra coefficient
87 * to be stored in location 63 of the block, not somewhere random.
89 * The worst case would be a run-length of 15, which means we need 16
97 const int jpeg_natural_order[DCTSIZE2+16] = {
99 0, 1, 8, 16, 9, 2, 3, 10,
101 17, 24, 32, 25, 18, 11, 4, 5,
103 12, 19, 26, 33, 40, 48, 41, 34,
105 27, 20, 13, 6, 7, 14, 21, 28,
107 35, 42, 49, 56, 57, 50, 43, 36,
109 29, 22, 15, 23, 30, 37, 44, 51,
111 58, 59, 52, 45, 38, 31, 39, 46,
113 53, 60, 61, 54, 47, 55, 62, 63,
115 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
117 63, 63, 63, 63, 63, 63, 63, 63
127 * Arithmetic utilities
135 jdiv_round_up (long a, long b)
137 /* Compute a/b rounded up to next integer, ie, ceil(a/b) */
139 /* Assumes a >= 0, b > 0 */
143 return (a + b - 1L) / b;
153 jround_up (long a, long b)
155 /* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
157 /* Assumes a >= 0, b > 0 */
171 /* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
173 * and coefficient-block arrays. This won't work on 80x86 because the arrays
175 * are FAR and we're assuming a small-pointer memory model. However, some
177 * DOS compilers provide far-pointer versions of memcpy() and memset() even
179 * in the small-model libraries. These will be used if USE_FMEM is defined.
181 * Otherwise, the routines below do it the hard way. (The performance cost
183 * is not all that great, because these routines aren't very heavily used.)
189 #ifndef NEED_FAR_POINTERS /* normal case, same as regular macros */
191 #define FMEMCOPY(dest,src,size) MEMCOPY(dest,src,size)
193 #define FMEMZERO(target,size) MEMZERO(target,size)
195 #else /* 80x86 case, define if we can */
199 #define FMEMCOPY(dest,src,size) _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
201 #define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size))
213 jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
215 JSAMPARRAY output_array, int dest_row,
217 int num_rows, JDIMENSION num_cols)
219 /* Copy some rows of samples from one place to another.
221 * num_rows rows are copied from input_array[source_row++]
223 * to output_array[dest_row++]; these areas may overlap for duplication.
225 * The source and destination arrays must be at least as wide as num_cols.
231 register JSAMPROW inptr, outptr;
235 register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
239 register JDIMENSION count;
247 input_array += source_row;
249 output_array += dest_row;
253 for (row = num_rows; row > 0; row--) {
255 inptr = *input_array++;
257 outptr = *output_array++;
261 FMEMCOPY(outptr, inptr, count);
265 for (count = num_cols; count > 0; count--)
267 *outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */
281 jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
283 JDIMENSION num_blocks)
285 /* Copy a row of coefficient blocks from one place to another. */
291 FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
295 register JCOEFPTR inptr, outptr;
301 inptr = (JCOEFPTR) input_row;
303 outptr = (JCOEFPTR) output_row;
305 for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) {
307 *outptr++ = *inptr++;
321 jzero_far (void FAR * target, size_t bytestozero)
323 /* Zero out a chunk of FAR memory. */
325 /* This might be sample-array data, block-array data, or alloc_large data. */
331 FMEMZERO(target, bytestozero);
335 register char FAR * ptr = (char FAR *) target;
337 register size_t count;
341 for (count = bytestozero; count > 0; count--) {