← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/libjpeg_turbo/src/jpegint.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/libjpeg_turbo/src/jpegint.h
1
 
/*
2
 
 * jpegint.h
3
 
 *
4
 
 * Copyright (C) 1991-1997, Thomas G. Lane.
5
 
 * Modified 1997-2009 by Guido Vollbeding.
6
 
 * This file is part of the Independent JPEG Group's software.
7
 
 * For conditions of distribution and use, see the accompanying README file.
8
 
 *
9
 
 * This file provides common declarations for the various JPEG modules.
10
 
 * These declarations are considered internal to the JPEG library; most
11
 
 * applications using the library shouldn't need to include this file.
12
 
 */
13
 
 
14
 
 
15
 
/* Declarations for both compression & decompression */
16
 
 
17
 
typedef enum {                  /* Operating modes for buffer controllers */
18
 
        JBUF_PASS_THRU,         /* Plain stripwise operation */
19
 
        /* Remaining modes require a full-image buffer to have been created */
20
 
        JBUF_SAVE_SOURCE,       /* Run source subobject only, save output */
21
 
        JBUF_CRANK_DEST,        /* Run dest subobject only, using saved data */
22
 
        JBUF_SAVE_AND_PASS      /* Run both subobjects, save output */
23
 
} J_BUF_MODE;
24
 
 
25
 
/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
26
 
#define CSTATE_START    100     /* after create_compress */
27
 
#define CSTATE_SCANNING 101     /* start_compress done, write_scanlines OK */
28
 
#define CSTATE_RAW_OK   102     /* start_compress done, write_raw_data OK */
29
 
#define CSTATE_WRCOEFS  103     /* jpeg_write_coefficients done */
30
 
#define DSTATE_START    200     /* after create_decompress */
31
 
#define DSTATE_INHEADER 201     /* reading header markers, no SOS yet */
32
 
#define DSTATE_READY    202     /* found SOS, ready for start_decompress */
33
 
#define DSTATE_PRELOAD  203     /* reading multiscan file in start_decompress*/
34
 
#define DSTATE_PRESCAN  204     /* performing dummy pass for 2-pass quant */
35
 
#define DSTATE_SCANNING 205     /* start_decompress done, read_scanlines OK */
36
 
#define DSTATE_RAW_OK   206     /* start_decompress done, read_raw_data OK */
37
 
#define DSTATE_BUFIMAGE 207     /* expecting jpeg_start_output */
38
 
#define DSTATE_BUFPOST  208     /* looking for SOS/EOI in jpeg_finish_output */
39
 
#define DSTATE_RDCOEFS  209     /* reading file in jpeg_read_coefficients */
40
 
#define DSTATE_STOPPING 210     /* looking for EOI in jpeg_finish_decompress */
41
 
 
42
 
 
43
 
/* Declarations for compression modules */
44
 
 
45
 
/* Master control module */
46
 
struct jpeg_comp_master {
47
 
  JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
48
 
  JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
49
 
  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
50
 
 
51
 
  /* State variables made visible to other modules */
52
 
  boolean call_pass_startup;    /* True if pass_startup must be called */
53
 
  boolean is_last_pass;         /* True during last pass */
54
 
};
55
 
 
56
 
/* Main buffer control (downsampled-data buffer) */
57
 
struct jpeg_c_main_controller {
58
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
59
 
  JMETHOD(void, process_data, (j_compress_ptr cinfo,
60
 
                               JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
61
 
                               JDIMENSION in_rows_avail));
62
 
};
63
 
 
64
 
/* Compression preprocessing (downsampling input buffer control) */
65
 
struct jpeg_c_prep_controller {
66
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
67
 
  JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
68
 
                                   JSAMPARRAY input_buf,
69
 
                                   JDIMENSION *in_row_ctr,
70
 
                                   JDIMENSION in_rows_avail,
71
 
                                   JSAMPIMAGE output_buf,
72
 
                                   JDIMENSION *out_row_group_ctr,
73
 
                                   JDIMENSION out_row_groups_avail));
74
 
};
75
 
 
76
 
/* Coefficient buffer control */
77
 
struct jpeg_c_coef_controller {
78
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
79
 
  JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
80
 
                                   JSAMPIMAGE input_buf));
81
 
};
82
 
 
83
 
/* Colorspace conversion */
84
 
struct jpeg_color_converter {
85
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
86
 
  JMETHOD(void, color_convert, (j_compress_ptr cinfo,
87
 
                                JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
88
 
                                JDIMENSION output_row, int num_rows));
89
 
};
90
 
 
91
 
/* Downsampling */
92
 
struct jpeg_downsampler {
93
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
94
 
  JMETHOD(void, downsample, (j_compress_ptr cinfo,
95
 
                             JSAMPIMAGE input_buf, JDIMENSION in_row_index,
96
 
                             JSAMPIMAGE output_buf,
97
 
                             JDIMENSION out_row_group_index));
98
 
 
99
 
  boolean need_context_rows;    /* TRUE if need rows above & below */
100
 
};
101
 
 
102
 
/* Forward DCT (also controls coefficient quantization) */
103
 
struct jpeg_forward_dct {
104
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
105
 
  /* perhaps this should be an array??? */
106
 
  JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
107
 
                              jpeg_component_info * compptr,
108
 
                              JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
109
 
                              JDIMENSION start_row, JDIMENSION start_col,
110
 
                              JDIMENSION num_blocks));
111
 
};
112
 
 
113
 
/* Entropy encoding */
114
 
struct jpeg_entropy_encoder {
115
 
  JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
116
 
  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
117
 
  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
118
 
};
119
 
 
120
 
/* Marker writing */
121
 
struct jpeg_marker_writer {
122
 
  JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
123
 
  JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
124
 
  JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
125
 
  JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
126
 
  JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
127
 
  /* These routines are exported to allow insertion of extra markers */
128
 
  /* Probably only COM and APPn markers should be written this way */
129
 
  JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
130
 
                                      unsigned int datalen));
131
 
  JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
132
 
};
133
 
 
134
 
 
135
 
/* Declarations for decompression modules */
136
 
 
137
 
/* Master control module */
138
 
struct jpeg_decomp_master {
139
 
  JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
140
 
  JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
141
 
 
142
 
  /* State variables made visible to other modules */
143
 
  boolean is_dummy_pass;        /* True during 1st pass for 2-pass quant */
144
 
};
145
 
 
146
 
/* Input control module */
147
 
struct jpeg_input_controller {
148
 
  JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
149
 
  JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
150
 
  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
151
 
  JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
152
 
 
153
 
  /* State variables made visible to other modules */
154
 
  boolean has_multiple_scans;   /* True if file has multiple scans */
155
 
  boolean eoi_reached;          /* True when EOI has been consumed */
156
 
};
157
 
 
158
 
/* Main buffer control (downsampled-data buffer) */
159
 
struct jpeg_d_main_controller {
160
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
161
 
  JMETHOD(void, process_data, (j_decompress_ptr cinfo,
162
 
                               JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
163
 
                               JDIMENSION out_rows_avail));
164
 
};
165
 
 
166
 
/* Coefficient buffer control */
167
 
struct jpeg_d_coef_controller {
168
 
  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
169
 
  JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
170
 
  JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
171
 
  JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
172
 
                                 JSAMPIMAGE output_buf));
173
 
  /* Pointer to array of coefficient virtual arrays, or NULL if none */
174
 
  jvirt_barray_ptr *coef_arrays;
175
 
};
176
 
 
177
 
/* Decompression postprocessing (color quantization buffer control) */
178
 
struct jpeg_d_post_controller {
179
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
180
 
  JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
181
 
                                    JSAMPIMAGE input_buf,
182
 
                                    JDIMENSION *in_row_group_ctr,
183
 
                                    JDIMENSION in_row_groups_avail,
184
 
                                    JSAMPARRAY output_buf,
185
 
                                    JDIMENSION *out_row_ctr,
186
 
                                    JDIMENSION out_rows_avail));
187
 
};
188
 
 
189
 
/* Marker reading & parsing */
190
 
struct jpeg_marker_reader {
191
 
  JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
192
 
  /* Read markers until SOS or EOI.
193
 
   * Returns same codes as are defined for jpeg_consume_input:
194
 
   * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
195
 
   */
196
 
  JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
197
 
  /* Read a restart marker --- exported for use by entropy decoder only */
198
 
  jpeg_marker_parser_method read_restart_marker;
199
 
 
200
 
  /* State of marker reader --- nominally internal, but applications
201
 
   * supplying COM or APPn handlers might like to know the state.
202
 
   */
203
 
  boolean saw_SOI;              /* found SOI? */
204
 
  boolean saw_SOF;              /* found SOF? */
205
 
  int next_restart_num;         /* next restart number expected (0-7) */
206
 
  unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */
207
 
};
208
 
 
209
 
/* Entropy decoding */
210
 
struct jpeg_entropy_decoder {
211
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
212
 
  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
213
 
                                JBLOCKROW *MCU_data));
214
 
 
215
 
  /* This is here to share code between baseline and progressive decoders; */
216
 
  /* other modules probably should not use it */
217
 
  boolean insufficient_data;    /* set TRUE after emitting warning */
218
 
};
219
 
 
220
 
/* Inverse DCT (also performs dequantization) */
221
 
typedef JMETHOD(void, inverse_DCT_method_ptr,
222
 
                (j_decompress_ptr cinfo, jpeg_component_info * compptr,
223
 
                 JCOEFPTR coef_block,
224
 
                 JSAMPARRAY output_buf, JDIMENSION output_col));
225
 
 
226
 
struct jpeg_inverse_dct {
227
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
228
 
  /* It is useful to allow each component to have a separate IDCT method. */
229
 
  inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
230
 
};
231
 
 
232
 
/* Upsampling (note that upsampler must also call color converter) */
233
 
struct jpeg_upsampler {
234
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
235
 
  JMETHOD(void, upsample, (j_decompress_ptr cinfo,
236
 
                           JSAMPIMAGE input_buf,
237
 
                           JDIMENSION *in_row_group_ctr,
238
 
                           JDIMENSION in_row_groups_avail,
239
 
                           JSAMPARRAY output_buf,
240
 
                           JDIMENSION *out_row_ctr,
241
 
                           JDIMENSION out_rows_avail));
242
 
 
243
 
  boolean need_context_rows;    /* TRUE if need rows above & below */
244
 
};
245
 
 
246
 
/* Colorspace conversion */
247
 
struct jpeg_color_deconverter {
248
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
249
 
  JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
250
 
                                JSAMPIMAGE input_buf, JDIMENSION input_row,
251
 
                                JSAMPARRAY output_buf, int num_rows));
252
 
};
253
 
 
254
 
/* Color quantization or color precision reduction */
255
 
struct jpeg_color_quantizer {
256
 
  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
257
 
  JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
258
 
                                 JSAMPARRAY input_buf, JSAMPARRAY output_buf,
259
 
                                 int num_rows));
260
 
  JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
261
 
  JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
262
 
};
263
 
 
264
 
 
265
 
/* Miscellaneous useful macros */
266
 
 
267
 
#undef MAX
268
 
#define MAX(a,b)        ((a) > (b) ? (a) : (b))
269
 
#undef MIN
270
 
#define MIN(a,b)        ((a) < (b) ? (a) : (b))
271
 
 
272
 
 
273
 
/* We assume that right shift corresponds to signed division by 2 with
274
 
 * rounding towards minus infinity.  This is correct for typical "arithmetic
275
 
 * shift" instructions that shift in copies of the sign bit.  But some
276
 
 * C compilers implement >> with an unsigned shift.  For these machines you
277
 
 * must define RIGHT_SHIFT_IS_UNSIGNED.
278
 
 * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
279
 
 * It is only applied with constant shift counts.  SHIFT_TEMPS must be
280
 
 * included in the variables of any routine using RIGHT_SHIFT.
281
 
 */
282
 
 
283
 
#ifdef RIGHT_SHIFT_IS_UNSIGNED
284
 
#define SHIFT_TEMPS     INT32 shift_temp;
285
 
#define RIGHT_SHIFT(x,shft)  \
286
 
        ((shift_temp = (x)) < 0 ? \
287
 
         (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
288
 
         (shift_temp >> (shft)))
289
 
#else
290
 
#define SHIFT_TEMPS
291
 
#define RIGHT_SHIFT(x,shft)     ((x) >> (shft))
292
 
#endif
293
 
 
294
 
 
295
 
/* Short forms of external names for systems with brain-damaged linkers. */
296
 
 
297
 
#ifdef NEED_SHORT_EXTERNAL_NAMES
298
 
#define jinit_compress_master   jICompress
299
 
#define jinit_c_master_control  jICMaster
300
 
#define jinit_c_main_controller jICMainC
301
 
#define jinit_c_prep_controller jICPrepC
302
 
#define jinit_c_coef_controller jICCoefC
303
 
#define jinit_color_converter   jICColor
304
 
#define jinit_downsampler       jIDownsampler
305
 
#define jinit_forward_dct       jIFDCT
306
 
#define jinit_huff_encoder      jIHEncoder
307
 
#define jinit_phuff_encoder     jIPHEncoder
308
 
#define jinit_arith_encoder     jIAEncoder
309
 
#define jinit_marker_writer     jIMWriter
310
 
#define jinit_master_decompress jIDMaster
311
 
#define jinit_d_main_controller jIDMainC
312
 
#define jinit_d_coef_controller jIDCoefC
313
 
#define jinit_d_post_controller jIDPostC
314
 
#define jinit_input_controller  jIInCtlr
315
 
#define jinit_marker_reader     jIMReader
316
 
#define jinit_huff_decoder      jIHDecoder
317
 
#define jinit_phuff_decoder     jIPHDecoder
318
 
#define jinit_arith_decoder     jIADecoder
319
 
#define jinit_inverse_dct       jIIDCT
320
 
#define jinit_upsampler         jIUpsampler
321
 
#define jinit_color_deconverter jIDColor
322
 
#define jinit_1pass_quantizer   jI1Quant
323
 
#define jinit_2pass_quantizer   jI2Quant
324
 
#define jinit_merged_upsampler  jIMUpsampler
325
 
#define jinit_memory_mgr        jIMemMgr
326
 
#define jdiv_round_up           jDivRound
327
 
#define jround_up               jRound
328
 
#define jcopy_sample_rows       jCopySamples
329
 
#define jcopy_block_row         jCopyBlocks
330
 
#define jzero_far               jZeroFar
331
 
#define jpeg_zigzag_order       jZIGTable
332
 
#define jpeg_natural_order      jZAGTable
333
 
#define jpeg_aritab             jAriTab
334
 
#endif /* NEED_SHORT_EXTERNAL_NAMES */
335
 
 
336
 
 
337
 
/* Compression module initialization routines */
338
 
EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
339
 
EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
340
 
                                         boolean transcode_only));
341
 
EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
342
 
                                          boolean need_full_buffer));
343
 
EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
344
 
                                          boolean need_full_buffer));
345
 
EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
346
 
                                          boolean need_full_buffer));
347
 
EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
348
 
EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
349
 
EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
350
 
EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
351
 
EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));
352
 
EXTERN(void) jinit_arith_encoder JPP((j_compress_ptr cinfo));
353
 
EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
354
 
/* Decompression module initialization routines */
355
 
EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
356
 
EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
357
 
                                          boolean need_full_buffer));
358
 
EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
359
 
                                          boolean need_full_buffer));
360
 
EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
361
 
                                          boolean need_full_buffer));
362
 
EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
363
 
EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
364
 
EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
365
 
EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
366
 
EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo));
367
 
EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
368
 
EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
369
 
EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
370
 
EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
371
 
EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
372
 
EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
373
 
/* Memory manager initialization */
374
 
EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
375
 
 
376
 
/* Utility routines in jutils.c */
377
 
EXTERN(long) jdiv_round_up JPP((long a, long b));
378
 
EXTERN(long) jround_up JPP((long a, long b));
379
 
EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
380
 
                                    JSAMPARRAY output_array, int dest_row,
381
 
                                    int num_rows, JDIMENSION num_cols));
382
 
EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
383
 
                                  JDIMENSION num_blocks));
384
 
EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
385
 
/* Constant tables in jutils.c */
386
 
#if 0                           /* This table is not actually needed in v6a */
387
 
extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
388
 
#endif
389
 
extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
390
 
 
391
 
/* Arithmetic coding probability estimation tables in jaricom.c */
392
 
extern const INT32 jpeg_aritab[];
393
 
 
394
 
/* Suppress undefined-structure complaints if necessary. */
395
 
 
396
 
#ifdef INCOMPLETE_TYPES_BROKEN
397
 
#ifndef AM_MEMORY_MANAGER       /* only jmemmgr.c defines these */
398
 
struct jvirt_sarray_control { long dummy; };
399
 
struct jvirt_barray_control { long dummy; };
400
 
#endif
401
 
#endif /* INCOMPLETE_TYPES_BROKEN */