root / tags / v1_0_2_Build_908 / libraries / libjni-ecw / include / ECW.h @ 11054
History | View | Annotate | Download (35.7 KB)
1 |
/**********************************************************
|
---|---|
2 |
** Copyright 1998 Earth Resource Mapping Ltd.
|
3 |
** This document contains proprietary source code of
|
4 |
** Earth Resource Mapping Ltd, and can only be used under
|
5 |
** one of the three licenses as described in the
|
6 |
** license.txt file supplied with this distribution.
|
7 |
** See separate license.txt file for license details
|
8 |
** and conditions.
|
9 |
**
|
10 |
** This software is covered by US patent #6,442,298,
|
11 |
** #6,102,897 and #6,633,688. Rights to use these patents
|
12 |
** is included in the license agreements.
|
13 |
**
|
14 |
** FILE: erswave.h
|
15 |
** CREATED: 1998
|
16 |
** AUTHOR: SNS
|
17 |
** PURPOSE: Definitions for Wavelet compressed imagery
|
18 |
** EDITS:
|
19 |
** [01] sns 10sep98 Created file
|
20 |
** [02] sns 12Feb99 Modified from ECW to NCS
|
21 |
** [03] sns 22Mar99 Adding additional encoding techniques
|
22 |
** [04] sns 01Apr99 Updated to use Windows native file IO
|
23 |
** [05] sns 02apr99 Modified to use IEEE4 for decode instead of UINT32
|
24 |
** so can better handle sub-integer errors, and later compress
|
25 |
** non-integer datasets. As the number of multiplies for decompression
|
26 |
** is quite low, going to IEEE4's from INT32's should not impact performance too much
|
27 |
** [06] sns 02Apr99 Updated to use fast floating point conversions on x86 platforms
|
28 |
** [07] sns 03Apr99 Adding RUN_ZERO and HUFFMAN encoding techniques
|
29 |
** [08] sns 06Apr99 Summing TAPs to exactly 1.0
|
30 |
** [09] sns 06Apr99 Adding 11 tap filter for speed of compression
|
31 |
** [10] sns 09Apr99 Added user control of compression block size
|
32 |
** [11] sns 08May99 Added on/off texture noise control flag to region structures
|
33 |
** [12] sns 21May99 Restructuring Compression front-end. Also using _RC_NEAR not _RC_CHOP
|
34 |
** [13] sns 21May99 Restructured QMF struct to prevent mis-aligned fetches
|
35 |
** [14] sns 04Jun99 Added internal random number generator instead of using rand()
|
36 |
** [15] sns 17Jun99 Changes to split Compression logic out to a separate SDK library
|
37 |
** [16] sjc 30Apr00 Merged Mac SDK port
|
38 |
** [17] ddi 14Nov00 Modified erw_decompress_read_region_line_bil() to take NCSEcwReadLineType parameter,
|
39 |
** and moved NCSEcwReadLineType from ncsecw.h
|
40 |
** [18] rar 17-Jan-01 Mac port changes
|
41 |
** [19] rar 18Sep01 Modified erw_decompress_open so that if the Block Table is uncompressed (RAW)
|
42 |
** it is not passed through unpack_data (which just does a memcpy anyway)
|
43 |
** [20] sjc 30Apr03 Added "Low Memory" compression
|
44 |
** [21] jx 12Feb04 nCounter is added to QmfRegionStruct to fix rounding error in erw_decompress_read_region_line_bil().
|
45 |
** [22] jx 17Feb04 changed varibles: current_line, start_line, increment_y and increment_x to IEEE8 to fix rounding error in erw_decompress_read_region_line_bil().
|
46 |
** [23] tfl 05Jul04 Added #define for JPEG2000 file extensions
|
47 |
**
|
48 |
** NOTES
|
49 |
**
|
50 |
** A wavelet compressed file consists of a normal .ERS file,
|
51 |
** containing map projection details and so forth, and the
|
52 |
** ER Mapper Compressed Wavelet (.ECW) file, which contains
|
53 |
** the following structure:
|
54 |
**
|
55 |
** ECW Header format is:
|
56 |
**
|
57 |
** UINT8 ERW_HEADER_ID_TAG 'e'
|
58 |
** UINT8 VERSION NUMBER (1..255)
|
59 |
** UINT8 blocking format (BLOCKING_LEVEL = blocking individual levels)
|
60 |
** UINT8 compress format (COMPRESS_UINT8 = rescale back to 0..255 for each band.
|
61 |
** COMPRESS_YIQ = YIQ encoding of a 3 band RGB file. Number of bands must also = 3)
|
62 |
** UINT8 number of QMF levels (excluding file fake level)
|
63 |
** UINT8 Number of subbands (sidebands). Currently always 4.
|
64 |
** UINT32 X size of the file
|
65 |
** UINT32 Y size of the file
|
66 |
** UINT16 Number of bands of data (must be 1 or more)
|
67 |
** UINT16 quantization scale factor
|
68 |
** UINT16 X block size
|
69 |
** UINT16 Y block size
|
70 |
**
|
71 |
** Then for each level (other than the largest level, being the fake file level), the
|
72 |
** following is written out:
|
73 |
** UINT8 Level number
|
74 |
** UINT32 x_size
|
75 |
** UINT32 y_size
|
76 |
** IEEE4 binsizes for each band in the file (so 1 for greyscale, 3 for RGB or YIQ)
|
77 |
** (note that currently all sidebands for a band have the same binsize)
|
78 |
**
|
79 |
** Next, the block offsets for all blocks, relative to the start of all level blocks (not relative to
|
80 |
** the start of the file), are output. As these can be a large number, they are output
|
81 |
** as a compressed set. A block may contain multiple subbands. We only record the total
|
82 |
** block length, as we always need all subbands.
|
83 |
** Blocks are output to disk in the order of levels, so all level 0 blocks will be on disk
|
84 |
** first, then level 1, and so on. The block offsets are stored in a single array, in
|
85 |
** the same way. Because we want to read and write this array, for all levels, as a single
|
86 |
** operation to/from disk, because we want to optimize compression by writing the entire
|
87 |
** group, only one array for all QMF levels is allocated, and each QMF points into part of
|
88 |
** that single array. The array is attached to the top level (which points to the first
|
89 |
** entries), and is freed at that level.
|
90 |
** NOTE WELL: We need to know the size of each block, which is the different between block X
|
91 |
** and block X+1 offsets. Therefor, we have to write one more block offset than actually present,
|
92 |
** which contains the offset to the end of the file (e.g. the file length). This could also
|
93 |
** be used as a file consistency check. Eitherway, it must be there. So the block offset
|
94 |
** buffers are allocated with +1 for this reason.
|
95 |
**
|
96 |
** The length of the compressed block is written first.
|
97 |
** Blocks are written with the offset to each subband other than the first,
|
98 |
* then the ENCODED DATA for each subband, so the data stream is:
|
99 |
** UINT32 Length of the compressed block
|
100 |
** UINT8 encoding_style
|
101 |
** <compressed stream of UINT64 block_offsets>
|
102 |
**
|
103 |
** Then, the blocks of sideband data are output.
|
104 |
** A block is defined as containing (level : MAX_SIDEBAND ? MAX_SIDEBAND-1) sidebands (e.g. 3 for
|
105 |
** levels greater than zero, and 4 for the level 0).
|
106 |
**
|
107 |
** As noted above, each block contains multiple sidebands. Each sideband is encoded in the
|
108 |
** ENCODED DATA format as follows.
|
109 |
** Blocks are written with the offset to each subband other than the first,
|
110 |
** then the ENCODED DATA for each subband, so the data stream is:
|
111 |
** UINT32 Offset to HL_SUBBAND ONLY OUTPUT IF LEVEL 0 (as there will be a LL SUBBAND output)
|
112 |
** UINT32 Offset to HH_SUBBAND
|
113 |
** Then for each subband (4 for 1st level, 3 for all others):
|
114 |
** UINT8 encoding_style
|
115 |
** <compressed stream of UINT64 block_offsets>
|
116 |
**
|
117 |
** After this, other routines write each compressed QMF level out to file.
|
118 |
********************************************************/
|
119 |
|
120 |
#ifndef ECW_H
|
121 |
#define ECW_H
|
122 |
|
123 |
#include "NCSJPCDefs.h" |
124 |
|
125 |
#ifndef NCSTYPES_H
|
126 |
#include "NCSTypes.h" |
127 |
#endif
|
128 |
|
129 |
#ifdef MACINTOSH
|
130 |
#include <fenv.h> |
131 |
#endif
|
132 |
#include <float.h> |
133 |
#include <stdio.h> |
134 |
|
135 |
|
136 |
#ifndef NCSUTIL_H
|
137 |
#include "NCSUtil.h" |
138 |
#endif
|
139 |
|
140 |
typedef struct { |
141 |
NCS_FILE_HANDLE hFile; |
142 |
void *pClientData;
|
143 |
} ECWFILE; |
144 |
#define NULL_ECWFILE { NCS_NULL_FILE_HANDLE, NULL } |
145 |
|
146 |
#include "NCSECWCompress.h" |
147 |
|
148 |
//#define SAFE_FREE(ptr) if( ptr ) free(ptr);
|
149 |
#define NCS_SAFE_FREE(ptr) if( ptr ) NCSFree(ptr); |
150 |
|
151 |
#ifdef __cplusplus
|
152 |
extern "C" { |
153 |
#endif
|
154 |
|
155 |
|
156 |
// FIXME! Move all range encoding code over to using UINT16/UINT32
|
157 |
#if !defined(MACINTOSH)
|
158 |
typedef UINT16 uint2;
|
159 |
#endif
|
160 |
typedef UINT32 uint4;
|
161 |
#if defined(WIN32)
|
162 |
typedef UINT32 uint;
|
163 |
#endif
|
164 |
|
165 |
#define ERS_WAVELET_DATASET_EXT ".ecw" /* compressed wavelet format file */ |
166 |
#define ERS_JP2_DATASET_EXTS { ".jp2" , ".j2k" , ".j2c" , ".jpc", ".jpx", ".jpf" } /*[23]*/ |
167 |
#define ECW_HEADER_ID_TAG 'e' /* [02] first byte of a compressed file must be this */ |
168 |
|
169 |
// FIXME! Move all code over to using IEEE4 not FLOAT
|
170 |
typedef IEEE4 FLOAT;
|
171 |
|
172 |
|
173 |
|
174 |
/* Maximum amount of RAM to use while copying a file. More is faster */
|
175 |
#ifdef MACINTOSH // MDT 4 Meg is too big for Mac -- use 64K /**[16]**/ |
176 |
|
177 |
#define MAX_FILE_COPY_MEMORY (1024*64) |
178 |
|
179 |
#else /* MACINTOSH */ |
180 |
|
181 |
#define MAX_FILE_COPY_MEMORY (1024*1024) * 4 // [02] 4MB is reasonable |
182 |
|
183 |
#endif /* MACINTOSH */ |
184 |
|
185 |
/* Maximum number of pyramid levels.
|
186 |
** We want enough room for terrabyte sized files
|
187 |
** This doesn't need to be larger than log2(MAX_IMAGE_DIM/FILTER_SIZE).
|
188 |
*/
|
189 |
#define MAX_LEVELS 20 |
190 |
|
191 |
//#define SCALE_FACTOR 1 // [05] was 256, no longer needed
|
192 |
|
193 |
/*
|
194 |
** QMF sideband images are sub-blocked, so that sub-sections of sideband images
|
195 |
** can be retrieved without having to read the entire sideband image.
|
196 |
** So a block will be BLOCK_SIZE_X * BLOCK_SIZE_Y symbols in size.
|
197 |
** The total must be less than or equal to 64K result (to ensure that encoders
|
198 |
** have a fixed maximum to encode). Smaller blocks means faster load time over
|
199 |
** internet (for NCS technology), but more inefficient compression and overhead.
|
200 |
** The best size is 1024(x)x64(y), which is fast, good compression, and small size.
|
201 |
** Note that the compressor can compress an entire file without blocking; this
|
202 |
** is a convenience definition related to decompression of images, it is not
|
203 |
** essential for operation of the compressor.
|
204 |
**
|
205 |
** The X block size is typically greater than the Y block size. This is because
|
206 |
** once a block is found, it is fast to read it, and because increasing Y block
|
207 |
** size increases the amount of memory required to store blocks prior to encoding
|
208 |
** Both numbers must be even numbers.
|
209 |
**
|
210 |
** [07] Note: The ENCODE_RUN_ZERO decoder currently limits block size in X to 2^15
|
211 |
** in size - which should never be a problem as this is a huge value for a single
|
212 |
** block, but is something to be aware of. The RUN_ZERO unpack code is easily enhanced for larger
|
213 |
** block sizes, at a slight expense in performance.
|
214 |
**
|
215 |
** [10] Block size can now be set during compression via command line. This is the default.
|
216 |
*/
|
217 |
|
218 |
|
219 |
|
220 |
//#define MIN_QMF_SIZE 128 // minimum size for the smallest LL
|
221 |
// Made smaller, for fast NCS initial loads
|
222 |
#define MIN_QMF_SIZE 64 // minimum size for the smallest LL |
223 |
|
224 |
|
225 |
/* Use these to set up nr_[x|y]_blocks in the qmf, then use those values */
|
226 |
|
227 |
#define QMF_LEVEL_NR_X_BLOCKS(p_qmf) \
|
228 |
(((p_qmf)->x_size + ((p_qmf)->x_block_size - 1)) / (p_qmf)->x_block_size)
|
229 |
|
230 |
#define QMF_LEVEL_NR_Y_BLOCKS(p_qmf) \
|
231 |
(((p_qmf)->y_size + ((p_qmf)->y_block_size - 1)) / (p_qmf)->y_block_size)
|
232 |
|
233 |
// size of filter tap bank, must be an odd number 3 or greater
|
234 |
// Filters are hardcode as defines, making multiplications later much faster.
|
235 |
// Compiler will detect and optimize symetric numbers
|
236 |
|
237 |
//#define FILTER_SIZE 15 // 15 tap filter banks.
|
238 |
#define FILTER_SIZE 11 // 11 tap filter banks |
239 |
|
240 |
#if FILTER_SIZE == 15 |
241 |
// Lowpass sums to 1.0
|
242 |
#define LO_FILTER_0 (IEEE4) -0.0012475221 |
243 |
#define LO_FILTER_1 (IEEE4) -0.0024950907 |
244 |
#define LO_FILTER_2 (IEEE4) 0.0087309530 |
245 |
#define LO_FILTER_3 (IEEE4) 0.0199579580 |
246 |
#define LO_FILTER_4 (IEEE4) -0.0505290000 |
247 |
#define LO_FILTER_5 (IEEE4) -0.1205509700 |
248 |
#define LO_FILTER_6 (IEEE4) 0.2930455800 |
249 |
#define LO_FILTER_7 (IEEE4) 0.7061761836 // [08] |
250 |
#define LO_FILTER_8 (IEEE4) 0.2930455800 |
251 |
#define LO_FILTER_9 (IEEE4) -0.1205509700 |
252 |
#define LO_FILTER_10 (IEEE4) -0.0505290000 |
253 |
#define LO_FILTER_11 (IEEE4) 0.0199579580 |
254 |
#define LO_FILTER_12 (IEEE4) 0.0087309530 |
255 |
#define LO_FILTER_13 (IEEE4) -0.0024950907 |
256 |
#define LO_FILTER_14 (IEEE4) -0.0012475221 |
257 |
// Highpass sums to 0.0
|
258 |
#define HI_FILTER_0 (IEEE4) 0.0012475221 |
259 |
#define HI_FILTER_1 (IEEE4) -0.0024950907 |
260 |
#define HI_FILTER_2 (IEEE4) -0.0087309530 |
261 |
#define HI_FILTER_3 (IEEE4) 0.0199579580 |
262 |
#define HI_FILTER_4 (IEEE4) 0.0505290000 |
263 |
#define HI_FILTER_5 (IEEE4) -0.1205509700 |
264 |
#define HI_FILTER_6 (IEEE4) -0.2930455800 |
265 |
#define HI_FILTER_7 (IEEE4) 0.7061762272 // [08] |
266 |
#define HI_FILTER_8 (IEEE4) -0.2930455800 |
267 |
#define HI_FILTER_9 (IEEE4) -0.1205509700 |
268 |
#define HI_FILTER_10 (IEEE4) 0.0505290000 |
269 |
#define HI_FILTER_11 (IEEE4) 0.0199579580 |
270 |
#define HI_FILTER_12 (IEEE4) -0.0087309530 |
271 |
#define HI_FILTER_13 (IEEE4) -0.0024950907 |
272 |
#define HI_FILTER_14 (IEEE4) 0.0012475221 |
273 |
#endif
|
274 |
|
275 |
#if FILTER_SIZE == 11 |
276 |
// Lowpass sums to 1.0
|
277 |
#define LO_FILTER_0 (IEEE4) 0.007987761489921101 |
278 |
#define LO_FILTER_1 (IEEE4) 0.02011649866148413 |
279 |
#define LO_FILTER_2 (IEEE4) -0.05015758257647976 |
280 |
#define LO_FILTER_3 (IEEE4) -0.12422330961337678 |
281 |
#define LO_FILTER_4 (IEEE4) 0.29216982108655865 |
282 |
#define LO_FILTER_5 (IEEE4) 0.7082136219037853 |
283 |
#define LO_FILTER_6 (IEEE4) 0.29216982108655865 |
284 |
#define LO_FILTER_7 (IEEE4) -0.12422330961337678 |
285 |
#define LO_FILTER_8 (IEEE4) -0.05015758257647976 |
286 |
#define LO_FILTER_9 (IEEE4) 0.02011649866148413 |
287 |
#define LO_FILTER_10 (IEEE4) 0.007987761489921101 |
288 |
// Highpass sums to 0.0
|
289 |
#define HI_FILTER_0 (IEEE4) -0.007987761489921101 |
290 |
#define HI_FILTER_1 (IEEE4) 0.02011649866148413 |
291 |
#define HI_FILTER_2 (IEEE4) 0.05015758257647976 |
292 |
#define HI_FILTER_3 (IEEE4) -0.12422330961337678 |
293 |
#define HI_FILTER_4 (IEEE4) -0.29216982108655865 |
294 |
#define HI_FILTER_5 (IEEE4) 0.7082136219037853 |
295 |
#define HI_FILTER_6 (IEEE4) -0.29216982108655865 |
296 |
#define HI_FILTER_7 (IEEE4) -0.12422330961337678 |
297 |
#define HI_FILTER_8 (IEEE4) 0.05015758257647976 |
298 |
#define HI_FILTER_9 (IEEE4) 0.02011649866148413 |
299 |
#define HI_FILTER_10 (IEEE4) -0.007987761489921101 |
300 |
#endif
|
301 |
|
302 |
/* The type of the quantized images. Must be SIGNED, and capable of holding values in the range [-MAX_BINS, MAX_BINS] */
|
303 |
typedef INT16 BinIndexType;
|
304 |
|
305 |
/* The type used to represent the binsizes. Should be UNSIGNED. If this is
|
306 |
changed, be sure to change the places where
|
307 |
binsizes are written or read from files. */
|
308 |
typedef UINT16 BinValueType;
|
309 |
|
310 |
typedef UINT8 Byte;
|
311 |
|
312 |
/*
|
313 |
** Number of possible values for a symbol. This must be at least
|
314 |
**(MAX_BINS * 4) (one sign bit, one tag bit)...
|
315 |
*/
|
316 |
#define NUM_SYMBOL_VALUES 65536 |
317 |
#define SIGN_MASK 0x4000 |
318 |
#define RUN_MASK 0x8000 |
319 |
#define MAX_BIN_VALUE 16383 // 0x3fff |
320 |
#define MIN_BIN_VALUE -16383 // Prior to masking |
321 |
#define VALUE_MASK 0x3fff /* without the sign or run bits set */ |
322 |
#define MAX_RUN_LENGTH 0x7fff /* can't be longer than this or would run into mask bits */ |
323 |
|
324 |
/*
|
325 |
** The blocking format used for a file. Currently only one supported -
|
326 |
** block each level.
|
327 |
*/
|
328 |
|
329 |
typedef enum { |
330 |
BLOCKING_LEVEL = 1
|
331 |
} BlockingFormat; |
332 |
|
333 |
/*
|
334 |
** The encoding format for a sideband within a block. More encoding
|
335 |
** standards might be added later.
|
336 |
*/
|
337 |
#ifdef NOTDEF
|
338 |
typedef enum { |
339 |
ENCODE_INVALID = 0, // invalid encoding style |
340 |
ENCODE_RAW = 1, // data is not encoded, and is in a raw format |
341 |
ENCODE_HUFFMAN = 2, // zero's run length encoded, and then huffman encoded |
342 |
ENCODE_RANGE = 3, // range encoding |
343 |
ENCODE_RANGE8 = 4, // 8 bit difference then range encoding |
344 |
ENCODE_ZEROS = 5, // encode the entire block as zero's |
345 |
ENCODE_RUN_ZERO = 6 // Run length encoded as zero's |
346 |
} EncodeFormat; |
347 |
#endif
|
348 |
typedef UINT16 EncodeFormat;
|
349 |
#define ENCODE_INVALID 0 |
350 |
#define ENCODE_RAW 1 |
351 |
#define ENCODE_HUFFMAN 2 |
352 |
#define ENCODE_RANGE 3 |
353 |
#define ENCODE_RANGE8 4 |
354 |
#define ENCODE_ZEROS 5 |
355 |
#define ENCODE_RUN_ZERO 6 |
356 |
|
357 |
#define MAX_SIDEBAND 4 |
358 |
|
359 |
typedef enum { |
360 |
LL_SIDEBAND = 0, // must be in order as used for array offsets |
361 |
LH_SIDEBAND = 1,
|
362 |
HL_SIDEBAND = 2,
|
363 |
HH_SIDEBAND = 3
|
364 |
} Sideband; |
365 |
|
366 |
/*
|
367 |
** Some basic information about a QMF file, pointed to by all levels,
|
368 |
** designed to make life easier for higher level applications.
|
369 |
** NOTE!! NCSECWClient.h has this structure, defined as "NCSFileViewFileInfo".
|
370 |
** Any changes must be kept in synch between the two structures
|
371 |
**
|
372 |
*/
|
373 |
|
374 |
typedef NCSFileViewFileInfo ECWFileInfo;
|
375 |
typedef NCSFileViewFileInfoEx ECWFileInfoEx;
|
376 |
|
377 |
/*
|
378 |
**
|
379 |
** The QmfLevelBandStruct is only allocated for COMPRESSION. Because the bin size is
|
380 |
** needed for decompression, it is pulled out of the band structure (binsize can be
|
381 |
** different for each band) and put into the main level structure. So the bin_size
|
382 |
** is the only multi-band value in the QMF level structure; the rest of the band
|
383 |
** specific information is held here at the band level. This also makes the QMF
|
384 |
** structure much smaller for decompression.
|
385 |
**
|
386 |
** There is a multi-band, compression only, buffer allocated at the QMF level,
|
387 |
** which is a pointer to the p_input_ll_line for all bands. This is so recursion,
|
388 |
** including the top level, is easier to structure.
|
389 |
*/
|
390 |
|
391 |
typedef struct qmf_level_band_struct { |
392 |
//
|
393 |
// These buffers are not allocated for the largest (file level) QMF level
|
394 |
//
|
395 |
IEEE4 *p_p_lo_lines[FILTER_SIZE+1]; // pointer to enough larger input lines for lowpass input |
396 |
IEEE4 *p_p_hi_lines[FILTER_SIZE+1]; // pointet to enough larger input lines for highpass input |
397 |
IEEE4 *p_low_high_block; // the block of memory indexed into by the above. Used for free()
|
398 |
// this is allocated with enough room on the X sides to handle reflection
|
399 |
IEEE4 *p_input_ll_line; // pointer to a single input line needed for this level
|
400 |
|
401 |
// This points to the Y_BLOCK_SIZE buffer of output lines, quantized, stored for
|
402 |
// LL (smallest level 0 only), LH, HL and HH. The index into the block for a given line
|
403 |
// is (for maximum memory access performance):
|
404 |
// (y_line_offset * x_line_size)
|
405 |
/* These are used when p_file_qmf->bLowMemCompress is TRUE [20]*/
|
406 |
UINT32 **p_p_ll_lengths; |
407 |
UINT8 ***p_p_p_ll_segs; |
408 |
UINT32 **p_p_lh_lengths; |
409 |
UINT8 ***p_p_p_lh_segs; |
410 |
UINT32 **p_p_hl_lengths; |
411 |
UINT8 ***p_p_p_hl_segs; |
412 |
UINT32 **p_p_hh_lengths; |
413 |
UINT8 ***p_p_p_hh_segs; |
414 |
/* These are used when p_file_qmf->bLowMemCompress is TRUE (1 line) or FALSE (Y_BLOCK_SIZE lines) [20]*/
|
415 |
INT16 *p_quantized_output_ll_block; // Only allocated for level 0 LL, NULL for all other levels
|
416 |
INT16 *p_quantized_output_lh_block; // LH block
|
417 |
INT16 *p_quantized_output_hl_block; // HL block
|
418 |
INT16 *p_quantized_output_hh_block; // HH block
|
419 |
|
420 |
UINT32 packed_length[MAX_SIDEBAND]; // the packed length for a single set of sidebands for this band
|
421 |
} QmfLevelBandStruct; |
422 |
|
423 |
/*
|
424 |
** One level of a QMF tree
|
425 |
**
|
426 |
** The QMF levels are as follows:
|
427 |
** QMF level (level 0..file_level-1)
|
428 |
** Normal QMF levels. Contain temporary buffers for line processing, and a temporary file
|
429 |
** pointer for writing the compressed sidebands to.
|
430 |
** File level:
|
431 |
** A place-holder level. Contains no buffers, but does contain information about the
|
432 |
** file to be read from.
|
433 |
*/
|
434 |
|
435 |
typedef struct qmf_level_struct { |
436 |
UINT16 level; |
437 |
UINT8 nr_levels; // Number of levels, excluding file level
|
438 |
UINT8 version; // [13] Top-level only: compressed file version
|
439 |
UINT8 nr_sidebands; // [13] Top-level only: set to MAX_SIDEBANDS during write of a file
|
440 |
UINT8 bPAD1; // [13] pad to long-word
|
441 |
UINT16 nr_bands; // [13] number of bands (not subbands) in the file, e.g. 3 for a RGB file
|
442 |
UINT32 x_size, y_size; |
443 |
UINT32 next_output_line; // COMPRESSION ONLY: next output line to construct. Will go from 0 to x_size - 1
|
444 |
UINT32 next_input_line; // COMPRESSION ONLY: next line of input to read. 2 lines read for every output line
|
445 |
struct qmf_level_struct *p_larger_qmf;
|
446 |
struct qmf_level_struct *p_smaller_qmf;
|
447 |
struct qmf_level_struct *p_top_qmf; /* pointer to top (smallest) level QMF */ |
448 |
struct qmf_level_struct *p_file_qmf; /* pointer to the fake (largest) file level QMF */ |
449 |
|
450 |
UINT32 *p_band_bin_size; /* bin size for each band during quantization. Each sideband for a band has same binsize */
|
451 |
UINT16 x_block_size; /* size of a block in X direction */
|
452 |
UINT16 y_block_size; /* size of a block in Y direction */
|
453 |
UINT32 nr_x_blocks; /* number of blocks in the X direction */
|
454 |
UINT32 nr_y_blocks; /* number of blocks in the Y direction */
|
455 |
UINT32 nFirstBlockNumber; /* [02] First block number for this level, 0 for level 0 */
|
456 |
|
457 |
// These values are valid for the top (smallest) level QMF only
|
458 |
BlockingFormat blocking_format; // typically BLOCKING_LEVEL
|
459 |
CompressFormat compress_format; // typically COMPRESS_UINT8 or COMPRESS_YIQ
|
460 |
IEEE4 compression_factor; // a number between 1 and 1000
|
461 |
|
462 |
|
463 |
// These are SHARED entries by all QMFs. They all point to the same data,
|
464 |
// and only the top level QMF allocates and frees these. The p_a_block points
|
465 |
// to a single block (valid compression only);
|
466 |
// all QMF's point to the same block. The p_block_offsets is
|
467 |
// an single array for all levels. It is allocated at p_top_qmf, and freed
|
468 |
// at p_top_qmf only. The other levels point to offsets in the array
|
469 |
// There is +1 block than actually present, to calculate the final block offset.
|
470 |
// These offsets are relative to the start of the first block, not the start of the file
|
471 |
UINT64 first_block_offset; /* offset from the start of the file to the first block */
|
472 |
UINT64 *p_block_offsets; /* offset for each block for this level of the file */
|
473 |
NCS_FILE_HANDLE outfile; /* output file */
|
474 |
UINT32 next_block_offset; /* incremented during writing */
|
475 |
UINT8 *p_a_block; /* pointer to a single block during packing/unpacking */
|
476 |
BOOLEAN bRawBlockTable; /* used to indicated weather the block table was store as
|
477 |
RAW or compressed. Required when freeing the memory
|
478 |
allocated for the Block Table in delete_qmf_levels */ //[19] |
479 |
BOOLEAN bLowMemCompress; /* Use "Low Memory" compression techniques [20]*/
|
480 |
|
481 |
// COMPRESSION ONLY: nr_bands of the following pointers, which point into the
|
482 |
// p_input_ll_line offset at [FILTERSIZE/2] for this QMF. Used for recursive calls.
|
483 |
IEEE4 **p_p_input_ll_line; // pointer to nr_bands, a single input line needed for this level
|
484 |
//
|
485 |
// These buffers are not allocated for the largest (file level) QMF level
|
486 |
// These are also ONLY allocated for compression, not for decompression. There is one
|
487 |
// per band being compressed
|
488 |
QmfLevelBandStruct *p_bands; |
489 |
INT16 next_output_block_y_line; // a number going from 0 to Y_BLOCK_SIZE-1
|
490 |
// The place to write the compressed sidebands for this level to. Each level has MAX_SIDEBAND files
|
491 |
// We don't encode the LL sideband image, so the [LL_SIDEBAND] item is normally unused except for debug
|
492 |
char *tmp_fname; // temporary file to write this level's blocks, so we can set up block order |
493 |
NCS_FILE_HANDLE tmp_file; // file pointer to the above block image disk file
|
494 |
|
495 |
// if we are doing transmission encoding instead of blocked encoding
|
496 |
IEEE4 scale_factor; // scale factor, for decompression only
|
497 |
UINT64 file_offset; // offset to start of this level in the file
|
498 |
|
499 |
// [02] Addition information for NCS usage. Valid for the TopQmf (smallest level) only
|
500 |
UINT8 *pHeaderMemImage; // Pointer to in memory copy of header if not NULL
|
501 |
UINT32 nHeaderMemImageLen; // Length of the above in memory header structure
|
502 |
|
503 |
ECWFILE hEcwFile; // input ECW, TopQmf level only, for decompression only
|
504 |
BOOLEAN bEcwFileOpen; // TRUE if above file handle is valid (open), otherwise FALSE
|
505 |
|
506 |
ECWFileInfoEx *pFileInfo; // Valid at top level only
|
507 |
|
508 |
// Compression specific information
|
509 |
struct EcwCompressionTask *pCompressionTask; // [15] |
510 |
} QmfLevelStruct; |
511 |
|
512 |
//
|
513 |
// Region to decode/decompress within a compressed file for a given line.
|
514 |
//
|
515 |
//
|
516 |
// For a region, we keep local line buffers for each level within the region's depth. There
|
517 |
// may be less of these than QMF's, if we are extracting a reduced resolution view of the data.
|
518 |
//
|
519 |
// The upsampling logic results in 4x4 output values from 2x2 input values, so we keep
|
520 |
// line 0 and line 1 of each level's LL. During processing, line 1 is rolled
|
521 |
// to line 1, and line 1 is requested from the smaller level recursively.
|
522 |
//
|
523 |
// Note that LH, HL and HH are loaded from the compressed file, LL is regenerated recursively
|
524 |
// from smaller levels.
|
525 |
//
|
526 |
// the line0 and line1 are +1 larger in X than required by this level; this handles
|
527 |
// different level sizes correctly. For example, we might expand expand a 11x12
|
528 |
// image up to a 22 x 23 image.
|
529 |
|
530 |
// The following returns an index into the line buffer, for the indicated
|
531 |
// band number (0..p_qmf->nr_bands), sideband (LL_SIDEBAND..HH_SIDEBAND) and line (0 or 1)
|
532 |
//
|
533 |
// NOTE WELL!! The "used_bands" is the value used for all band loops during decompression.
|
534 |
// This is so that (later) we can set up the decompress logic to uncompress only some bands.
|
535 |
// Only the unpack() routines will need to be modified for this to work. For now, though,
|
536 |
// we have to unpack all bands.
|
537 |
|
538 |
// Used to compute initial indexes for pointers
|
539 |
#define DECOMP_LEVEL_LINE01(p_level, band, sideband, line) \
|
540 |
((p_level)->buffer_ptr + (((2 * (band * MAX_SIDEBAND + sideband)) + (line)) * ((p_level)->level_size_x+2))) |
541 |
// Used to compute index for a given band and subband
|
542 |
#define DECOMP_INDEX \
|
543 |
(band * MAX_SIDEBAND + sideband) |
544 |
|
545 |
typedef struct { |
546 |
UINT32 used_bands; |
547 |
IEEE4 **p_p_line0; // [05] this level's LL, LH, HL and HH for line N+0. Must be signed
|
548 |
IEEE4 **p_p_line1; // [05] this level's LL, LH, HL and HH for line N+1. Must be signed
|
549 |
IEEE4 **p_p_line1_ll_sideband;// [05] This level's LL sideband with x_reflection for line 1, all bands
|
550 |
|
551 |
UINT32 start_read_lines; // [11] starting read_lines state for ResetView()
|
552 |
UINT32 read_lines; // # of lines of above level to read. Starts as 2, then will be 0 or 1
|
553 |
// The following is the next line of this level to read.
|
554 |
// So a level with sidebands of 32x32 could have this number range from 0..31,
|
555 |
// as this level would be called up to 64 times to generate the 0..64 lines for the larger level
|
556 |
// In other words, this is from 0 .. (# lines-1) in the side bands for this level.
|
557 |
UINT32 current_line; // line currently being read at this level
|
558 |
UINT32 start_line; // [11] starting line for ResetView()
|
559 |
// this is the next block line to read (can be from 0..y_block_size). Only valid if have_blocks = TRUE
|
560 |
INT16 next_input_block_y_line;// a number going from 0 to Y_BLOCK_SIZE-1
|
561 |
UINT8 have_blocks; // true if the next Y block number is valid
|
562 |
UINT32 start_x_block; // first X block, from 0..p_pqm->x_size/p_qmf->x_block_size
|
563 |
UINT32 x_block_count; // count of X blocks across
|
564 |
|
565 |
void *p_x_blocks; // pointer to a set of decompressions in progress for a set of X blocks |
566 |
UINT32 first_block_skip; // how many symbols to skip at start of line in the first block in the set of X blocks
|
567 |
UINT32 last_block_skip; // how many symbols to skip at end of line in the last block in the X set
|
568 |
|
569 |
QmfLevelStruct *p_qmf; // handy pointer to the QMF for this level
|
570 |
struct qmf_region_struct *p_region; // handy pointer to the region that contains these levels |
571 |
// the reflection amounts. Need to add these to start/end/size to get true size
|
572 |
// Always 0 or 1, so can be shorter byte values
|
573 |
UINT8 reflect_start_x, reflect_end_x; |
574 |
UINT8 reflect_start_y, reflect_end_y; |
575 |
// NOTE WELL: These start/end/size values EXCLUDE the reflection values
|
576 |
UINT32 level_start_y, level_end_y, level_size_y; |
577 |
UINT32 level_start_x, level_end_x, level_size_x; |
578 |
UINT32 output_level_start_y, output_level_end_y, output_level_size_y; |
579 |
UINT32 output_level_start_x, output_level_end_x, output_level_size_x; |
580 |
|
581 |
IEEE4 *buffer_ptr; // [05] Band/sideband/line[01] buffer.
|
582 |
// for speed we allocate a single buffer, and point into it.
|
583 |
// So a single malloc/free per level
|
584 |
} QmfRegionLevelStruct; |
585 |
|
586 |
// One of these is created for each start_region()/end_region() call pair
|
587 |
typedef struct qmf_region_struct { |
588 |
QmfLevelStruct *p_top_qmf; // pointer to the smallest level in the QMF
|
589 |
QmfLevelStruct *p_largest_qmf; // pointer to the largest level we have to read for this region resolution
|
590 |
// region location and size to read
|
591 |
UINT32 start_x, start_y; |
592 |
UINT32 end_x, end_y; |
593 |
UINT32 number_x, number_y; |
594 |
|
595 |
UINT32 random_value; // [14] random value for texture generation
|
596 |
// floating point versions of current line and incrememtn. This is because
|
597 |
// we read power of 2 lines, but need to feed non-power of two lines to caller
|
598 |
UINT32 read_line; // non-zero if have to read line(s), 0 if not (duplicating line)
|
599 |
//[22]
|
600 |
IEEE8 current_line; // the current output line being worked on
|
601 |
IEEE8 start_line; // [11] starting line for ResetView()
|
602 |
IEEE8 increment_y; // the increment of input lines to add for each output line. Will be <= 1.0
|
603 |
IEEE8 increment_x; // the increment of input pixels to add for each output pixel. Will be <= 1.0
|
604 |
// recursive information. This array is p_largest_level->level+1 in size
|
605 |
// The in_line[0|1] points are set up for the size of each level, so increase in size for each level
|
606 |
QmfRegionLevelStruct *p_levels; |
607 |
IEEE4 **p_p_ll_line; // [05] the power of two size, INT32 format, output line. Must be signed
|
608 |
IEEE4 *p_ll_buffer; // [05] the buffer that the above indexes into
|
609 |
UINT32 used_bands; // bands actually read - may be different from p_qmf->nr_bands in future versions
|
610 |
// The band_list is allocated and freed by the caller. We do NOT allocate or free it
|
611 |
UINT32 nr_bands_requested; // the number of bands requested from caller; may be differed to used_bands
|
612 |
UINT32 *band_list; // array of used_bands, indicating actual band numbers to use
|
613 |
struct NCSFileViewStruct *pNCSFileView; // [02] pointer to the NCS File View for this QMF Region |
614 |
BOOLEAN bAddTextureNoise; // [11] TRUE if add texture noise during decompression
|
615 |
UINT32 nCounter; // [21] to fix rounding error in erw_decompress_read_region_line_bil()
|
616 |
} QmfRegionStruct; |
617 |
|
618 |
|
619 |
/*
|
620 |
** QMF tree management functions
|
621 |
*/
|
622 |
|
623 |
// QMF tree management routines used by both build/extract
|
624 |
|
625 |
#ifdef ECW_COMPRESS // [15] |
626 |
extern NCSError setup_qmf_tree(QmfLevelStruct **pp_qmf, struct EcwCompressionTask *pCompressionTask, |
627 |
UINT32 nBlockSizeX, UINT32 nBlockSizeY, |
628 |
UINT16 *num_levels, UINT32 x_size, UINT32 y_size, UINT32 nr_bands, |
629 |
UINT32 nInputBands, CompressHint eCompressHint, |
630 |
IEEE4 compression_factor, CompressFormat compress_format, int compress );
|
631 |
#endif
|
632 |
|
633 |
extern void delete_qmf_levels(QmfLevelStruct *p_qmf); |
634 |
extern UINT32 get_qmf_tree_nr_blocks( QmfLevelStruct *p_top_level );
|
635 |
|
636 |
QmfLevelStruct *new_qmf_level(UINT32 nBlockSizeX, UINT32 nBlockSizeY, |
637 |
UINT16 level, UINT32 x_size, UINT32 y_size, UINT32 nr_bands, |
638 |
QmfLevelStruct *p_smaller_qmf, QmfLevelStruct *p_larger_qmf, int compress);
|
639 |
|
640 |
NCSError allocate_qmf_buffers(QmfLevelStruct *p_top_qmf, int compress);
|
641 |
|
642 |
|
643 |
|
644 |
// Data unpack routines
|
645 |
|
646 |
#if defined( MACINTOSH ) && TARGET_API_MAC_OS8
|
647 |
extern int unpack_ecw_block(QmfLevelStruct *pQmfLevel, UINT32 nBlockX, UINT32 nBlockY, |
648 |
Handle *ppUnpackedECWBlock, UINT32 *pUnpackedLength, |
649 |
UINT8 *pPackedBlock); |
650 |
int align_ecw_block(NCSFile *pFile, NCSBlockId nBlockID,
|
651 |
Handle *ppAlignedECWBlock, UINT32 *pAlignedLength, |
652 |
UINT8 *pPackedBlock, UINT32 nPackedLength); |
653 |
#else
|
654 |
extern int unpack_ecw_block(QmfLevelStruct *pQmfLevel, UINT32 nBlockX, UINT32 nBlockY, |
655 |
UINT8 **ppUnpackedECWBlock, UINT32 *pUnpackedLength, |
656 |
UINT8 *pPackedECWBlock); |
657 |
int align_ecw_block(NCSFile *pFile, NCSBlockId nBlockID,
|
658 |
UINT8 **ppAlignedECWBlock, UINT32 *pAlignedLength, |
659 |
UINT8 *pPackedBlock, UINT32 nPackedLength); |
660 |
#endif //MACINTOSH |
661 |
|
662 |
extern int unpack_data(UINT8 **p_raw, |
663 |
UINT8 *p_packed, UINT32 raw_length, |
664 |
UINT8 nSizeOfEncodeFormat); |
665 |
|
666 |
|
667 |
int unpack_init_lines( QmfRegionLevelStruct *p_level );
|
668 |
|
669 |
int unpack_start_line_block( QmfRegionLevelStruct *p_level, UINT32 x_block,
|
670 |
UINT8 *p_packed_block, UINT32 lines_to_skip); |
671 |
|
672 |
int unpack_line( QmfRegionLevelStruct *p_level );
|
673 |
|
674 |
void unpack_finish_lines( QmfRegionLevelStruct *p_level );
|
675 |
|
676 |
void unpack_free_lines( QmfRegionLevelStruct *p_level );
|
677 |
|
678 |
/*
|
679 |
** Encoder functions
|
680 |
*/
|
681 |
|
682 |
#ifdef ECW_COMPRESS
|
683 |
|
684 |
extern NCSError build_qmf_compress_file(QmfLevelStruct *p_top_qmf, NCS_FILE_HANDLE outfile);
|
685 |
|
686 |
extern NCSError build_qmf_level_qencode_line(QmfLevelStruct *p_qmf, UINT32 y, IEEE4 **p_p_ll_line);
|
687 |
|
688 |
extern NCSError qencode_qmf(QmfLevelStruct *p_top_qmf, int num_levels, |
689 |
FLOAT compression_factor, NCS_FILE_HANDLE outfile); |
690 |
|
691 |
extern NCSError pack_data(QmfLevelStruct *p_top_qmf,
|
692 |
UINT8 **p_packed, UINT32 *packed_length, |
693 |
UINT8 *p_raw, UINT32 raw_length, UINT8 symbol_size_hint, BOOLEAN bTryHuffman); |
694 |
|
695 |
|
696 |
/*
|
697 |
** File IO functions
|
698 |
*/
|
699 |
|
700 |
// writes the preamble header in the compressed ERW file
|
701 |
NCSError write_compressed_preamble(QmfLevelStruct *p_top_qmf, NCS_FILE_HANDLE outfile); |
702 |
// convert the block table to LSB offsets
|
703 |
NCSError convert_block_table(QmfLevelStruct *p_top_qmf, NCS_FILE_HANDLE outfile); |
704 |
// writes the level to the compressed ERW file
|
705 |
NCSError write_compressed_level(QmfLevelStruct *p_qmf, NCS_FILE_HANDLE outfile); |
706 |
|
707 |
#endif /* ECW_COMPRESS */ |
708 |
|
709 |
/*
|
710 |
** Decoder functions
|
711 |
*/
|
712 |
|
713 |
// Visible functions that can be called
|
714 |
|
715 |
extern QmfLevelStruct *erw_decompress_open(
|
716 |
char *p_input_filename, // File to open |
717 |
UINT8 *pMemImage, // if non-NULL, open the memory image not the file
|
718 |
BOOLEAN bReadOffsets, // TRUE if the client wants the block Offset Table
|
719 |
BOOLEAN bReadMemImage ); // TRUE if the client wants a Memory Image of the Header
|
720 |
|
721 |
|
722 |
extern QmfRegionStruct *erw_decompress_start_region( QmfLevelStruct *p_top_qmf,
|
723 |
UINT32 nr_bands_requested, // number of bands to read
|
724 |
UINT32 *p_band_list, // list of bands to be read. Caller allocs/frees this
|
725 |
UINT32 start_x, UINT32 start_y, |
726 |
UINT32 end_x, UINT32 end_y, |
727 |
UINT32 number_x, UINT32 number_y); |
728 |
|
729 |
typedef enum { /**[17]**/ |
730 |
NCSECW_READLINE_INVALID = 0, // invalid type /**[17]**/ |
731 |
NCSECW_READLINE_RGB = 1, // RGB Triplet /**[17]**/ |
732 |
NCSECW_READLINE_BGR = 2, // BGR Triplet /**[17]**/ |
733 |
NCSECW_READLINE_RGBA = 3, // RGBA 32-bit /**[17]**/ |
734 |
NCSECW_READLINE_BGRA = 4, // BGRA 32-bit /**[17]**/ |
735 |
NCSECW_READLINE_IEEE4 = 5, // single band float /**[17]**/ |
736 |
NCSECW_READLINE_UINT8 = 6, // single band unsigned 8bit /**[17]**/ |
737 |
NCSECW_READLINE_UINT16 = 7 // single band unsigned 16bit /**[17]**/ |
738 |
} NCSEcwReadLineType; /**[17]**/
|
739 |
|
740 |
int erw_decompress_read_region_line_bil ( QmfRegionStruct *p_region, UINT8 **p_p_output_line, NCSEcwReadLineType nOutputType); // [17] |
741 |
int erw_decompress_read_region_line_rgb ( QmfRegionStruct *p_region, UINT8 *pRGBTriplets);
|
742 |
int erw_decompress_read_region_line_bgr ( QmfRegionStruct *p_region, UINT8 *pRGBTriplets);
|
743 |
int erw_decompress_read_region_line_rgba( QmfRegionStruct *p_region, UINT32 *pRGBAPixels);
|
744 |
int erw_decompress_read_region_line_bgra( QmfRegionStruct *p_region, UINT32 *pBGRAPixels);
|
745 |
|
746 |
|
747 |
void erw_decompress_end_region( QmfRegionStruct *p_region );
|
748 |
extern void erw_decompress_close( QmfLevelStruct *p_top_qmf ); |
749 |
|
750 |
// handy argument parsing for stand alone program
|
751 |
extern int setup_decompress(int argc, char *argv[], |
752 |
char **p_p_input_erw_filename,
|
753 |
char **p_p_output_bil_filename);
|
754 |
|
755 |
// Internal functions. Do not call these
|
756 |
|
757 |
extern int qdecode_qmf_level_line( QmfRegionStruct *p_region, UINT16 level, UINT32 y_line, |
758 |
IEEE4 **p_p_output_line); |
759 |
|
760 |
/*
|
761 |
** GUI functions (gui_io.c)
|
762 |
*/
|
763 |
void gui_percent( UINT32 percent );
|
764 |
int gui_cancel( void ); |
765 |
void gui_msg_ok( char *msg, char *title ); |
766 |
|
767 |
|
768 |
/*
|
769 |
** ECW Header File IO routines
|
770 |
** Use these only for small numbers of header bytes, as they are quite slow
|
771 |
*/
|
772 |
|
773 |
#ifdef ECW_COMPRESS // [02] only compression needs the ermapper.lib library |
774 |
int write_int8(UINT8 value, FILE *stream);
|
775 |
int write_int16(UINT16 value, FILE *stream);
|
776 |
int write_int32(UINT32 value, FILE *stream);
|
777 |
int write_int64(UINT64 value, FILE *stream);
|
778 |
int write_ieee4(IEEE4 value, FILE *stream);
|
779 |
#endif
|
780 |
/*
|
781 |
** ECW File reading Abstraction Routines
|
782 |
** These are non-ER Mapper specific (as ECW gets linked stand alone),
|
783 |
** and CAN NOT use fopen() to due # of file limitations on platforms like Windows
|
784 |
*/
|
785 |
|
786 |
/*
|
787 |
** The Unix vs WIN32 calls are so different, we wrap the reads with functions,
|
788 |
** that return FALSE if all went well, and TRUE if there was an error.
|
789 |
** Note that the ECWFILE *can* be NULL (windows madness), so you will have to
|
790 |
** keep a separate variable to decide if the file is open or not.
|
791 |
*/
|
792 |
BOOLEAN EcwFileOpenForRead(char *szFilename, ECWFILE *pFile); // Opens file for binary reading |
793 |
BOOLEAN EcwFileClose(ECWFILE hFile); // Closes file
|
794 |
BOOLEAN EcwFileRead(ECWFILE hFile, void *pBuffer, UINT32 nLength); // reads nLength bytes into existing pBuffer |
795 |
BOOLEAN EcwFileSetPos(ECWFILE hFile, UINT64 nOffset); // Seeks to specified location in file
|
796 |
BOOLEAN EcwFileGetPos(ECWFILE hFile, UINT64 *pOffset); // Returns current file position
|
797 |
BOOLEAN EcwFileReadUint8(ECWFILE hFile, UINT8 *sym); |
798 |
BOOLEAN EcwFileReadUint16(ECWFILE hFile, UINT16 *sym16); |
799 |
BOOLEAN EcwFileReadUint32(ECWFILE hFile, UINT32 *sym32); |
800 |
BOOLEAN EcwFileReadUint64(ECWFILE hFile, UINT64 *sym); |
801 |
BOOLEAN EcwFileReadIeee8(ECWFILE hFile, IEEE8 *fvalue); |
802 |
BOOLEAN EcwFileReadIeee4(ECWFILE hFile, IEEE4 *fsym32); |
803 |
void sread_ieee8(IEEE8 *sym, UINT8 *p_s);
|
804 |
|
805 |
|
806 |
UINT32 sread_int32(UINT8 *p_s); |
807 |
UINT16 sread_int16(UINT8 *p_s); |
808 |
|
809 |
/*
|
810 |
** Memory functions
|
811 |
*/
|
812 |
|
813 |
extern char *check_malloc (int size); |
814 |
extern void check_free (char *ptr); |
815 |
extern FILE *check_fopen (char *filename, char *read_write_flag); |
816 |
char *concatenate(char *string1, char *string2); |
817 |
|
818 |
// For MAC Port --
|
819 |
|
820 |
#ifdef MACINTOSH
|
821 |
extern void *vmalloc( size_t cb ); |
822 |
extern void *vcalloc( size_t c, size_t cb ); |
823 |
#else
|
824 |
#define vmalloc(p) malloc(p)
|
825 |
#define vcalloc(p,q) calloc(p,q)
|
826 |
#endif
|
827 |
|
828 |
#ifdef __cplusplus
|
829 |
} |
830 |
#endif
|
831 |
|
832 |
#endif // ECW_H |