• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * jutils.c
3  *
4  * This file was part of the Independent JPEG Group's software:
5  * Copyright (C) 1991-1996, Thomas G. Lane.
6  * It was modified by The libjpeg-turbo Project to include only code
7  * relevant to libjpeg-turbo.
8  * For conditions of distribution and use, see the accompanying README.ijg
9  * file.
10  *
11  * This file contains tables and miscellaneous utility routines needed
12  * for both compression and decompression.
13  * Note we prefix all global names with "j" to minimize conflicts with
14  * a surrounding application.
15  */
16 
17 #define JPEG_INTERNALS
18 #include "jinclude.h"
19 #include "jpeglib.h"
20 
21 
22 /*
23  * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
24  * of a DCT block read in natural order (left to right, top to bottom).
25  */
26 
27 #if 0                           /* This table is not actually needed in v6a */
28 
29 const int jpeg_zigzag_order[DCTSIZE2] = {
30    0,  1,  5,  6, 14, 15, 27, 28,
31    2,  4,  7, 13, 16, 26, 29, 42,
32    3,  8, 12, 17, 25, 30, 41, 43,
33    9, 11, 18, 24, 31, 40, 44, 53,
34   10, 19, 23, 32, 39, 45, 52, 54,
35   20, 22, 33, 38, 46, 51, 55, 60,
36   21, 34, 37, 47, 50, 56, 59, 61,
37   35, 36, 48, 49, 57, 58, 62, 63
38 };
39 
40 #endif
41 
42 /*
43  * jpeg_natural_order[i] is the natural-order position of the i'th element
44  * of zigzag order.
45  *
46  * When reading corrupted data, the Huffman decoders could attempt
47  * to reference an entry beyond the end of this array (if the decoded
48  * zero run length reaches past the end of the block).  To prevent
49  * wild stores without adding an inner-loop test, we put some extra
50  * "63"s after the real entries.  This will cause the extra coefficient
51  * to be stored in location 63 of the block, not somewhere random.
52  * The worst case would be a run-length of 15, which means we need 16
53  * fake entries.
54  */
55 
56 const int jpeg_natural_order[DCTSIZE2+16] = {
57   0,  1,  8, 16,  9,  2,  3, 10,
58  17, 24, 32, 25, 18, 11,  4,  5,
59  12, 19, 26, 33, 40, 48, 41, 34,
60  27, 20, 13,  6,  7, 14, 21, 28,
61  35, 42, 49, 56, 57, 50, 43, 36,
62  29, 22, 15, 23, 30, 37, 44, 51,
63  58, 59, 52, 45, 38, 31, 39, 46,
64  53, 60, 61, 54, 47, 55, 62, 63,
65  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
66  63, 63, 63, 63, 63, 63, 63, 63
67 };
68 
69 
70 /*
71  * Arithmetic utilities
72  */
73 
74 GLOBAL(long)
jdiv_round_up(long a,long b)75 jdiv_round_up (long a, long b)
76 /* Compute a/b rounded up to next integer, ie, ceil(a/b) */
77 /* Assumes a >= 0, b > 0 */
78 {
79   return (a + b - 1L) / b;
80 }
81 
82 
83 GLOBAL(long)
jround_up(long a,long b)84 jround_up (long a, long b)
85 /* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
86 /* Assumes a >= 0, b > 0 */
87 {
88   a += b - 1L;
89   return a - (a % b);
90 }
91 
92 
93 GLOBAL(void)
jcopy_sample_rows(JSAMPARRAY input_array,int source_row,JSAMPARRAY output_array,int dest_row,int num_rows,JDIMENSION num_cols)94 jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
95                    JSAMPARRAY output_array, int dest_row,
96                    int num_rows, JDIMENSION num_cols)
97 /* Copy some rows of samples from one place to another.
98  * num_rows rows are copied from input_array[source_row++]
99  * to output_array[dest_row++]; these areas may overlap for duplication.
100  * The source and destination arrays must be at least as wide as num_cols.
101  */
102 {
103   register JSAMPROW inptr, outptr;
104   register size_t count = (size_t) (num_cols * sizeof(JSAMPLE));
105   register int row;
106 
107   input_array += source_row;
108   output_array += dest_row;
109 
110   for (row = num_rows; row > 0; row--) {
111     inptr = *input_array++;
112     outptr = *output_array++;
113     MEMCOPY(outptr, inptr, count);
114   }
115 }
116 
117 
118 GLOBAL(void)
jcopy_block_row(JBLOCKROW input_row,JBLOCKROW output_row,JDIMENSION num_blocks)119 jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
120                  JDIMENSION num_blocks)
121 /* Copy a row of coefficient blocks from one place to another. */
122 {
123   MEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
124 }
125 
126 
127 GLOBAL(void)
jzero_far(void * target,size_t bytestozero)128 jzero_far (void *target, size_t bytestozero)
129 /* Zero out a chunk of memory. */
130 /* This might be sample-array data, block-array data, or alloc_large data. */
131 {
132   MEMZERO(target, bytestozero);
133 }
134