w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

jutils.c
Go to the documentation of this file.
1 /*
2  * jutils.c
3  *
4  * Copyright (C) 1991-1996, Thomas G. Lane.
5  * This file is part of the Independent JPEG Group's software.
6  * For conditions of distribution and use, see the accompanying README file.
7  *
8  * This file contains tables and miscellaneous utility routines needed
9  * for both compression and decompression.
10  * Note we prefix all global names with "j" to minimize conflicts with
11  * a surrounding application.
12  */
13 
14 #define JPEG_INTERNALS
15 #include "jinclude.h"
16 #include "jpeglib.h"
17 
18 
19 /*
20  * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
21  * of a DCT block read in natural order (left to right, top to bottom).
22  */
23 
24 #if 0 /* This table is not actually needed in v6a */
25 
26 const int jpeg_zigzag_order[DCTSIZE2] = {
27  0, 1, 5, 6, 14, 15, 27, 28,
28  2, 4, 7, 13, 16, 26, 29, 42,
29  3, 8, 12, 17, 25, 30, 41, 43,
30  9, 11, 18, 24, 31, 40, 44, 53,
31  10, 19, 23, 32, 39, 45, 52, 54,
32  20, 22, 33, 38, 46, 51, 55, 60,
33  21, 34, 37, 47, 50, 56, 59, 61,
34  35, 36, 48, 49, 57, 58, 62, 63
35 };
36 
37 #endif
38 
39 /*
40  * jpeg_natural_order[i] is the natural-order position of the i'th element
41  * of zigzag order.
42  *
43  * When reading corrupted data, the Huffman decoders could attempt
44  * to reference an entry beyond the end of this array (if the decoded
45  * zero run length reaches past the end of the block). To prevent
46  * wild stores without adding an inner-loop test, we put some extra
47  * "63"s after the real entries. This will cause the extra coefficient
48  * to be stored in location 63 of the block, not somewhere random.
49  * The worst case would be a run-length of 15, which means we need 16
50  * fake entries.
51  */
52 
53 const int jpeg_natural_order[DCTSIZE2+16] = {
54  0, 1, 8, 16, 9, 2, 3, 10,
55  17, 24, 32, 25, 18, 11, 4, 5,
56  12, 19, 26, 33, 40, 48, 41, 34,
57  27, 20, 13, 6, 7, 14, 21, 28,
58  35, 42, 49, 56, 57, 50, 43, 36,
59  29, 22, 15, 23, 30, 37, 44, 51,
60  58, 59, 52, 45, 38, 31, 39, 46,
61  53, 60, 61, 54, 47, 55, 62, 63,
62  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
63  63, 63, 63, 63, 63, 63, 63, 63
64 };
65 
66 
67 /*
68  * Arithmetic utilities
69  */
70 
71 GLOBAL(long)
72 jdiv_round_up (long a, long b)
73 /* Compute a/b rounded up to next integer, ie, ceil(a/b) */
74 /* Assumes a >= 0, b > 0 */
75 {
76  return (a + b - 1L) / b;
77 }
78 
79 
80 GLOBAL(long)
81 jround_up (long a, long b)
82 /* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
83 /* Assumes a >= 0, b > 0 */
84 {
85  a += b - 1L;
86  return a - (a % b);
87 }
88 
89 
90 /* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
91  * and coefficient-block arrays. This won't work on 80x86 because the arrays
92  * are FAR and we're assuming a small-pointer memory model. However, some
93  * DOS compilers provide far-pointer versions of memcpy() and memset() even
94  * in the small-model libraries. These will be used if USE_FMEM is defined.
95  * Otherwise, the routines below do it the hard way. (The performance cost
96  * is not all that great, because these routines aren't very heavily used.)
97  */
98 
99 #ifndef NEED_FAR_POINTERS /* normal case, same as regular macros */
100 #define FMEMCOPY(dest,src,size) MEMCOPY(dest,src,size)
101 #define FMEMZERO(target,size) MEMZERO(target,size)
102 #else /* 80x86 case, define if we can */
103 #ifdef USE_FMEM
104 #define FMEMCOPY(dest,src,size) _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
105 #define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size))
106 #endif
107 #endif
108 
109 
110 GLOBAL(void)
114 /* Copy some rows of samples from one place to another.
115  * num_rows rows are copied from input_array[source_row++]
116  * to output_array[dest_row++]; these areas may overlap for duplication.
117  * The source and destination arrays must be at least as wide as num_cols.
118  */
119 {
120  register JSAMPROW inptr, outptr;
121 #ifdef FMEMCOPY
122  register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
123 #else
124  register JDIMENSION count;
125 #endif
126  register int row;
127 
128  input_array += source_row;
130 
131  for (row = num_rows; row > 0; row--) {
132  inptr = *input_array++;
133  outptr = *output_array++;
134 #ifdef FMEMCOPY
135  FMEMCOPY(outptr, inptr, count);
136 #else
137  for (count = num_cols; count > 0; count--)
138  *outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */
139 #endif
140  }
141 }
142 
143 
144 GLOBAL(void)
147 /* Copy a row of coefficient blocks from one place to another. */
148 {
149 #ifdef FMEMCOPY
150  FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
151 #else
152  register JCOEFPTR inptr, outptr;
153  register long count;
154 
155  inptr = (JCOEFPTR) input_row;
156  outptr = (JCOEFPTR) output_row;
157  for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) {
158  *outptr++ = *inptr++;
159  }
160 #endif
161 }
162 
163 
164 GLOBAL(void)
165 jzero_far (void FAR * target, size_t bytestozero)
166 /* Zero out a chunk of FAR memory. */
167 /* This might be sample-array data, block-array data, or alloc_large data. */
168 {
169 #ifdef FMEMZERO
171 #else
172  register char FAR * ptr = (char FAR *) target;
173  register size_t count;
174 
175  for (count = bytestozero; count > 0; count--) {
176  *ptr++ = 0;
177  }
178 #endif
179 }
#define count(a)
Definition: aptex-macros.h:781
#define b
Definition: jpegint.h:372
#define a(n)
Definition: gpos-common.c:148
#define SIZEOF(object)
Definition: jinclude.h:80
unsigned int JDIMENSION
Definition: jmorecfg.h:171
char JSAMPLE
Definition: jmorecfg.h:64
short JCOEF
Definition: jmorecfg.h:99
#define FAR
Definition: jmorecfg.h:217
#define GLOBAL(type)
Definition: jmorecfg.h:188
JBLOCKROW output_row
Definition: jpegint.h:376
int JSAMPARRAY int int num_rows
Definition: jpegint.h:375
JBLOCKROW JDIMENSION num_blocks
Definition: jpegint.h:377
int JSAMPARRAY int int JDIMENSION num_cols
Definition: jpegint.h:375
int JSAMPARRAY output_array
Definition: jpegint.h:374
int source_row
Definition: jpegint.h:373
size_t bytestozero
Definition: jpegint.h:378
int JSAMPARRAY int dest_row
Definition: jpegint.h:374
JSAMPLE * JSAMPROW
Definition: jpeglib.h:66
JCOEF * JCOEFPTR
Definition: jpeglib.h:75
JBLOCK * JBLOCKROW
Definition: jpeglib.h:71
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:67
#define DCTSIZE2
Definition: jpeglib.h:42
#define FMEMCOPY(dest, src, size)
Definition: jutils.c:100
long jround_up(long a, long b)
Definition: jutils.c:81
void jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks)
Definition: jutils.c:145
#define FMEMZERO(target, size)
Definition: jutils.c:101
void jcopy_sample_rows(JSAMPARRAY input_array, int source_row, JSAMPARRAY output_array, int dest_row, int num_rows, JDIMENSION num_cols)
Definition: jutils.c:111
void jzero_far(void *target, size_t bytestozero)
Definition: jutils.c:165
const int jpeg_natural_order[64+16]
Definition: jutils.c:53
long jdiv_round_up(long a, long b)
Definition: jutils.c:72
#define target(code, i)
Definition: lpeg.c:1165
#define size_t
Definition: glob.c:257
set set set set set set set set set set set set set set set set set set set set *set set set macro pixldst op &r &cond WK op &r &cond WK op &r &cond WK else op &m &cond &ia op &r &cond WK else op &m &cond &ia elseif elseif else error unsupported base if elseif elseif else error unsupported unaligned pixldst unaligned endm macro pixst base base else pixldst base endif endm macro PF ptr
static int row
Definition: ps2pk.c:587