← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to fpcsrc/packages/base/pasjpeg/jutils.pas

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fpcsrc/packages/base/pasjpeg/jutils.pas
 
1
Unit jutils;
 
2
 
 
3
{ This file contains tables and miscellaneous utility routines needed
 
4
  for both compression and decompression.
 
5
  Note we prefix all global names with "j" to minimize conflicts with
 
6
  a surrounding application. }
 
7
 
 
8
{ Source: jutils.c; Copyright (C) 1991-1996, Thomas G. Lane. }
 
9
 
 
10
interface
 
11
 
 
12
{$I jconfig.inc}
 
13
 
 
14
uses
 
15
  jmorecfg,
 
16
  jinclude,
 
17
  jpeglib;
 
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
{$ifdef FALSE}      { This table is not actually needed in v6a }
 
25
 
 
26
const
 
27
  jpeg_zigzag_order : array[0..DCTSIZE2] of int =
 
28
  (0,  1,  5,  6, 14, 15, 27, 28,
 
29
   2,  4,  7, 13, 16, 26, 29, 42,
 
30
   3,  8, 12, 17, 25, 30, 41, 43,
 
31
   9, 11, 18, 24, 31, 40, 44, 53,
 
32
  10, 19, 23, 32, 39, 45, 52, 54,
 
33
  20, 22, 33, 38, 46, 51, 55, 60,
 
34
  21, 34, 37, 47, 50, 56, 59, 61,
 
35
  35, 36, 48, 49, 57, 58, 62, 63);
 
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
 
54
  jpeg_natural_order : array[0..DCTSIZE2+16-1] of int =
 
55
 (0,  1,  8, 16,  9,  2,  3, 10,
 
56
 17, 24, 32, 25, 18, 11,  4,  5,
 
57
 12, 19, 26, 33, 40, 48, 41, 34,
 
58
 27, 20, 13,  6,  7, 14, 21, 28,
 
59
 35, 42, 49, 56, 57, 50, 43, 36,
 
60
 29, 22, 15, 23, 30, 37, 44, 51,
 
61
 58, 59, 52, 45, 38, 31, 39, 46,
 
62
 53, 60, 61, 54, 47, 55, 62, 63,
 
63
 63, 63, 63, 63, 63, 63, 63, 63, { extra entries for safety in decoder }
 
64
 63, 63, 63, 63, 63, 63, 63, 63);
 
65
 
 
66
 
 
67
 
 
68
{ Arithmetic utilities }
 
69
 
 
70
{GLOBAL}
 
71
function jdiv_round_up (a : long; b : long) : long;
 
72
 
 
73
{GLOBAL}
 
74
function jround_up (a : long; b : long) : long;
 
75
 
 
76
{GLOBAL}
 
77
procedure jcopy_sample_rows (input_array : JSAMPARRAY;
 
78
                             source_row : int;
 
79
                             output_array : JSAMPARRAY; dest_row : int;
 
80
                             num_rows : int; num_cols : JDIMENSION);
 
81
 
 
82
{GLOBAL}
 
83
procedure jcopy_block_row (input_row : JBLOCKROW;
 
84
                           output_row : JBLOCKROW;
 
85
                           num_blocks : JDIMENSION);
 
86
 
 
87
{GLOBAL}
 
88
procedure jzero_far (target : pointer;{far} bytestozero : size_t);
 
89
 
 
90
procedure FMEMZERO(target : pointer; size : size_t);
 
91
 
 
92
procedure FMEMCOPY(dest,src : pointer; size : size_t);
 
93
 
 
94
implementation
 
95
 
 
96
{GLOBAL}
 
97
function jdiv_round_up (a : long; b : long) : long;
 
98
{ Compute a/b rounded up to next integer, ie, ceil(a/b) }
 
99
{ Assumes a >= 0, b > 0 }
 
100
begin
 
101
  jdiv_round_up := (a + b - long(1)) div b;
 
102
end;
 
103
 
 
104
 
 
105
{GLOBAL}
 
106
function jround_up (a : long; b : long) : long;
 
107
{ Compute a rounded up to next multiple of b, ie, ceil(a/b)*b }
 
108
{ Assumes a >= 0, b > 0 }
 
109
begin
 
110
  Inc(a, b - long(1));
 
111
  jround_up := a - (a mod b);
 
112
end;
 
113
 
 
114
{ On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
 
115
  and coefficient-block arrays.  This won't work on 80x86 because the arrays
 
116
  are FAR and we're assuming a small-pointer memory model.  However, some
 
117
  DOS compilers provide far-pointer versions of memcpy() and memset() even
 
118
  in the small-model libraries.  These will be used if USE_FMEM is defined.
 
119
  Otherwise, the routines below do it the hard way.  (The performance cost
 
120
  is not all that great, because these routines aren't very heavily used.) }
 
121
 
 
122
 
 
123
{$ifndef NEED_FAR_POINTERS}      { normal case, same as regular macros }
 
124
procedure FMEMZERO(target : pointer; size : size_t);
 
125
begin
 
126
  FillChar(target^, size, 0);
 
127
end;
 
128
 
 
129
procedure FMEMCOPY(dest,src : pointer; size : size_t);
 
130
begin
 
131
  Move(src^, dest^, size);
 
132
end;
 
133
 
 
134
 
 
135
{$else}                       { 80x86 case, define if we can }
 
136
  {$ifdef USE_FMEM}
 
137
   FMEMCOPY(dest,src,size)    _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
 
138
   FMEMZERO(target,size)      _fmemset((void FAR *)(target), 0, (size_t)(size))
 
139
  {$endif}
 
140
{$endif}
 
141
 
 
142
 
 
143
{GLOBAL}
 
144
procedure jcopy_sample_rows (input_array : JSAMPARRAY; source_row : int;
 
145
                             output_array : JSAMPARRAY; dest_row : int;
 
146
                             num_rows : int; num_cols : JDIMENSION);
 
147
{ Copy some rows of samples from one place to another.
 
148
  num_rows rows are copied from input_array[source_row++]
 
149
  to output_array[dest_row++]; these areas may overlap for duplication.
 
150
  The source and destination arrays must be at least as wide as num_cols. }
 
151
var
 
152
  inptr, outptr : JSAMPLE_PTR; {register}
 
153
{$ifdef FMEMCOPY}
 
154
  count : size_t; {register}
 
155
{$else}
 
156
  count : JDIMENSION; {register}
 
157
{$endif}
 
158
  row : int; {register}
 
159
begin
 
160
{$ifdef FMEMCOPY}
 
161
  count := size_t(num_cols * SIZEOF(JSAMPLE));
 
162
{$endif}
 
163
  Inc(JSAMPROW_PTR(input_array), source_row);
 
164
  Inc(JSAMPROW_PTR(output_array), dest_row);
 
165
 
 
166
  for row := pred(num_rows) downto 0 do
 
167
  begin
 
168
    inptr := JSAMPLE_PTR(input_array^[0]);
 
169
    Inc(JSAMPROW_PTR(input_array));
 
170
    outptr := JSAMPLE_PTR(output_array^[0]);
 
171
    Inc(JSAMPROW_PTR(output_array));
 
172
{$ifdef FMEMCOPY}
 
173
    FMEMCOPY(outptr, inptr, count);
 
174
{$else}
 
175
    for count := pred(num_cols) downto 0 do
 
176
    begin
 
177
      outptr^ := inptr^;        { needn't bother with GETJSAMPLE() here }
 
178
      Inc(inptr);
 
179
      Inc(outptr);
 
180
    end;
 
181
{$endif}
 
182
  end;
 
183
end;
 
184
 
 
185
 
 
186
{GLOBAL}
 
187
procedure jcopy_block_row (input_row : JBLOCKROW;
 
188
                           output_row : JBLOCKROW;
 
189
                           num_blocks : JDIMENSION);
 
190
{ Copy a row of coefficient blocks from one place to another. }
 
191
{$ifdef FMEMCOPY}
 
192
begin
 
193
  FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
 
194
{$else}
 
195
var
 
196
  inptr, outptr : JCOEFPTR; {register}
 
197
  count : long; {register}
 
198
begin
 
199
  inptr := JCOEFPTR (input_row);
 
200
  outptr := JCOEFPTR (output_row);
 
201
  for count := long(num_blocks) * DCTSIZE2 -1 downto 0 do
 
202
  begin
 
203
    outptr^ := inptr^;
 
204
    Inc(outptr);
 
205
    Inc(inptr);
 
206
  end;
 
207
{$endif}
 
208
end;
 
209
 
 
210
 
 
211
{GLOBAL}
 
212
procedure jzero_far (target : pointer;{far} bytestozero : size_t);
 
213
{ Zero out a chunk of FAR memory. }
 
214
{ This might be sample-array data, block-array data, or alloc_large data. }
 
215
{$ifdef FMEMZERO}
 
216
begin
 
217
  FMEMZERO(target, bytestozero);
 
218
{$else}
 
219
var
 
220
  ptr : byteptr;
 
221
  count : size_t; {register}
 
222
begin
 
223
  ptr := target;
 
224
  for count := bytestozero-1 downto 0 do
 
225
  begin
 
226
    ptr^ := 0;
 
227
    Inc(ptr);
 
228
  end;
 
229
{$endif}
 
230
end;
 
231
 
 
232
end.