← Back to branch summary

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

« back to all changes in this revision

Viewing changes to fpcsrc/packages/base/pasjpeg/jcphuff.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/jcphuff.pas
 
1
Unit JcpHuff;
 
2
 
 
3
{ This file contains Huffman entropy encoding routines for progressive JPEG.
 
4
 
 
5
  We do not support output suspension in this module, since the library
 
6
  currently does not allow multiple-scan files to be written with output
 
7
  suspension. }
 
8
 
 
9
{ Original: jcphuff.c;  Copyright (C) 1995-1997, Thomas G. Lane. }
 
10
 
 
11
interface
 
12
 
 
13
{$I jconfig.inc}
 
14
uses
 
15
  jmorecfg,
 
16
  jinclude,
 
17
  jpeglib,
 
18
  jdeferr,
 
19
  jerror,
 
20
  jutils,
 
21
  jcomapi,
 
22
  jchuff;               { Declarations shared with jchuff.c }
 
23
 
 
24
 
 
25
{ Module initialization routine for progressive Huffman entropy encoding. }
 
26
 
 
27
{GLOBAL}
 
28
procedure jinit_phuff_encoder (cinfo : j_compress_ptr);
 
29
 
 
30
implementation
 
31
 
 
32
{ Expanded entropy encoder object for progressive Huffman encoding. }
 
33
type
 
34
  phuff_entropy_ptr = ^phuff_entropy_encoder;
 
35
  phuff_entropy_encoder = record
 
36
    pub : jpeg_entropy_encoder; { public fields }
 
37
 
 
38
    { Mode flag: TRUE for optimization, FALSE for actual data output }
 
39
    gather_statistics : boolean;
 
40
 
 
41
    { Bit-level coding status.
 
42
      next_output_byte/free_in_buffer are local copies of cinfo^.dest fields.}
 
43
 
 
44
    next_output_byte : JOCTETptr; { => next byte to write in buffer }
 
45
    free_in_buffer : size_t;    { # of byte spaces remaining in buffer }
 
46
    put_buffer : INT32;         { current bit-accumulation buffer }
 
47
    put_bits : int;             { # of bits now in it }
 
48
    cinfo : j_compress_ptr;     { link to cinfo (needed for dump_buffer) }
 
49
 
 
50
    { Coding status for DC components }
 
51
    last_dc_val : array[0..MAX_COMPS_IN_SCAN-1] of int;
 
52
                                { last DC coef for each component }
 
53
 
 
54
    { Coding status for AC components }
 
55
    ac_tbl_no : int;            { the table number of the single component }
 
56
    EOBRUN : uInt;              { run length of EOBs }
 
57
    BE : uInt;                  { # of buffered correction bits before MCU }
 
58
    bit_buffer : JBytePtr;      { buffer for correction bits (1 per char) }
 
59
    { packing correction bits tightly would save some space but cost time... }
 
60
 
 
61
    restarts_to_go : uInt;      { MCUs left in this restart interval }
 
62
    next_restart_num : int;     { next restart number to write (0-7) }
 
63
 
 
64
    { Pointers to derived tables (these workspaces have image lifespan).
 
65
      Since any one scan codes only DC or only AC, we only need one set
 
66
      of tables, not one for DC and one for AC. }
 
67
 
 
68
    derived_tbls : array[0..NUM_HUFF_TBLS-1] of c_derived_tbl_ptr;
 
69
 
 
70
    { Statistics tables for optimization; again, one set is enough }
 
71
    count_ptrs : array[0..NUM_HUFF_TBLS-1] of TLongTablePtr;
 
72
  end;
 
73
 
 
74
 
 
75
{ MAX_CORR_BITS is the number of bits the AC refinement correction-bit
 
76
  buffer can hold.  Larger sizes may slightly improve compression, but
 
77
  1000 is already well into the realm of overkill.
 
78
  The minimum safe size is 64 bits. }
 
79
 
 
80
const
 
81
  MAX_CORR_BITS = 1000;         { Max # of correction bits I can buffer }
 
82
 
 
83
 
 
84
{ Forward declarations }
 
85
{METHODDEF}
 
86
function encode_mcu_DC_first (cinfo : j_compress_ptr;
 
87
                              const MCU_data: array of JBLOCKROW) : boolean;
 
88
                              far; forward;
 
89
{METHODDEF}
 
90
function encode_mcu_AC_first (cinfo : j_compress_ptr;
 
91
                              const MCU_data: array of JBLOCKROW) : boolean;
 
92
                              far; forward;
 
93
{METHODDEF}
 
94
function encode_mcu_DC_refine (cinfo : j_compress_ptr;
 
95
                              const MCU_data: array of JBLOCKROW) : boolean;
 
96
                              far; forward;
 
97
{METHODDEF}
 
98
function encode_mcu_AC_refine (cinfo : j_compress_ptr;
 
99
                              const MCU_data: array of JBLOCKROW) : boolean;
 
100
                              far; forward;
 
101
 
 
102
{METHODDEF}
 
103
procedure finish_pass_phuff (cinfo : j_compress_ptr); far; forward;
 
104
 
 
105
{METHODDEF}
 
106
procedure finish_pass_gather_phuff (cinfo : j_compress_ptr); far; forward;
 
107
 
 
108
 
 
109
{ Initialize for a Huffman-compressed scan using progressive JPEG. }
 
110
 
 
111
{METHODDEF}
 
112
procedure start_pass_phuff (cinfo : j_compress_ptr;
 
113
                            gather_statistics : boolean); far;
 
114
var
 
115
  entropy : phuff_entropy_ptr;
 
116
  is_DC_band : boolean;
 
117
  ci, tbl : int;
 
118
  compptr : jpeg_component_info_ptr;
 
119
begin
 
120
  entropy := phuff_entropy_ptr (cinfo^.entropy);
 
121
 
 
122
  entropy^.cinfo := cinfo;
 
123
  entropy^.gather_statistics := gather_statistics;
 
124
 
 
125
  is_DC_band := (cinfo^.Ss = 0);
 
126
 
 
127
  { We assume jcmaster.c already validated the scan parameters. }
 
128
 
 
129
  { Select execution routines }
 
130
  if (cinfo^.Ah = 0) then
 
131
  begin
 
132
    if (is_DC_band) then
 
133
      entropy^.pub.encode_mcu := encode_mcu_DC_first
 
134
    else
 
135
      entropy^.pub.encode_mcu := encode_mcu_AC_first;
 
136
  end
 
137
  else
 
138
  begin
 
139
    if (is_DC_band) then
 
140
      entropy^.pub.encode_mcu := encode_mcu_DC_refine
 
141
    else
 
142
    begin
 
143
      entropy^.pub.encode_mcu := encode_mcu_AC_refine;
 
144
      { AC refinement needs a correction bit buffer }
 
145
      if (entropy^.bit_buffer = NIL) then
 
146
        entropy^.bit_buffer := JBytePtr(
 
147
          cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
 
148
                                      MAX_CORR_BITS * SIZEOF(byte)) );
 
149
    end;
 
150
  end;
 
151
  if (gather_statistics) then
 
152
    entropy^.pub.finish_pass := finish_pass_gather_phuff
 
153
  else
 
154
    entropy^.pub.finish_pass := finish_pass_phuff;
 
155
 
 
156
  { Only DC coefficients may be interleaved, so cinfo^.comps_in_scan = 1
 
157
    for AC coefficients. }
 
158
 
 
159
  for ci := 0 to pred(cinfo^.comps_in_scan) do
 
160
  begin
 
161
    compptr := cinfo^.cur_comp_info[ci];
 
162
    { Initialize DC predictions to 0 }
 
163
    entropy^.last_dc_val[ci] := 0;
 
164
    { Get table index }
 
165
    if (is_DC_band) then
 
166
    begin
 
167
      if (cinfo^.Ah <> 0) then  { DC refinement needs no table }
 
168
        continue;
 
169
      tbl := compptr^.dc_tbl_no;
 
170
    end
 
171
    else
 
172
    begin
 
173
      tbl := compptr^.ac_tbl_no;
 
174
      entropy^.ac_tbl_no := tbl;
 
175
    end;
 
176
    if (gather_statistics) then
 
177
    begin
 
178
      { Check for invalid table index }
 
179
      { (make_c_derived_tbl does this in the other path) }
 
180
      if (tbl < 0) or (tbl >= NUM_HUFF_TBLS) then
 
181
        ERREXIT1(j_common_ptr(cinfo), JERR_NO_HUFF_TABLE, tbl);
 
182
      { Allocate and zero the statistics tables }
 
183
      { Note that jpeg_gen_optimal_table expects 257 entries in each table! }
 
184
      if (entropy^.count_ptrs[tbl] = NIL) then
 
185
        entropy^.count_ptrs[tbl] := TLongTablePtr(
 
186
          cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
 
187
                                      257 * SIZEOF(long)) );
 
188
      MEMZERO(entropy^.count_ptrs[tbl], 257 * SIZEOF(long));
 
189
    end else
 
190
    begin
 
191
      { Compute derived values for Huffman table }
 
192
      { We may do this more than once for a table, but it's not expensive }
 
193
      jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
 
194
                              entropy^.derived_tbls[tbl]);
 
195
    end;
 
196
  end;
 
197
 
 
198
  { Initialize AC stuff }
 
199
  entropy^.EOBRUN := 0;
 
200
  entropy^.BE := 0;
 
201
 
 
202
  { Initialize bit buffer to empty }
 
203
  entropy^.put_buffer := 0;
 
204
  entropy^.put_bits := 0;
 
205
 
 
206
  { Initialize restart stuff }
 
207
  entropy^.restarts_to_go := cinfo^.restart_interval;
 
208
  entropy^.next_restart_num := 0;
 
209
end;
 
210
 
 
211
 
 
212
 
 
213
 
 
214
{LOCAL}
 
215
procedure dump_buffer (entropy : phuff_entropy_ptr);
 
216
{ Empty the output buffer; we do not support suspension in this module. }
 
217
var
 
218
  dest : jpeg_destination_mgr_ptr;
 
219
begin
 
220
  dest := entropy^.cinfo^.dest;
 
221
 
 
222
  if (not dest^.empty_output_buffer (entropy^.cinfo)) then
 
223
    ERREXIT(j_common_ptr(entropy^.cinfo), JERR_CANT_SUSPEND);
 
224
  { After a successful buffer dump, must reset buffer pointers }
 
225
  entropy^.next_output_byte := dest^.next_output_byte;
 
226
  entropy^.free_in_buffer := dest^.free_in_buffer;
 
227
end;
 
228
 
 
229
 
 
230
{ Outputting bits to the file }
 
231
 
 
232
{ Only the right 24 bits of put_buffer are used; the valid bits are
 
233
  left-justified in this part.  At most 16 bits can be passed to emit_bits
 
234
  in one call, and we never retain more than 7 bits in put_buffer
 
235
  between calls, so 24 bits are sufficient. }
 
236
 
 
237
 
 
238
{LOCAL}
 
239
procedure emit_bits (entropy : phuff_entropy_ptr;
 
240
                     code : uInt;
 
241
                     size : int); {INLINE}
 
242
{ Emit some bits, unless we are in gather mode }
 
243
var
 
244
  {register} put_buffer : INT32;
 
245
  {register} put_bits : int;
 
246
var
 
247
  c : int;
 
248
begin
 
249
  { This routine is heavily used, so it's worth coding tightly. }
 
250
  put_buffer := INT32 (code);
 
251
  put_bits := entropy^.put_bits;
 
252
 
 
253
  { if size is 0, caller used an invalid Huffman table entry }
 
254
  if (size = 0) then
 
255
    ERREXIT(j_common_ptr(entropy^.cinfo), JERR_HUFF_MISSING_CODE);
 
256
 
 
257
  if (entropy^.gather_statistics) then
 
258
    exit;                       { do nothing if we're only getting stats }
 
259
 
 
260
  put_buffer := put_buffer and ((INT32(1) shl size) - 1);
 
261
                                { mask off any extra bits in code }
 
262
 
 
263
  Inc(put_bits, size);          { new number of bits in buffer }
 
264
 
 
265
  put_buffer := put_buffer shl (24 - put_bits); { align incoming bits }
 
266
 
 
267
  put_buffer := put_buffer or entropy^.put_buffer;
 
268
                                { and merge with old buffer contents }
 
269
 
 
270
  while (put_bits >= 8) do
 
271
  begin
 
272
    c := int ((put_buffer shr 16) and $FF);
 
273
 
 
274
    {emit_byte(entropy, c);}
 
275
    { Outputting bytes to the file.
 
276
      NB: these must be called only when actually outputting,
 
277
      that is, entropy^.gather_statistics = FALSE. }
 
278
    { Emit a byte }
 
279
    entropy^.next_output_byte^ := JOCTET(c);
 
280
    Inc(entropy^.next_output_byte);
 
281
    Dec(entropy^.free_in_buffer);
 
282
    if (entropy^.free_in_buffer = 0) then
 
283
      dump_buffer(entropy);
 
284
 
 
285
    if (c = $FF) then
 
286
    begin               { need to stuff a zero byte? }
 
287
      {emit_byte(entropy, 0);}
 
288
      entropy^.next_output_byte^ := JOCTET(0);
 
289
      Inc(entropy^.next_output_byte);
 
290
      Dec(entropy^.free_in_buffer);
 
291
      if (entropy^.free_in_buffer = 0) then
 
292
        dump_buffer(entropy);
 
293
    end;
 
294
    put_buffer := put_buffer shl 8;
 
295
    Dec(put_bits, 8);
 
296
  end;
 
297
 
 
298
  entropy^.put_buffer := put_buffer; { update variables }
 
299
  entropy^.put_bits := put_bits;
 
300
end;
 
301
 
 
302
 
 
303
{LOCAL}
 
304
procedure flush_bits (entropy : phuff_entropy_ptr);
 
305
begin
 
306
  emit_bits(entropy, $7F, 7); { fill any partial byte with ones }
 
307
  entropy^.put_buffer := 0;     { and reset bit-buffer to empty }
 
308
  entropy^.put_bits := 0;
 
309
end;
 
310
 
 
311
{ Emit (or just count) a Huffman symbol. }
 
312
 
 
313
 
 
314
{LOCAL}
 
315
procedure emit_symbol (entropy : phuff_entropy_ptr;
 
316
                       tbl_no : int;
 
317
                       symbol : int); {INLINE}
 
318
var
 
319
  tbl : c_derived_tbl_ptr;
 
320
begin
 
321
  if (entropy^.gather_statistics) then
 
322
    Inc(entropy^.count_ptrs[tbl_no]^[symbol])
 
323
  else
 
324
  begin
 
325
    tbl := entropy^.derived_tbls[tbl_no];
 
326
    emit_bits(entropy, tbl^.ehufco[symbol], tbl^.ehufsi[symbol]);
 
327
  end;
 
328
end;
 
329
 
 
330
 
 
331
{ Emit bits from a correction bit buffer. }
 
332
 
 
333
{LOCAL}
 
334
procedure emit_buffered_bits (entropy : phuff_entropy_ptr;
 
335
                              bufstart : JBytePtr;
 
336
                              nbits : uInt);
 
337
var
 
338
  bufptr : byteptr;
 
339
begin
 
340
  if (entropy^.gather_statistics) then
 
341
    exit;                       { no real work }
 
342
 
 
343
  bufptr := byteptr(bufstart);
 
344
  while (nbits > 0) do
 
345
  begin
 
346
    emit_bits(entropy, uInt(bufptr^), 1);
 
347
    Inc(bufptr);
 
348
    Dec(nbits);
 
349
  end;
 
350
end;
 
351
 
 
352
 
 
353
{ Emit any pending EOBRUN symbol. }
 
354
 
 
355
{LOCAL}
 
356
procedure emit_eobrun (entropy : phuff_entropy_ptr);
 
357
var
 
358
  {register} temp, nbits : int;
 
359
begin
 
360
  if (entropy^.EOBRUN > 0) then
 
361
  begin                        { if there is any pending EOBRUN }
 
362
    temp := entropy^.EOBRUN;
 
363
    nbits := 0;
 
364
    temp := temp shr 1;
 
365
    while (temp <> 0) do
 
366
    begin
 
367
      Inc(nbits);
 
368
      temp := temp shr 1;
 
369
    end;
 
370
 
 
371
    { safety check: shouldn't happen given limited correction-bit buffer }
 
372
    if (nbits > 14) then
 
373
      ERREXIT(j_common_ptr(entropy^.cinfo), JERR_HUFF_MISSING_CODE);
 
374
 
 
375
    emit_symbol(entropy, entropy^.ac_tbl_no, nbits shl 4);
 
376
    if (nbits <> 0) then
 
377
      emit_bits(entropy, entropy^.EOBRUN, nbits);
 
378
 
 
379
    entropy^.EOBRUN := 0;
 
380
 
 
381
    { Emit any buffered correction bits }
 
382
    emit_buffered_bits(entropy, entropy^.bit_buffer, entropy^.BE);
 
383
    entropy^.BE := 0;
 
384
  end;
 
385
end;
 
386
 
 
387
 
 
388
{ Emit a restart marker & resynchronize predictions. }
 
389
 
 
390
{LOCAL}
 
391
procedure emit_restart (entropy : phuff_entropy_ptr;
 
392
                        restart_num : int);
 
393
var
 
394
  ci : int;
 
395
begin
 
396
  emit_eobrun(entropy);
 
397
 
 
398
  if (not entropy^.gather_statistics) then
 
399
  begin
 
400
    flush_bits(entropy);
 
401
    {emit_byte(entropy, $FF);}
 
402
    { Outputting bytes to the file.
 
403
      NB: these must be called only when actually outputting,
 
404
      that is, entropy^.gather_statistics = FALSE. }
 
405
 
 
406
    entropy^.next_output_byte^ := JOCTET($FF);
 
407
    Inc(entropy^.next_output_byte);
 
408
    Dec(entropy^.free_in_buffer);
 
409
    if (entropy^.free_in_buffer = 0) then
 
410
      dump_buffer(entropy);
 
411
 
 
412
    {emit_byte(entropy, JPEG_RST0 + restart_num);}
 
413
    entropy^.next_output_byte^ := JOCTET(JPEG_RST0 + restart_num);
 
414
    Inc(entropy^.next_output_byte);
 
415
    Dec(entropy^.free_in_buffer);
 
416
    if (entropy^.free_in_buffer = 0) then
 
417
      dump_buffer(entropy);
 
418
  end;
 
419
 
 
420
  if (entropy^.cinfo^.Ss = 0) then
 
421
  begin
 
422
    { Re-initialize DC predictions to 0 }
 
423
    for ci := 0 to pred(entropy^.cinfo^.comps_in_scan) do
 
424
      entropy^.last_dc_val[ci] := 0;
 
425
  end
 
426
  else
 
427
  begin
 
428
    { Re-initialize all AC-related fields to 0 }
 
429
    entropy^.EOBRUN := 0;
 
430
    entropy^.BE := 0;
 
431
  end;
 
432
end;
 
433
 
 
434
 
 
435
{ MCU encoding for DC initial scan (either spectral selection,
 
436
  or first pass of successive approximation). }
 
437
 
 
438
{METHODDEF}
 
439
function encode_mcu_DC_first (cinfo : j_compress_ptr;
 
440
                              const MCU_data: array of JBLOCKROW) : boolean;
 
441
var
 
442
  entropy : phuff_entropy_ptr;
 
443
  {register} temp, temp2 : int;
 
444
  {register} nbits : int;
 
445
  blkn, ci : int;
 
446
  Al : int;
 
447
  block : JBLOCK_PTR;
 
448
  compptr : jpeg_component_info_ptr;
 
449
  ishift_temp : int;
 
450
begin
 
451
  entropy := phuff_entropy_ptr (cinfo^.entropy);
 
452
  Al := cinfo^.Al;
 
453
 
 
454
  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
 
455
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;
 
456
 
 
457
  { Emit restart marker if needed }
 
458
  if (cinfo^.restart_interval <> 0) then
 
459
    if (entropy^.restarts_to_go = 0) then
 
460
      emit_restart(entropy, entropy^.next_restart_num);
 
461
 
 
462
  { Encode the MCU data blocks }
 
463
  for blkn := 0 to pred(cinfo^.blocks_in_MCU) do
 
464
  begin
 
465
    block := JBLOCK_PTR(MCU_data[blkn]);
 
466
    ci := cinfo^.MCU_membership[blkn];
 
467
    compptr := cinfo^.cur_comp_info[ci];
 
468
 
 
469
    { Compute the DC value after the required point transform by Al.
 
470
      This is simply an arithmetic right shift. }
 
471
 
 
472
    {temp2 := IRIGHT_SHIFT( int(block^[0]), Al);}
 
473
    {IRIGHT_SHIFT_IS_UNSIGNED}
 
474
    ishift_temp := int(block^[0]);
 
475
    if ishift_temp < 0 then
 
476
      temp2 := (ishift_temp shr Al) or ((not 0) shl (16-Al))
 
477
    else
 
478
      temp2 := ishift_temp shr Al;
 
479
 
 
480
 
 
481
    { DC differences are figured on the point-transformed values. }
 
482
    temp := temp2 - entropy^.last_dc_val[ci];
 
483
    entropy^.last_dc_val[ci] := temp2;
 
484
 
 
485
    { Encode the DC coefficient difference per section G.1.2.1 }
 
486
    temp2 := temp;
 
487
    if (temp < 0) then
 
488
    begin
 
489
      temp := -temp;            { temp is abs value of input }
 
490
      { For a negative input, want temp2 := bitwise complement of abs(input) }
 
491
      { This code assumes we are on a two's complement machine }
 
492
      Dec(temp2);
 
493
    end;
 
494
 
 
495
    { Find the number of bits needed for the magnitude of the coefficient }
 
496
    nbits := 0;
 
497
    while (temp <> 0) do
 
498
    begin
 
499
      Inc(nbits);
 
500
      temp := temp shr 1;
 
501
    end;
 
502
 
 
503
    { Check for out-of-range coefficient values.
 
504
      Since we're encoding a difference, the range limit is twice as much. }
 
505
 
 
506
    if (nbits > MAX_COEF_BITS+1) then
 
507
      ERREXIT(j_common_ptr(cinfo), JERR_BAD_DCT_COEF);
 
508
 
 
509
    { Count/emit the Huffman-coded symbol for the number of bits }
 
510
    emit_symbol(entropy, compptr^.dc_tbl_no, nbits);
 
511
 
 
512
    { Emit that number of bits of the value, if positive, }
 
513
    { or the complement of its magnitude, if negative. }
 
514
    if (nbits <> 0) then       { emit_bits rejects calls with size 0 }
 
515
      emit_bits(entropy, uInt(temp2), nbits);
 
516
  end;
 
517
 
 
518
  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
 
519
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;
 
520
 
 
521
  { Update restart-interval state too }
 
522
  if (cinfo^.restart_interval <> 0) then
 
523
  begin
 
524
    if (entropy^.restarts_to_go = 0) then
 
525
    begin
 
526
      entropy^.restarts_to_go := cinfo^.restart_interval;
 
527
      Inc(entropy^.next_restart_num);
 
528
      with entropy^ do
 
529
        next_restart_num := next_restart_num and 7;
 
530
    end;
 
531
    Dec(entropy^.restarts_to_go);
 
532
  end;
 
533
 
 
534
  encode_mcu_DC_first := TRUE;
 
535
end;
 
536
 
 
537
 
 
538
{ MCU encoding for AC initial scan (either spectral selection,
 
539
  or first pass of successive approximation). }
 
540
 
 
541
{METHODDEF}
 
542
function encode_mcu_AC_first (cinfo : j_compress_ptr;
 
543
                              const MCU_data: array of JBLOCKROW) : boolean;
 
544
var
 
545
  entropy : phuff_entropy_ptr;
 
546
  {register} temp, temp2 : int;
 
547
  {register} nbits : int;
 
548
  {register} r, k : int;
 
549
  Se : int;
 
550
  Al : int;
 
551
  block : JBLOCK_PTR;
 
552
begin
 
553
  entropy := phuff_entropy_ptr (cinfo^.entropy);
 
554
  Se := cinfo^.Se;
 
555
  Al := cinfo^.Al;
 
556
 
 
557
  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
 
558
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;
 
559
 
 
560
  { Emit restart marker if needed }
 
561
  if (cinfo^.restart_interval <> 0) then
 
562
    if (entropy^.restarts_to_go = 0) then
 
563
      emit_restart(entropy, entropy^.next_restart_num);
 
564
 
 
565
  { Encode the MCU data block }
 
566
  block := JBLOCK_PTR(MCU_data[0]);
 
567
 
 
568
  { Encode the AC coefficients per section G.1.2.2, fig. G.3 }
 
569
 
 
570
  r := 0;                       { r := run length of zeros }
 
571
 
 
572
  for k := cinfo^.Ss to Se do
 
573
  begin
 
574
    temp := (block^[jpeg_natural_order[k]]);
 
575
    if (temp = 0) then
 
576
    begin
 
577
      Inc(r);
 
578
      continue;
 
579
    end;
 
580
    { We must apply the point transform by Al.  For AC coefficients this
 
581
      is an integer division with rounding towards 0.  To do this portably
 
582
      in C, we shift after obtaining the absolute value; so the code is
 
583
      interwoven with finding the abs value (temp) and output bits (temp2). }
 
584
 
 
585
    if (temp < 0) then
 
586
    begin
 
587
      temp := -temp;            { temp is abs value of input }
 
588
      temp := temp shr Al;      { apply the point transform }
 
589
      { For a negative coef, want temp2 := bitwise complement of abs(coef) }
 
590
      temp2 := not temp;
 
591
    end
 
592
    else
 
593
    begin
 
594
      temp := temp shr Al;      { apply the point transform }
 
595
      temp2 := temp;
 
596
    end;
 
597
    { Watch out for case that nonzero coef is zero after point transform }
 
598
    if (temp = 0) then
 
599
    begin
 
600
      Inc(r);
 
601
      continue;
 
602
    end;
 
603
 
 
604
    { Emit any pending EOBRUN }
 
605
    if (entropy^.EOBRUN > 0) then
 
606
      emit_eobrun(entropy);
 
607
    { if run length > 15, must emit special run-length-16 codes ($F0) }
 
608
    while (r > 15) do
 
609
    begin
 
610
      emit_symbol(entropy, entropy^.ac_tbl_no, $F0);
 
611
      Dec(r, 16);
 
612
    end;
 
613
 
 
614
    { Find the number of bits needed for the magnitude of the coefficient }
 
615
    nbits := 0;                 { there must be at least one 1 bit }
 
616
    repeat
 
617
      Inc(nbits);
 
618
      temp := temp shr 1;
 
619
    until (temp = 0);
 
620
 
 
621
    { Check for out-of-range coefficient values }
 
622
    if (nbits > MAX_COEF_BITS) then
 
623
      ERREXIT(j_common_ptr(cinfo), JERR_BAD_DCT_COEF);
 
624
 
 
625
    { Count/emit Huffman symbol for run length / number of bits }
 
626
    emit_symbol(entropy, entropy^.ac_tbl_no, (r shl 4) + nbits);
 
627
 
 
628
    { Emit that number of bits of the value, if positive, }
 
629
    { or the complement of its magnitude, if negative. }
 
630
    emit_bits(entropy, uInt(temp2), nbits);
 
631
 
 
632
    r := 0;                     { reset zero run length }
 
633
  end;
 
634
 
 
635
  if (r > 0) then
 
636
  begin                         { If there are trailing zeroes, }
 
637
    Inc(entropy^.EOBRUN);       { count an EOB }
 
638
    if (entropy^.EOBRUN = $7FFF) then
 
639
      emit_eobrun(entropy);     { force it out to avoid overflow }
 
640
  end;
 
641
 
 
642
  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
 
643
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;
 
644
 
 
645
  { Update restart-interval state too }
 
646
  if (cinfo^.restart_interval <> 0) then
 
647
  begin
 
648
    if (entropy^.restarts_to_go = 0) then
 
649
    begin
 
650
      entropy^.restarts_to_go := cinfo^.restart_interval;
 
651
      Inc(entropy^.next_restart_num);
 
652
      with entropy^ do
 
653
        next_restart_num := next_restart_num and 7;
 
654
    end;
 
655
    Dec(entropy^.restarts_to_go);
 
656
  end;
 
657
 
 
658
  encode_mcu_AC_first := TRUE;
 
659
end;
 
660
 
 
661
 
 
662
{ MCU encoding for DC successive approximation refinement scan.
 
663
  Note: we assume such scans can be multi-component, although the spec
 
664
  is not very clear on the point. }
 
665
 
 
666
{METHODDEF}
 
667
function encode_mcu_DC_refine (cinfo : j_compress_ptr;
 
668
                              const MCU_data: array of JBLOCKROW) : boolean;
 
669
var
 
670
  entropy : phuff_entropy_ptr;
 
671
  {register} temp : int;
 
672
  blkn : int;
 
673
  Al : int;
 
674
  block : JBLOCK_PTR;
 
675
begin
 
676
  entropy := phuff_entropy_ptr (cinfo^.entropy);
 
677
  Al := cinfo^.Al;
 
678
 
 
679
  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
 
680
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;
 
681
 
 
682
  { Emit restart marker if needed }
 
683
  if (cinfo^.restart_interval <> 0) then
 
684
    if (entropy^.restarts_to_go = 0) then
 
685
      emit_restart(entropy, entropy^.next_restart_num);
 
686
 
 
687
  { Encode the MCU data blocks }
 
688
  for blkn := 0 to pred(cinfo^.blocks_in_MCU) do
 
689
  begin
 
690
    block := JBLOCK_PTR(MCU_data[blkn]);
 
691
 
 
692
    { We simply emit the Al'th bit of the DC coefficient value. }
 
693
    temp := block^[0];
 
694
    emit_bits(entropy, uInt(temp shr Al), 1);
 
695
  end;
 
696
 
 
697
  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
 
698
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;
 
699
 
 
700
  { Update restart-interval state too }
 
701
  if (cinfo^.restart_interval <> 0) then
 
702
  begin
 
703
    if (entropy^.restarts_to_go = 0) then
 
704
    begin
 
705
      entropy^.restarts_to_go := cinfo^.restart_interval;
 
706
      Inc(entropy^.next_restart_num);
 
707
      with entropy^ do
 
708
        next_restart_num := next_restart_num and 7;
 
709
    end;
 
710
    Dec(entropy^.restarts_to_go);
 
711
  end;
 
712
 
 
713
  encode_mcu_DC_refine := TRUE;
 
714
end;
 
715
 
 
716
 
 
717
{ MCU encoding for AC successive approximation refinement scan. }
 
718
 
 
719
{METHODDEF}
 
720
function encode_mcu_AC_refine (cinfo : j_compress_ptr;
 
721
                               const MCU_data: array of JBLOCKROW) : boolean;
 
722
 
 
723
var
 
724
  entropy : phuff_entropy_ptr;
 
725
  {register} temp : int;
 
726
  {register} r, k : int;
 
727
  EOB : int;
 
728
  BR_buffer : JBytePtr;
 
729
  BR : uInt;
 
730
  Se : int;
 
731
  Al : int;
 
732
  block : JBLOCK_PTR;
 
733
  absvalues : array[0..DCTSIZE2-1] of int;
 
734
begin
 
735
  entropy := phuff_entropy_ptr(cinfo^.entropy);
 
736
  Se := cinfo^.Se;
 
737
  Al := cinfo^.Al;
 
738
 
 
739
  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
 
740
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;
 
741
 
 
742
  { Emit restart marker if needed }
 
743
  if (cinfo^.restart_interval <> 0) then
 
744
    if (entropy^.restarts_to_go = 0) then
 
745
      emit_restart(entropy, entropy^.next_restart_num);
 
746
 
 
747
  { Encode the MCU data block }
 
748
  block := JBLOCK_PTR(MCU_data[0]);
 
749
 
 
750
  { It is convenient to make a pre-pass to determine the transformed
 
751
    coefficients' absolute values and the EOB position. }
 
752
 
 
753
  EOB := 0;
 
754
  for k := cinfo^.Ss to Se do
 
755
  begin
 
756
    temp := block^[jpeg_natural_order[k]];
 
757
    { We must apply the point transform by Al.  For AC coefficients this
 
758
      is an integer division with rounding towards 0.  To do this portably
 
759
      in C, we shift after obtaining the absolute value. }
 
760
 
 
761
    if (temp < 0) then
 
762
      temp := -temp;            { temp is abs value of input }
 
763
    temp := temp shr Al;                { apply the point transform }
 
764
    absvalues[k] := temp;       { save abs value for main pass }
 
765
    if (temp = 1) then
 
766
      EOB := k;                 { EOB := index of last newly-nonzero coef }
 
767
  end;
 
768
 
 
769
  { Encode the AC coefficients per section G.1.2.3, fig. G.7 }
 
770
 
 
771
  r := 0;                       { r := run length of zeros }
 
772
  BR := 0;                      { BR := count of buffered bits added now }
 
773
  BR_buffer := JBytePtr(@(entropy^.bit_buffer^[entropy^.BE]));
 
774
                                { Append bits to buffer }
 
775
 
 
776
  for k := cinfo^.Ss to Se do
 
777
  begin
 
778
    temp := absvalues[k];
 
779
    if (temp = 0) then
 
780
    begin
 
781
      Inc(r);
 
782
      continue;
 
783
    end;
 
784
 
 
785
    { Emit any required ZRLs, but not if they can be folded into EOB }
 
786
    while (r > 15) and (k <= EOB) do
 
787
    begin
 
788
      { emit any pending EOBRUN and the BE correction bits }
 
789
      emit_eobrun(entropy);
 
790
      { Emit ZRL }
 
791
      emit_symbol(entropy, entropy^.ac_tbl_no, $F0);
 
792
      Dec(r, 16);
 
793
      { Emit buffered correction bits that must be associated with ZRL }
 
794
      emit_buffered_bits(entropy, BR_buffer, BR);
 
795
      BR_buffer := entropy^.bit_buffer; { BE bits are gone now }
 
796
      BR := 0;
 
797
    end;
 
798
 
 
799
    { If the coef was previously nonzero, it only needs a correction bit.
 
800
      NOTE: a straight translation of the spec's figure G.7 would suggest
 
801
      that we also need to test r > 15.  But if r > 15, we can only get here
 
802
      if k > EOB, which implies that this coefficient is not 1. }
 
803
    if (temp > 1) then
 
804
    begin
 
805
      { The correction bit is the next bit of the absolute value. }
 
806
      BR_buffer^[BR] := byte (temp and 1);
 
807
      Inc(BR);
 
808
      continue;
 
809
    end;
 
810
 
 
811
    { Emit any pending EOBRUN and the BE correction bits }
 
812
    emit_eobrun(entropy);
 
813
 
 
814
    { Count/emit Huffman symbol for run length / number of bits }
 
815
    emit_symbol(entropy, entropy^.ac_tbl_no, (r shl 4) + 1);
 
816
 
 
817
    { Emit output bit for newly-nonzero coef }
 
818
    if (block^[jpeg_natural_order[k]] < 0) then
 
819
      temp := 0
 
820
    else
 
821
      temp := 1;
 
822
    emit_bits(entropy, uInt(temp), 1);
 
823
 
 
824
    { Emit buffered correction bits that must be associated with this code }
 
825
    emit_buffered_bits(entropy, BR_buffer, BR);
 
826
    BR_buffer := entropy^.bit_buffer; { BE bits are gone now }
 
827
    BR := 0;
 
828
    r := 0;                     { reset zero run length }
 
829
  end;
 
830
 
 
831
  if (r > 0) or (BR > 0) then
 
832
  begin                         { If there are trailing zeroes, }
 
833
    Inc(entropy^.EOBRUN);       { count an EOB }
 
834
    Inc(entropy^.BE, BR);          { concat my correction bits to older ones }
 
835
    { We force out the EOB if we risk either:
 
836
      1. overflow of the EOB counter;
 
837
      2. overflow of the correction bit buffer during the next MCU. }
 
838
 
 
839
    if (entropy^.EOBRUN = $7FFF) or
 
840
       (entropy^.BE > (MAX_CORR_BITS-DCTSIZE2+1)) then
 
841
      emit_eobrun(entropy);
 
842
  end;
 
843
 
 
844
  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
 
845
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;
 
846
 
 
847
  { Update restart-interval state too }
 
848
  if (cinfo^.restart_interval <> 0) then
 
849
  begin
 
850
    if (entropy^.restarts_to_go = 0) then
 
851
    begin
 
852
      entropy^.restarts_to_go := cinfo^.restart_interval;
 
853
      Inc(entropy^.next_restart_num);
 
854
      with entropy^ do
 
855
        next_restart_num := next_restart_num and 7;
 
856
    end;
 
857
    Dec(entropy^.restarts_to_go);
 
858
  end;
 
859
 
 
860
  encode_mcu_AC_refine := TRUE;
 
861
end;
 
862
 
 
863
 
 
864
{ Finish up at the end of a Huffman-compressed progressive scan. }
 
865
 
 
866
{METHODDEF}
 
867
procedure finish_pass_phuff (cinfo : j_compress_ptr);
 
868
var
 
869
  entropy : phuff_entropy_ptr;
 
870
begin
 
871
  entropy := phuff_entropy_ptr (cinfo^.entropy);
 
872
 
 
873
  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
 
874
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;
 
875
 
 
876
  { Flush out any buffered data }
 
877
  emit_eobrun(entropy);
 
878
  flush_bits(entropy);
 
879
 
 
880
  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
 
881
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;
 
882
end;
 
883
 
 
884
 
 
885
{ Finish up a statistics-gathering pass and create the new Huffman tables. }
 
886
 
 
887
{METHODDEF}
 
888
procedure finish_pass_gather_phuff (cinfo : j_compress_ptr);
 
889
var
 
890
  entropy : phuff_entropy_ptr;
 
891
  is_DC_band : boolean;
 
892
  ci, tbl : int;
 
893
  compptr : jpeg_component_info_ptr;
 
894
  htblptr : ^JHUFF_TBL_PTR;
 
895
  did : array[0..NUM_HUFF_TBLS-1] of boolean;
 
896
begin
 
897
  entropy := phuff_entropy_ptr (cinfo^.entropy);
 
898
 
 
899
  { Flush out buffered data (all we care about is counting the EOB symbol) }
 
900
  emit_eobrun(entropy);
 
901
 
 
902
  is_DC_band := (cinfo^.Ss = 0);
 
903
 
 
904
  { It's important not to apply jpeg_gen_optimal_table more than once
 
905
    per table, because it clobbers the input frequency counts! }
 
906
 
 
907
  MEMZERO(@did, SIZEOF(did));
 
908
 
 
909
  for ci := 0 to pred(cinfo^.comps_in_scan) do
 
910
  begin
 
911
    compptr := cinfo^.cur_comp_info[ci];
 
912
    if (is_DC_band) then
 
913
    begin
 
914
      if (cinfo^.Ah <> 0) then     { DC refinement needs no table }
 
915
        continue;
 
916
      tbl := compptr^.dc_tbl_no;
 
917
    end
 
918
    else
 
919
    begin
 
920
      tbl := compptr^.ac_tbl_no;
 
921
    end;
 
922
    if (not did[tbl]) then
 
923
    begin
 
924
      if (is_DC_band) then
 
925
        htblptr := @(cinfo^.dc_huff_tbl_ptrs[tbl])
 
926
      else
 
927
        htblptr := @(cinfo^.ac_huff_tbl_ptrs[tbl]);
 
928
      if (htblptr^ = NIL) then
 
929
        htblptr^ := jpeg_alloc_huff_table(j_common_ptr(cinfo));
 
930
      jpeg_gen_optimal_table(cinfo, htblptr^, entropy^.count_ptrs[tbl]^);
 
931
      did[tbl] := TRUE;
 
932
    end;
 
933
  end;
 
934
end;
 
935
 
 
936
 
 
937
{ Module initialization routine for progressive Huffman entropy encoding. }
 
938
 
 
939
{GLOBAL}
 
940
procedure jinit_phuff_encoder (cinfo : j_compress_ptr);
 
941
var
 
942
  entropy : phuff_entropy_ptr;
 
943
  i : int;
 
944
begin
 
945
  entropy := phuff_entropy_ptr(
 
946
    cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
 
947
                                SIZEOF(phuff_entropy_encoder)) );
 
948
  cinfo^.entropy := jpeg_entropy_encoder_ptr(entropy);
 
949
  entropy^.pub.start_pass := start_pass_phuff;
 
950
 
 
951
  { Mark tables unallocated }
 
952
  for i := 0 to pred(NUM_HUFF_TBLS) do
 
953
  begin
 
954
    entropy^.derived_tbls[i] := NIL;
 
955
    entropy^.count_ptrs[i] := NIL;
 
956
  end;
 
957
  entropy^.bit_buffer := NIL;   { needed only in AC refinement scan }
 
958
end;
 
959
 
 
960
end.