|
1 /* ************************************************************************** */ |
|
2 /* * For conditions of distribution and use, * */ |
|
3 /* * see copyright notice in libmng.h * */ |
|
4 /* ************************************************************************** */ |
|
5 /* * * */ |
|
6 /* * project : libmng * */ |
|
7 /* * file : libmng_chunk_descr.c copyright (c) 2005-2007 G.Juyn * */ |
|
8 /* * version : 1.0.10 * */ |
|
9 /* * * */ |
|
10 /* * purpose : Chunk descriptor functions (implementation) * */ |
|
11 /* * * */ |
|
12 /* * author : G.Juyn * */ |
|
13 /* * * */ |
|
14 /* * comment : implementation of the chunk- anf field-descriptor * */ |
|
15 /* * routines * */ |
|
16 /* * * */ |
|
17 /* * changes : 1.0.9 - 12/06/2004 - G.Juyn * */ |
|
18 /* * - added conditional MNG_OPTIMIZE_CHUNKREADER * */ |
|
19 /* * 1.0.9 - 12/11/2004 - G.Juyn * */ |
|
20 /* * - made all constants 'static' * */ |
|
21 /* * 1.0.9 - 12/20/2004 - G.Juyn * */ |
|
22 /* * - cleaned up macro-invocations (thanks to D. Airlie) * */ |
|
23 /* * 1.0.9 - 01/17/2005 - G.Juyn * */ |
|
24 /* * - fixed problem with global PLTE/tRNS * */ |
|
25 /* * * */ |
|
26 /* * 1.0.10 - 01/17/2005 - G.R-P. * */ |
|
27 /* * - added typecast to appease the compiler * */ |
|
28 /* * 1.0.10 - 04/08/2007 - G.Juyn * */ |
|
29 /* * - added support for mPNG proposal * */ |
|
30 /* * 1.0.10 - 04/12/2007 - G.Juyn * */ |
|
31 /* * - added support for ANG proposal * */ |
|
32 /* * * */ |
|
33 /* ************************************************************************** */ |
|
34 |
|
35 #include <stddef.h> /* needed for offsetof() */ |
|
36 |
|
37 #include "libmng.h" |
|
38 #include "libmng_data.h" |
|
39 #include "libmng_error.h" |
|
40 #include "libmng_trace.h" |
|
41 #ifdef __BORLANDC__ |
|
42 #pragma hdrstop |
|
43 #endif |
|
44 #include "libmng_memory.h" |
|
45 #include "libmng_objects.h" |
|
46 #include "libmng_chunks.h" |
|
47 #include "libmng_chunk_descr.h" |
|
48 #include "libmng_object_prc.h" |
|
49 #include "libmng_chunk_prc.h" |
|
50 #include "libmng_chunk_io.h" |
|
51 #include "libmng_display.h" |
|
52 |
|
53 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
54 #include "libmng_pixels.h" |
|
55 #include "libmng_filter.h" |
|
56 #endif |
|
57 |
|
58 #if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI) |
|
59 #pragma option -A /* force ANSI-C */ |
|
60 #endif |
|
61 |
|
62 /* ************************************************************************** */ |
|
63 |
|
64 #ifdef MNG_OPTIMIZE_CHUNKREADER |
|
65 #if defined(MNG_INCLUDE_READ_PROCS) || defined(MNG_INCLUDE_WRITE_PROCS) |
|
66 |
|
67 /* ************************************************************************** */ |
|
68 /* ************************************************************************** */ |
|
69 /* PNG chunks */ |
|
70 |
|
71 MNG_LOCAL mng_field_descriptor mng_fields_ihdr [] = |
|
72 { |
|
73 {MNG_NULL, |
|
74 MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT, |
|
75 1, 0, 4, 4, |
|
76 offsetof(mng_ihdr, iWidth), MNG_NULL, MNG_NULL}, |
|
77 {MNG_NULL, |
|
78 MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT, |
|
79 1, 0, 4, 4, |
|
80 offsetof(mng_ihdr, iHeight), MNG_NULL, MNG_NULL}, |
|
81 {MNG_NULL, |
|
82 MNG_FIELD_INT, |
|
83 1, 16, 1, 1, |
|
84 offsetof(mng_ihdr, iBitdepth), MNG_NULL, MNG_NULL}, |
|
85 {MNG_NULL, |
|
86 MNG_FIELD_INT, |
|
87 0, 6, 1, 1, |
|
88 offsetof(mng_ihdr, iColortype), MNG_NULL, MNG_NULL}, |
|
89 {MNG_NULL, |
|
90 MNG_FIELD_INT, |
|
91 0, 0, 1, 1, |
|
92 offsetof(mng_ihdr, iCompression), MNG_NULL, MNG_NULL}, |
|
93 {MNG_NULL, |
|
94 MNG_FIELD_INT, |
|
95 0, 0, 1, 1, |
|
96 offsetof(mng_ihdr, iFilter), MNG_NULL, MNG_NULL}, |
|
97 {MNG_NULL, |
|
98 MNG_FIELD_INT, |
|
99 0, 1, 1, 1, |
|
100 offsetof(mng_ihdr, iInterlace), MNG_NULL, MNG_NULL} |
|
101 }; |
|
102 |
|
103 /* ************************************************************************** */ |
|
104 |
|
105 MNG_LOCAL mng_field_descriptor mng_fields_plte [] = |
|
106 { |
|
107 {mng_debunk_plte, |
|
108 MNG_NULL, |
|
109 0, 0, 0, 0, |
|
110 MNG_NULL, MNG_NULL, MNG_NULL} |
|
111 }; |
|
112 |
|
113 /* ************************************************************************** */ |
|
114 |
|
115 MNG_LOCAL mng_field_descriptor mng_fields_idat [] = |
|
116 { |
|
117 {MNG_NULL, |
|
118 MNG_NULL, |
|
119 0, 0, 0, 0, |
|
120 offsetof(mng_idat, pData), MNG_NULL, offsetof(mng_idat, iDatasize)} |
|
121 }; |
|
122 |
|
123 /* ************************************************************************** */ |
|
124 |
|
125 MNG_LOCAL mng_field_descriptor mng_fields_trns [] = |
|
126 { |
|
127 {mng_debunk_trns, |
|
128 MNG_NULL, |
|
129 0, 0, 0, 0, |
|
130 MNG_NULL, MNG_NULL, MNG_NULL} |
|
131 }; |
|
132 |
|
133 /* ************************************************************************** */ |
|
134 |
|
135 #ifndef MNG_SKIPCHUNK_gAMA |
|
136 MNG_LOCAL mng_field_descriptor mng_fields_gama [] = |
|
137 { |
|
138 {MNG_NULL, |
|
139 MNG_FIELD_INT, |
|
140 0, 0, 4, 4, |
|
141 offsetof(mng_gama, iGamma), MNG_NULL, MNG_NULL} |
|
142 }; |
|
143 #endif |
|
144 |
|
145 /* ************************************************************************** */ |
|
146 |
|
147 #ifndef MNG_SKIPCHUNK_cHRM |
|
148 MNG_LOCAL mng_field_descriptor mng_fields_chrm [] = |
|
149 { |
|
150 {MNG_NULL, |
|
151 MNG_FIELD_INT, |
|
152 0, 0, 4, 4, |
|
153 offsetof(mng_chrm, iWhitepointx), MNG_NULL, MNG_NULL}, |
|
154 {MNG_NULL, |
|
155 MNG_FIELD_INT, |
|
156 0, 0, 4, 4, |
|
157 offsetof(mng_chrm, iWhitepointy), MNG_NULL, MNG_NULL}, |
|
158 {MNG_NULL, |
|
159 MNG_FIELD_INT, |
|
160 0, 0, 4, 4, |
|
161 offsetof(mng_chrm, iRedx), MNG_NULL, MNG_NULL}, |
|
162 {MNG_NULL, |
|
163 MNG_FIELD_INT, |
|
164 0, 0, 4, 4, |
|
165 offsetof(mng_chrm, iRedy), MNG_NULL, MNG_NULL}, |
|
166 {MNG_NULL, |
|
167 MNG_FIELD_INT, |
|
168 0, 0, 4, 4, |
|
169 offsetof(mng_chrm, iGreeny), MNG_NULL, MNG_NULL}, |
|
170 {MNG_NULL, |
|
171 MNG_FIELD_INT, |
|
172 0, 0, 4, 4, |
|
173 offsetof(mng_chrm, iGreeny), MNG_NULL, MNG_NULL}, |
|
174 {MNG_NULL, |
|
175 MNG_FIELD_INT, |
|
176 0, 0, 4, 4, |
|
177 offsetof(mng_chrm, iBluex), MNG_NULL, MNG_NULL}, |
|
178 {MNG_NULL, |
|
179 MNG_FIELD_INT, |
|
180 0, 0, 4, 4, |
|
181 offsetof(mng_chrm, iBluey), MNG_NULL, MNG_NULL} |
|
182 }; |
|
183 #endif |
|
184 |
|
185 /* ************************************************************************** */ |
|
186 |
|
187 #ifndef MNG_SKIPCHUNK_sRGB |
|
188 MNG_LOCAL mng_field_descriptor mng_fields_srgb [] = |
|
189 { |
|
190 {MNG_NULL, |
|
191 MNG_FIELD_INT, |
|
192 0, 4, 1, 1, |
|
193 offsetof(mng_srgb, iRenderingintent), MNG_NULL, MNG_NULL} |
|
194 }; |
|
195 #endif |
|
196 |
|
197 /* ************************************************************************** */ |
|
198 |
|
199 #ifndef MNG_SKIPCHUNK_iCCP |
|
200 MNG_LOCAL mng_field_descriptor mng_fields_iccp [] = |
|
201 { |
|
202 {MNG_NULL, |
|
203 MNG_FIELD_TERMINATOR, |
|
204 0, 0, 1, 79, |
|
205 offsetof(mng_iccp, zName), MNG_NULL, offsetof(mng_iccp, iNamesize)}, |
|
206 {MNG_NULL, |
|
207 MNG_FIELD_INT, |
|
208 0, 0, 1, 1, |
|
209 offsetof(mng_iccp, iCompression), MNG_NULL, MNG_NULL}, |
|
210 {MNG_NULL, |
|
211 MNG_FIELD_DEFLATED, |
|
212 0, 0, 0, 0, |
|
213 offsetof(mng_iccp, pProfile), MNG_NULL, offsetof(mng_iccp, iProfilesize)} |
|
214 }; |
|
215 #endif |
|
216 |
|
217 /* ************************************************************************** */ |
|
218 |
|
219 #ifndef MNG_SKIPCHUNK_tEXt |
|
220 MNG_LOCAL mng_field_descriptor mng_fields_text [] = |
|
221 { |
|
222 {MNG_NULL, |
|
223 MNG_FIELD_TERMINATOR, |
|
224 0, 0, 1, 79, |
|
225 offsetof(mng_text, zKeyword), MNG_NULL, offsetof(mng_text, iKeywordsize)}, |
|
226 {MNG_NULL, |
|
227 MNG_NULL, |
|
228 0, 0, 0, 0, |
|
229 offsetof(mng_text, zText), MNG_NULL, offsetof(mng_text, iTextsize)} |
|
230 }; |
|
231 #endif |
|
232 |
|
233 /* ************************************************************************** */ |
|
234 |
|
235 #ifndef MNG_SKIPCHUNK_zTXt |
|
236 MNG_LOCAL mng_field_descriptor mng_fields_ztxt [] = |
|
237 { |
|
238 {MNG_NULL, |
|
239 MNG_FIELD_TERMINATOR, |
|
240 0, 0, 1, 79, |
|
241 offsetof(mng_ztxt, zKeyword), MNG_NULL, offsetof(mng_ztxt, iKeywordsize)}, |
|
242 {MNG_NULL, |
|
243 MNG_FIELD_INT, |
|
244 0, 0, 1, 1, |
|
245 offsetof(mng_ztxt, iCompression), MNG_NULL, MNG_NULL}, |
|
246 {MNG_NULL, |
|
247 MNG_FIELD_DEFLATED, |
|
248 0, 0, 0, 0, |
|
249 offsetof(mng_ztxt, zText), MNG_NULL, offsetof(mng_ztxt, iTextsize)} |
|
250 }; |
|
251 #endif |
|
252 |
|
253 /* ************************************************************************** */ |
|
254 |
|
255 #ifndef MNG_SKIPCHUNK_iTXt |
|
256 MNG_LOCAL mng_field_descriptor mng_fields_itxt [] = |
|
257 { |
|
258 {MNG_NULL, |
|
259 MNG_FIELD_TERMINATOR, |
|
260 0, 0, 1, 79, |
|
261 offsetof(mng_itxt, zKeyword), MNG_NULL, offsetof(mng_itxt, iKeywordsize)}, |
|
262 {MNG_NULL, |
|
263 MNG_FIELD_INT, |
|
264 0, 1, 1, 1, |
|
265 offsetof(mng_itxt, iCompressionflag), MNG_NULL, MNG_NULL}, |
|
266 {MNG_NULL, |
|
267 MNG_FIELD_INT, |
|
268 0, 0, 1, 1, |
|
269 offsetof(mng_itxt, iCompressionmethod), MNG_NULL, MNG_NULL}, |
|
270 {MNG_NULL, |
|
271 MNG_FIELD_TERMINATOR, |
|
272 0, 0, 0, 0, |
|
273 offsetof(mng_itxt, zLanguage), MNG_NULL, offsetof(mng_itxt, iLanguagesize)}, |
|
274 {MNG_NULL, |
|
275 MNG_FIELD_TERMINATOR, |
|
276 0, 0, 0, 0, |
|
277 offsetof(mng_itxt, zTranslation), MNG_NULL, offsetof(mng_itxt, iTranslationsize)}, |
|
278 {mng_deflate_itxt, |
|
279 MNG_NULL, |
|
280 0, 0, 0, 0, |
|
281 MNG_NULL, MNG_NULL, MNG_NULL} |
|
282 }; |
|
283 #endif |
|
284 |
|
285 /* ************************************************************************** */ |
|
286 |
|
287 #ifndef MNG_SKIPCHUNK_bKGD |
|
288 MNG_LOCAL mng_field_descriptor mng_fields_bkgd [] = |
|
289 { |
|
290 {MNG_NULL, |
|
291 MNG_FIELD_INT | MNG_FIELD_PUTIMGTYPE, |
|
292 0, 0, 0, 0, |
|
293 offsetof(mng_bkgd, iType), MNG_NULL, MNG_NULL}, |
|
294 {MNG_NULL, |
|
295 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE3, |
|
296 0, 0xFF, 1, 1, |
|
297 offsetof(mng_bkgd, iIndex), MNG_NULL, MNG_NULL}, |
|
298 {MNG_NULL, |
|
299 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE0 | MNG_FIELD_IFIMGTYPE4, |
|
300 0, 0xFFFF, 2, 2, |
|
301 offsetof(mng_bkgd, iGray), MNG_NULL, MNG_NULL}, |
|
302 {MNG_NULL, |
|
303 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE6, |
|
304 0, 0xFFFF, 2, 2, |
|
305 offsetof(mng_bkgd, iRed), MNG_NULL, MNG_NULL}, |
|
306 {MNG_NULL, |
|
307 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE6, |
|
308 0, 0xFFFF, 2, 2, |
|
309 offsetof(mng_bkgd, iGreen), MNG_NULL, MNG_NULL}, |
|
310 {MNG_NULL, |
|
311 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE6, |
|
312 0, 0xFFFF, 2, 2, |
|
313 offsetof(mng_bkgd, iBlue), MNG_NULL, MNG_NULL} |
|
314 }; |
|
315 #endif |
|
316 |
|
317 /* ************************************************************************** */ |
|
318 |
|
319 #ifndef MNG_SKIPCHUNK_pHYs |
|
320 MNG_LOCAL mng_field_descriptor mng_fields_phys [] = |
|
321 { |
|
322 {MNG_NULL, |
|
323 MNG_FIELD_INT, |
|
324 0, 0, 4, 4, |
|
325 offsetof(mng_phys, iSizex), MNG_NULL, MNG_NULL}, |
|
326 {MNG_NULL, |
|
327 MNG_FIELD_INT, |
|
328 0, 0, 4, 4, |
|
329 offsetof(mng_phys, iSizey), MNG_NULL, MNG_NULL}, |
|
330 {MNG_NULL, |
|
331 MNG_FIELD_INT, |
|
332 0, 1, 1, 1, |
|
333 offsetof(mng_phys, iUnit), MNG_NULL, MNG_NULL} |
|
334 }; |
|
335 #endif |
|
336 |
|
337 /* ************************************************************************** */ |
|
338 |
|
339 #ifndef MNG_SKIPCHUNK_sBIT |
|
340 MNG_LOCAL mng_field_descriptor mng_fields_sbit [] = |
|
341 { |
|
342 {MNG_NULL, |
|
343 MNG_FIELD_INT | MNG_FIELD_PUTIMGTYPE, |
|
344 0, 0, 0, 0, |
|
345 offsetof(mng_sbit, iType), MNG_NULL, MNG_NULL}, |
|
346 {MNG_NULL, |
|
347 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPES, |
|
348 0, 0xFF, 1, 1, |
|
349 offsetof(mng_sbit, aBits[0]), MNG_NULL, MNG_NULL}, |
|
350 {MNG_NULL, |
|
351 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE3 | MNG_FIELD_IFIMGTYPE4 | MNG_FIELD_IFIMGTYPE6, |
|
352 0, 0xFF, 1, 1, |
|
353 offsetof(mng_sbit, aBits[1]), MNG_NULL, MNG_NULL}, |
|
354 {MNG_NULL, |
|
355 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE3 | MNG_FIELD_IFIMGTYPE6, |
|
356 0, 0xFF, 1, 1, |
|
357 offsetof(mng_sbit, aBits[2]), MNG_NULL, MNG_NULL}, |
|
358 {MNG_NULL, |
|
359 MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE6, |
|
360 0, 0xFF, 1, 1, |
|
361 offsetof(mng_sbit, aBits[3]), MNG_NULL, MNG_NULL} |
|
362 }; |
|
363 #endif |
|
364 |
|
365 /* ************************************************************************** */ |
|
366 |
|
367 #ifndef MNG_SKIPCHUNK_sPLT |
|
368 MNG_LOCAL mng_field_descriptor mng_fields_splt [] = |
|
369 { |
|
370 {MNG_NULL, |
|
371 MNG_NULL, |
|
372 0, 0, 1, 79, |
|
373 offsetof(mng_splt, zName), MNG_NULL, offsetof(mng_splt, iNamesize)}, |
|
374 {MNG_NULL, |
|
375 MNG_FIELD_INT, |
|
376 8, 16, 1, 1, |
|
377 offsetof(mng_splt, iSampledepth), MNG_NULL, MNG_NULL}, |
|
378 {mng_splt_entries, |
|
379 MNG_NULL, |
|
380 0, 0, 0, 0, |
|
381 MNG_NULL, MNG_NULL, MNG_NULL} |
|
382 }; |
|
383 #endif |
|
384 |
|
385 /* ************************************************************************** */ |
|
386 |
|
387 #ifndef MNG_SKIPCHUNK_hIST |
|
388 MNG_LOCAL mng_field_descriptor mng_fields_hist [] = |
|
389 { |
|
390 {mng_hist_entries, |
|
391 MNG_NULL, |
|
392 0, 0, 0, 0, |
|
393 MNG_NULL, MNG_NULL, MNG_NULL} |
|
394 }; |
|
395 #endif |
|
396 |
|
397 /* ************************************************************************** */ |
|
398 |
|
399 #ifndef MNG_SKIPCHUNK_tIME |
|
400 MNG_LOCAL mng_field_descriptor mng_fields_time [] = |
|
401 { |
|
402 {MNG_NULL, |
|
403 MNG_FIELD_INT, |
|
404 0, 0xFFFF, 2, 2, |
|
405 offsetof(mng_time, iYear), MNG_NULL, MNG_NULL}, |
|
406 {MNG_NULL, |
|
407 MNG_FIELD_INT, |
|
408 1, 12, 1, 1, |
|
409 offsetof(mng_time, iMonth), MNG_NULL, MNG_NULL}, |
|
410 {MNG_NULL, |
|
411 MNG_FIELD_INT, |
|
412 1, 31, 1, 1, |
|
413 offsetof(mng_time, iDay), MNG_NULL, MNG_NULL}, |
|
414 {MNG_NULL, |
|
415 MNG_FIELD_INT, |
|
416 0, 24, 1, 1, |
|
417 offsetof(mng_time, iHour), MNG_NULL, MNG_NULL}, |
|
418 {MNG_NULL, |
|
419 MNG_FIELD_INT, |
|
420 0, 60, 1, 1, |
|
421 offsetof(mng_time, iMinute), MNG_NULL, MNG_NULL}, |
|
422 {MNG_NULL, |
|
423 MNG_FIELD_INT, |
|
424 0, 60, 1, 1, |
|
425 offsetof(mng_time, iSecond), MNG_NULL, MNG_NULL} |
|
426 }; |
|
427 #endif |
|
428 |
|
429 /* ************************************************************************** */ |
|
430 /* ************************************************************************** */ |
|
431 /* JNG chunks */ |
|
432 |
|
433 #ifdef MNG_INCLUDE_JNG |
|
434 MNG_LOCAL mng_field_descriptor mng_fields_jhdr [] = |
|
435 { |
|
436 {MNG_NULL, |
|
437 MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT, |
|
438 1, 0, 4, 4, |
|
439 offsetof(mng_jhdr, iWidth), MNG_NULL, MNG_NULL}, |
|
440 {MNG_NULL, |
|
441 MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT, |
|
442 1, 0, 4, 4, |
|
443 offsetof(mng_jhdr, iHeight), MNG_NULL, MNG_NULL}, |
|
444 {MNG_NULL, |
|
445 MNG_FIELD_INT, |
|
446 8, 16, 1, 1, |
|
447 offsetof(mng_jhdr, iColortype), MNG_NULL, MNG_NULL}, |
|
448 {MNG_NULL, |
|
449 MNG_FIELD_INT, |
|
450 8, 20, 1, 1, |
|
451 offsetof(mng_jhdr, iImagesampledepth), MNG_NULL, MNG_NULL}, |
|
452 {MNG_NULL, |
|
453 MNG_FIELD_INT, |
|
454 8, 8, 1, 1, |
|
455 offsetof(mng_jhdr, iImagecompression), MNG_NULL, MNG_NULL}, |
|
456 {MNG_NULL, |
|
457 MNG_FIELD_INT, |
|
458 0, 8, 1, 1, |
|
459 offsetof(mng_jhdr, iImageinterlace), MNG_NULL, MNG_NULL}, |
|
460 {MNG_NULL, |
|
461 MNG_FIELD_INT, |
|
462 0, 16, 1, 1, |
|
463 offsetof(mng_jhdr, iAlphasampledepth), MNG_NULL, MNG_NULL}, |
|
464 {MNG_NULL, |
|
465 MNG_FIELD_INT, |
|
466 0, 8, 1, 1, |
|
467 offsetof(mng_jhdr, iAlphacompression), MNG_NULL, MNG_NULL}, |
|
468 {MNG_NULL, |
|
469 MNG_FIELD_INT, |
|
470 0, 0, 1, 1, |
|
471 offsetof(mng_jhdr, iAlphafilter), MNG_NULL, MNG_NULL}, |
|
472 {MNG_NULL, |
|
473 MNG_FIELD_INT, |
|
474 0, 1, 1, 1, |
|
475 offsetof(mng_jhdr, iAlphainterlace), MNG_NULL, MNG_NULL} |
|
476 }; |
|
477 #endif |
|
478 |
|
479 /* ************************************************************************** */ |
|
480 |
|
481 #ifdef MNG_INCLUDE_JNG |
|
482 #define mng_fields_jdaa mng_fields_idat |
|
483 #define mng_fields_jdat mng_fields_idat |
|
484 #endif |
|
485 |
|
486 /* ************************************************************************** */ |
|
487 /* ************************************************************************** */ |
|
488 /* MNG chunks */ |
|
489 |
|
490 MNG_LOCAL mng_field_descriptor mng_fields_mhdr [] = |
|
491 { |
|
492 {MNG_NULL, |
|
493 MNG_FIELD_INT, |
|
494 0, 0, 4, 4, |
|
495 offsetof(mng_mhdr, iWidth), MNG_NULL, MNG_NULL}, |
|
496 {MNG_NULL, |
|
497 MNG_FIELD_INT, |
|
498 0, 0, 4, 4, |
|
499 offsetof(mng_mhdr, iHeight), MNG_NULL, MNG_NULL}, |
|
500 {MNG_NULL, |
|
501 MNG_FIELD_INT, |
|
502 0, 0, 4, 4, |
|
503 offsetof(mng_mhdr, iTicks), MNG_NULL, MNG_NULL}, |
|
504 {MNG_NULL, |
|
505 MNG_FIELD_INT, |
|
506 0, 0, 4, 4, |
|
507 offsetof(mng_mhdr, iLayercount), MNG_NULL, MNG_NULL}, |
|
508 {MNG_NULL, |
|
509 MNG_FIELD_INT, |
|
510 0, 0, 4, 4, |
|
511 offsetof(mng_mhdr, iFramecount), MNG_NULL, MNG_NULL}, |
|
512 {MNG_NULL, |
|
513 MNG_FIELD_INT, |
|
514 0, 0, 4, 4, |
|
515 offsetof(mng_mhdr, iPlaytime), MNG_NULL, MNG_NULL}, |
|
516 {MNG_NULL, |
|
517 MNG_FIELD_INT, |
|
518 0, 0, 4, 4, |
|
519 offsetof(mng_mhdr, iSimplicity), MNG_NULL, MNG_NULL} |
|
520 }; |
|
521 |
|
522 /* ************************************************************************** */ |
|
523 |
|
524 #ifndef MNG_SKIPCHUNK_LOOP |
|
525 MNG_LOCAL mng_field_descriptor mng_fields_loop [] = |
|
526 { |
|
527 {mng_debunk_loop, |
|
528 MNG_NULL, |
|
529 0, 0, 0, 0, |
|
530 MNG_NULL, MNG_NULL, MNG_NULL} |
|
531 }; |
|
532 #endif |
|
533 |
|
534 /* ************************************************************************** */ |
|
535 |
|
536 #ifndef MNG_SKIPCHUNK_LOOP |
|
537 MNG_LOCAL mng_field_descriptor mng_fields_endl [] = |
|
538 { |
|
539 {MNG_NULL, |
|
540 MNG_FIELD_INT, |
|
541 0, 0xFF, 1, 1, |
|
542 offsetof(mng_endl, iLevel), MNG_NULL, MNG_NULL} |
|
543 }; |
|
544 #endif |
|
545 |
|
546 /* ************************************************************************** */ |
|
547 |
|
548 #ifndef MNG_SKIPCHUNK_DEFI |
|
549 MNG_LOCAL mng_field_descriptor mng_fields_defi [] = |
|
550 { |
|
551 {MNG_NULL, |
|
552 MNG_FIELD_INT, |
|
553 0, 0xFFFF, 2, 2, |
|
554 offsetof(mng_defi, iObjectid), MNG_NULL, MNG_NULL}, |
|
555 {MNG_NULL, |
|
556 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
557 0, 0xFF, 1, 1, |
|
558 offsetof(mng_defi, iDonotshow), offsetof(mng_defi, bHasdonotshow), MNG_NULL}, |
|
559 {MNG_NULL, |
|
560 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
561 0, 0xFF, 1, 1, |
|
562 offsetof(mng_defi, iConcrete), offsetof(mng_defi, bHasconcrete), MNG_NULL}, |
|
563 {MNG_NULL, |
|
564 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
565 0, 0, 4, 4, |
|
566 offsetof(mng_defi, iXlocation), offsetof(mng_defi, bHasloca), MNG_NULL}, |
|
567 {MNG_NULL, |
|
568 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
569 0, 0, 4, 4, |
|
570 offsetof(mng_defi, iYlocation), MNG_NULL, MNG_NULL}, |
|
571 {MNG_NULL, |
|
572 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2, |
|
573 0, 0, 4, 4, |
|
574 offsetof(mng_defi, iLeftcb), offsetof(mng_defi, bHasclip), MNG_NULL}, |
|
575 {MNG_NULL, |
|
576 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2, |
|
577 0, 0, 4, 4, |
|
578 offsetof(mng_defi, iRightcb), MNG_NULL, MNG_NULL}, |
|
579 {MNG_NULL, |
|
580 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2, |
|
581 0, 0, 4, 4, |
|
582 offsetof(mng_defi, iTopcb), MNG_NULL, MNG_NULL}, |
|
583 {MNG_NULL, |
|
584 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2, |
|
585 0, 0, 4, 4, |
|
586 offsetof(mng_defi, iBottomcb), MNG_NULL, MNG_NULL} |
|
587 }; |
|
588 #endif |
|
589 |
|
590 /* ************************************************************************** */ |
|
591 |
|
592 #ifndef MNG_SKIPCHUNK_BASI |
|
593 MNG_LOCAL mng_field_descriptor mng_fields_basi [] = |
|
594 { |
|
595 {MNG_NULL, |
|
596 MNG_FIELD_INT, |
|
597 0, 0, 4, 4, |
|
598 offsetof(mng_basi, iWidth), MNG_NULL, MNG_NULL}, |
|
599 {MNG_NULL, |
|
600 MNG_FIELD_INT, |
|
601 0, 0, 4, 4, |
|
602 offsetof(mng_basi, iHeight), MNG_NULL, MNG_NULL}, |
|
603 {MNG_NULL, |
|
604 MNG_FIELD_INT, |
|
605 1, 16, 1, 1, |
|
606 offsetof(mng_basi, iBitdepth), MNG_NULL, MNG_NULL}, |
|
607 {MNG_NULL, |
|
608 MNG_FIELD_INT, |
|
609 0, 6, 1, 1, |
|
610 offsetof(mng_basi, iColortype), MNG_NULL, MNG_NULL}, |
|
611 {MNG_NULL, |
|
612 MNG_FIELD_INT, |
|
613 0, 0, 1, 1, |
|
614 offsetof(mng_basi, iCompression), MNG_NULL, MNG_NULL}, |
|
615 {MNG_NULL, |
|
616 MNG_FIELD_INT, |
|
617 0, 0, 1, 1, |
|
618 offsetof(mng_basi, iFilter), MNG_NULL, MNG_NULL}, |
|
619 {MNG_NULL, |
|
620 MNG_FIELD_INT, |
|
621 0, 1, 1, 1, |
|
622 offsetof(mng_basi, iInterlace), MNG_NULL, MNG_NULL}, |
|
623 {MNG_NULL, |
|
624 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
625 0, 0xFFFF, 2, 2, |
|
626 offsetof(mng_basi, iRed), MNG_NULL, MNG_NULL}, |
|
627 {MNG_NULL, |
|
628 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
629 0, 0xFFFF, 2, 2, |
|
630 offsetof(mng_basi, iGreen), MNG_NULL, MNG_NULL}, |
|
631 {MNG_NULL, |
|
632 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
633 0, 0xFFFF, 2, 2, |
|
634 offsetof(mng_basi, iBlue), MNG_NULL, MNG_NULL}, |
|
635 {MNG_NULL, |
|
636 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
637 0, 0xFFFF, 2, 2, |
|
638 offsetof(mng_basi, iAlpha), offsetof(mng_basi, bHasalpha), MNG_NULL}, |
|
639 {MNG_NULL, |
|
640 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
641 0, 1, 1, 1, |
|
642 offsetof(mng_basi, iViewable), MNG_NULL, MNG_NULL} |
|
643 }; |
|
644 #endif |
|
645 |
|
646 /* ************************************************************************** */ |
|
647 |
|
648 #ifndef MNG_SKIPCHUNK_CLON |
|
649 MNG_LOCAL mng_field_descriptor mng_fields_clon [] = |
|
650 { |
|
651 {MNG_NULL, |
|
652 MNG_FIELD_INT, |
|
653 0, 0xFFFF, 2, 2, |
|
654 offsetof(mng_clon, iSourceid), MNG_NULL, MNG_NULL}, |
|
655 {MNG_NULL, |
|
656 MNG_FIELD_INT, |
|
657 0, 0xFFFF, 2, 2, |
|
658 offsetof(mng_clon, iCloneid), MNG_NULL, MNG_NULL}, |
|
659 {MNG_NULL, |
|
660 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
661 0, 2, 1, 1, |
|
662 offsetof(mng_clon, iClonetype), MNG_NULL, MNG_NULL}, |
|
663 {MNG_NULL, |
|
664 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
665 0, 1, 1, 1, |
|
666 offsetof(mng_clon, iDonotshow), offsetof(mng_clon, bHasdonotshow), MNG_NULL}, |
|
667 {MNG_NULL, |
|
668 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
669 0, 1, 1, 1, |
|
670 offsetof(mng_clon, iConcrete), MNG_NULL, MNG_NULL}, |
|
671 {MNG_NULL, |
|
672 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
673 0, 2, 1, 1, |
|
674 offsetof(mng_clon, iLocationtype), offsetof(mng_clon, bHasloca), MNG_NULL}, |
|
675 {MNG_NULL, |
|
676 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
677 0, 0, 4, 4, |
|
678 offsetof(mng_clon, iLocationx), MNG_NULL, MNG_NULL}, |
|
679 {MNG_NULL, |
|
680 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
681 0, 0, 4, 4, |
|
682 offsetof(mng_clon, iLocationy), MNG_NULL, MNG_NULL} |
|
683 }; |
|
684 #endif |
|
685 |
|
686 /* ************************************************************************** */ |
|
687 |
|
688 #ifndef MNG_SKIPCHUNK_PAST |
|
689 MNG_LOCAL mng_field_descriptor mng_fields_past [] = |
|
690 { |
|
691 {mng_debunk_past, |
|
692 MNG_NULL, |
|
693 0, 0, 0, 0, |
|
694 MNG_NULL, MNG_NULL, MNG_NULL} |
|
695 }; |
|
696 #endif |
|
697 |
|
698 /* ************************************************************************** */ |
|
699 |
|
700 #ifndef MNG_SKIPCHUNK_DISC |
|
701 MNG_LOCAL mng_field_descriptor mng_fields_disc [] = |
|
702 { |
|
703 {mng_disc_entries, |
|
704 MNG_NULL, |
|
705 0, 0, 0, 0, |
|
706 MNG_NULL, MNG_NULL, MNG_NULL} |
|
707 }; |
|
708 #endif |
|
709 |
|
710 /* ************************************************************************** */ |
|
711 |
|
712 #ifndef MNG_SKIPCHUNK_BACK |
|
713 MNG_LOCAL mng_field_descriptor mng_fields_back [] = |
|
714 { |
|
715 {MNG_NULL, |
|
716 MNG_FIELD_INT, |
|
717 0, 0xFFFF, 2, 2, |
|
718 offsetof(mng_back, iRed), MNG_NULL, MNG_NULL}, |
|
719 {MNG_NULL, |
|
720 MNG_FIELD_INT, |
|
721 0, 0xFFFF, 2, 2, |
|
722 offsetof(mng_back, iGreen), MNG_NULL, MNG_NULL}, |
|
723 {MNG_NULL, |
|
724 MNG_FIELD_INT, |
|
725 0, 0xFFFF, 2, 2, |
|
726 offsetof(mng_back, iBlue), MNG_NULL, MNG_NULL}, |
|
727 {MNG_NULL, |
|
728 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
729 0, 3, 1, 1, |
|
730 offsetof(mng_back, iMandatory), MNG_NULL, MNG_NULL}, |
|
731 {MNG_NULL, |
|
732 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
733 0, 0xFFFF, 2, 2, |
|
734 offsetof(mng_back, iImageid), MNG_NULL, MNG_NULL}, |
|
735 {MNG_NULL, |
|
736 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
737 0, 1, 1, 1, |
|
738 offsetof(mng_back, iTile), MNG_NULL, MNG_NULL} |
|
739 }; |
|
740 #endif |
|
741 |
|
742 /* ************************************************************************** */ |
|
743 |
|
744 #ifndef MNG_SKIPCHUNK_FRAM |
|
745 MNG_LOCAL mng_field_descriptor mng_fields_fram [] = |
|
746 { |
|
747 {MNG_NULL, |
|
748 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
749 0, 4, 1, 1, |
|
750 offsetof(mng_fram, iMode), MNG_NULL, MNG_NULL}, |
|
751 {MNG_NULL, |
|
752 MNG_FIELD_TERMINATOR | MNG_FIELD_OPTIONAL, |
|
753 0, 0, 1, 79, |
|
754 offsetof(mng_fram, zName), MNG_NULL, offsetof(mng_fram, iNamesize)}, |
|
755 {mng_fram_remainder, |
|
756 MNG_FIELD_OPTIONAL, |
|
757 0, 0, 0, 0, |
|
758 MNG_NULL, MNG_NULL, MNG_NULL} |
|
759 }; |
|
760 #endif |
|
761 |
|
762 /* ************************************************************************** */ |
|
763 |
|
764 #ifndef MNG_SKIPCHUNK_MOVE |
|
765 MNG_LOCAL mng_field_descriptor mng_fields_move [] = |
|
766 { |
|
767 {MNG_NULL, |
|
768 MNG_FIELD_INT, |
|
769 0, 0xFFFF, 2, 2, |
|
770 offsetof(mng_move, iFirstid), MNG_NULL, MNG_NULL}, |
|
771 {MNG_NULL, |
|
772 MNG_FIELD_INT, |
|
773 0, 0xFFFF, 2, 2, |
|
774 offsetof(mng_move, iLastid), MNG_NULL, MNG_NULL}, |
|
775 {MNG_NULL, |
|
776 MNG_FIELD_INT, |
|
777 0, 1, 1, 1, |
|
778 offsetof(mng_move, iMovetype), MNG_NULL, MNG_NULL}, |
|
779 {MNG_NULL, |
|
780 MNG_FIELD_INT, |
|
781 0, 0, 4, 4, |
|
782 offsetof(mng_move, iMovex), MNG_NULL, MNG_NULL}, |
|
783 {MNG_NULL, |
|
784 MNG_FIELD_INT, |
|
785 0, 0, 4, 4, |
|
786 offsetof(mng_move, iMovey), MNG_NULL, MNG_NULL} |
|
787 }; |
|
788 #endif |
|
789 |
|
790 /* ************************************************************************** */ |
|
791 |
|
792 #ifndef MNG_SKIPCHUNK_CLIP |
|
793 MNG_LOCAL mng_field_descriptor mng_fields_clip [] = |
|
794 { |
|
795 {MNG_NULL, |
|
796 MNG_FIELD_INT, |
|
797 0, 0xFFFF, 2, 2, |
|
798 offsetof(mng_clip, iFirstid), MNG_NULL, MNG_NULL}, |
|
799 {MNG_NULL, |
|
800 MNG_FIELD_INT, |
|
801 0, 0xFFFF, 2, 2, |
|
802 offsetof(mng_clip, iLastid), MNG_NULL, MNG_NULL}, |
|
803 {MNG_NULL, |
|
804 MNG_FIELD_INT, |
|
805 0, 1, 1, 1, |
|
806 offsetof(mng_clip, iCliptype), MNG_NULL, MNG_NULL}, |
|
807 {MNG_NULL, |
|
808 MNG_FIELD_INT, |
|
809 0, 0, 4, 4, |
|
810 offsetof(mng_clip, iClipl), MNG_NULL, MNG_NULL}, |
|
811 {MNG_NULL, |
|
812 MNG_FIELD_INT, |
|
813 0, 0, 4, 4, |
|
814 offsetof(mng_clip, iClipr), MNG_NULL, MNG_NULL}, |
|
815 {MNG_NULL, |
|
816 MNG_FIELD_INT, |
|
817 0, 0, 4, 4, |
|
818 offsetof(mng_clip, iClipt), MNG_NULL, MNG_NULL}, |
|
819 {MNG_NULL, |
|
820 MNG_FIELD_INT, |
|
821 0, 0, 4, 4, |
|
822 offsetof(mng_clip, iClipb), MNG_NULL, MNG_NULL} |
|
823 }; |
|
824 #endif |
|
825 |
|
826 /* ************************************************************************** */ |
|
827 |
|
828 #ifndef MNG_SKIPCHUNK_SHOW |
|
829 MNG_LOCAL mng_field_descriptor mng_fields_show [] = |
|
830 { |
|
831 {MNG_NULL, |
|
832 MNG_FIELD_INT, |
|
833 1, 0xFFFF, 2, 2, |
|
834 offsetof(mng_show, iFirstid), MNG_NULL, MNG_NULL}, |
|
835 {MNG_NULL, |
|
836 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
837 1, 0xFFFF, 2, 2, |
|
838 offsetof(mng_show, iLastid), offsetof(mng_show, bHaslastid), MNG_NULL}, |
|
839 {MNG_NULL, |
|
840 MNG_FIELD_INT | MNG_FIELD_OPTIONAL, |
|
841 0, 7, 1, 1, |
|
842 offsetof(mng_show, iMode), MNG_NULL, MNG_NULL} |
|
843 }; |
|
844 #endif |
|
845 |
|
846 /* ************************************************************************** */ |
|
847 |
|
848 #ifndef MNG_SKIPCHUNK_TERM |
|
849 MNG_LOCAL mng_field_descriptor mng_fields_term [] = |
|
850 { |
|
851 {MNG_NULL, |
|
852 MNG_FIELD_INT, |
|
853 0, 3, 1, 1, |
|
854 offsetof(mng_term, iTermaction), MNG_NULL, MNG_NULL}, |
|
855 {MNG_NULL, |
|
856 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
857 0, 2, 1, 1, |
|
858 offsetof(mng_term, iIteraction), MNG_NULL, MNG_NULL}, |
|
859 {MNG_NULL, |
|
860 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
861 0, 0, 4, 4, |
|
862 offsetof(mng_term, iDelay), MNG_NULL, MNG_NULL}, |
|
863 {MNG_NULL, |
|
864 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
865 0, 0, 4, 4, |
|
866 offsetof(mng_term, iItermax), MNG_NULL, MNG_NULL} |
|
867 }; |
|
868 #endif |
|
869 |
|
870 /* ************************************************************************** */ |
|
871 |
|
872 #ifndef MNG_SKIPCHUNK_SAVE |
|
873 MNG_LOCAL mng_field_descriptor mng_fields_save [] = |
|
874 { |
|
875 {mng_save_entries, |
|
876 MNG_NULL, |
|
877 0, 0, 0, 0, |
|
878 MNG_NULL, MNG_NULL, MNG_NULL} |
|
879 }; |
|
880 #endif |
|
881 |
|
882 /* ************************************************************************** */ |
|
883 |
|
884 #ifndef MNG_SKIPCHUNK_SEEK |
|
885 MNG_LOCAL mng_field_descriptor mng_fields_seek [] = |
|
886 { |
|
887 {MNG_NULL, |
|
888 MNG_NULL, |
|
889 0, 0, 1, 79, |
|
890 offsetof(mng_seek, zName), MNG_NULL, offsetof(mng_seek, iNamesize)} |
|
891 }; |
|
892 #endif |
|
893 |
|
894 /* ************************************************************************** */ |
|
895 |
|
896 #ifndef MNG_SKIPCHUNK_eXPI |
|
897 MNG_LOCAL mng_field_descriptor mng_fields_expi [] = |
|
898 { |
|
899 {MNG_NULL, |
|
900 MNG_FIELD_INT, |
|
901 0, 0xFFFF, 2, 2, |
|
902 offsetof(mng_expi, iSnapshotid), MNG_NULL, MNG_NULL}, |
|
903 {MNG_NULL, |
|
904 MNG_NULL, |
|
905 0, 0, 1, 79, |
|
906 offsetof(mng_expi, zName), MNG_NULL, offsetof(mng_expi, iNamesize)} |
|
907 }; |
|
908 #endif |
|
909 |
|
910 /* ************************************************************************** */ |
|
911 |
|
912 #ifndef MNG_SKIPCHUNK_fPRI |
|
913 MNG_LOCAL mng_field_descriptor mng_fields_fpri [] = |
|
914 { |
|
915 {MNG_NULL, |
|
916 MNG_FIELD_INT, |
|
917 0, 1, 1, 1, |
|
918 offsetof(mng_fpri, iDeltatype), MNG_NULL, MNG_NULL}, |
|
919 {MNG_NULL, |
|
920 MNG_FIELD_INT, |
|
921 0, 0xFF, 1, 1, |
|
922 offsetof(mng_fpri, iPriority), MNG_NULL, MNG_NULL} |
|
923 }; |
|
924 #endif |
|
925 |
|
926 /* ************************************************************************** */ |
|
927 |
|
928 #ifndef MNG_SKIPCHUNK_nEED |
|
929 MNG_LOCAL mng_field_descriptor mng_fields_need [] = |
|
930 { |
|
931 {MNG_NULL, |
|
932 MNG_NULL, |
|
933 0, 0, 1, 0, |
|
934 offsetof(mng_need, zKeywords), MNG_NULL, offsetof(mng_need, iKeywordssize)} |
|
935 }; |
|
936 #endif |
|
937 |
|
938 /* ************************************************************************** */ |
|
939 |
|
940 #ifndef MNG_SKIPCHUNK_pHYg |
|
941 #define mng_fields_phyg mng_fields_phys |
|
942 #endif |
|
943 |
|
944 /* ************************************************************************** */ |
|
945 |
|
946 #ifndef MNG_NO_DELTA_PNG |
|
947 MNG_LOCAL mng_field_descriptor mng_fields_dhdr [] = |
|
948 { |
|
949 {MNG_NULL, |
|
950 MNG_FIELD_INT, |
|
951 0, 0xFFFF, 2, 2, |
|
952 offsetof(mng_dhdr, iObjectid), MNG_NULL, MNG_NULL}, |
|
953 {MNG_NULL, |
|
954 MNG_FIELD_INT, |
|
955 0, 2, 1, 1, |
|
956 offsetof(mng_dhdr, iImagetype), MNG_NULL, MNG_NULL}, |
|
957 {MNG_NULL, |
|
958 MNG_FIELD_INT, |
|
959 0, 7, 1, 1, |
|
960 offsetof(mng_dhdr, iDeltatype), MNG_NULL, MNG_NULL}, |
|
961 {MNG_NULL, |
|
962 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
963 0, 0, 4, 4, |
|
964 offsetof(mng_dhdr, iBlockwidth), offsetof(mng_dhdr, bHasblocksize), MNG_NULL}, |
|
965 {MNG_NULL, |
|
966 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1, |
|
967 0, 0, 4, 4, |
|
968 offsetof(mng_dhdr, iBlockheight), MNG_NULL, MNG_NULL}, |
|
969 {MNG_NULL, |
|
970 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2, |
|
971 0, 0, 4, 4, |
|
972 offsetof(mng_dhdr, iBlockx), offsetof(mng_dhdr, bHasblockloc), MNG_NULL}, |
|
973 {MNG_NULL, |
|
974 MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2, |
|
975 0, 0, 4, 4, |
|
976 offsetof(mng_dhdr, iBlocky), MNG_NULL, MNG_NULL} |
|
977 }; |
|
978 #endif |
|
979 |
|
980 /* ************************************************************************** */ |
|
981 |
|
982 #ifndef MNG_NO_DELTA_PNG |
|
983 MNG_LOCAL mng_field_descriptor mng_fields_prom [] = |
|
984 { |
|
985 {MNG_NULL, |
|
986 MNG_FIELD_INT, |
|
987 0, 14, 1, 1, |
|
988 offsetof(mng_prom, iColortype), MNG_NULL, MNG_NULL}, |
|
989 {MNG_NULL, |
|
990 MNG_FIELD_INT, |
|
991 0, 16, 1, 1, |
|
992 offsetof(mng_prom, iSampledepth), MNG_NULL, MNG_NULL}, |
|
993 {MNG_NULL, |
|
994 MNG_FIELD_INT, |
|
995 0, 1, 1, 1, |
|
996 offsetof(mng_prom, iFilltype), MNG_NULL, MNG_NULL} |
|
997 }; |
|
998 #endif |
|
999 |
|
1000 /* ************************************************************************** */ |
|
1001 |
|
1002 #ifndef MNG_NO_DELTA_PNG |
|
1003 MNG_LOCAL mng_field_descriptor mng_fields_pplt [] = |
|
1004 { |
|
1005 {MNG_NULL, |
|
1006 MNG_FIELD_INT, |
|
1007 0, 5, 1, 1, |
|
1008 offsetof(mng_pplt, iDeltatype), MNG_NULL, MNG_NULL}, |
|
1009 {mng_pplt_entries, |
|
1010 MNG_NULL, |
|
1011 0, 0, 0, 0, |
|
1012 MNG_NULL, MNG_NULL, MNG_NULL} |
|
1013 }; |
|
1014 #endif |
|
1015 |
|
1016 /* ************************************************************************** */ |
|
1017 |
|
1018 #ifndef MNG_NO_DELTA_PNG |
|
1019 MNG_LOCAL mng_field_descriptor mng_fields_drop [] = |
|
1020 { |
|
1021 {mng_drop_entries, |
|
1022 MNG_NULL, |
|
1023 0, 0, 0, 0, |
|
1024 MNG_NULL, MNG_NULL, MNG_NULL} |
|
1025 }; |
|
1026 #endif |
|
1027 |
|
1028 /* ************************************************************************** */ |
|
1029 |
|
1030 #ifndef MNG_NO_DELTA_PNG |
|
1031 #ifndef MNG_SKIPCHUNK_DBYK |
|
1032 MNG_LOCAL mng_field_descriptor mng_fields_dbyk [] = |
|
1033 { |
|
1034 {MNG_NULL, |
|
1035 MNG_FIELD_INT, |
|
1036 0, 0, 4, 4, |
|
1037 offsetof(mng_dbyk, iChunkname), MNG_NULL, MNG_NULL}, |
|
1038 {MNG_NULL, |
|
1039 MNG_FIELD_INT, |
|
1040 0, 1, 1, 1, |
|
1041 offsetof(mng_dbyk, iPolarity), MNG_NULL, MNG_NULL}, |
|
1042 {MNG_NULL, |
|
1043 MNG_NULL, |
|
1044 0, 0, 1, 0, |
|
1045 offsetof(mng_dbyk, zKeywords), MNG_NULL, offsetof(mng_dbyk, iKeywordssize)} |
|
1046 }; |
|
1047 #endif |
|
1048 #endif |
|
1049 |
|
1050 /* ************************************************************************** */ |
|
1051 |
|
1052 #ifndef MNG_NO_DELTA_PNG |
|
1053 #ifndef MNG_SKIPCHUNK_ORDR |
|
1054 MNG_LOCAL mng_field_descriptor mng_fields_ordr [] = |
|
1055 { |
|
1056 {mng_drop_entries, |
|
1057 MNG_NULL, |
|
1058 0, 0, 0, 0, |
|
1059 MNG_NULL, MNG_NULL, MNG_NULL} |
|
1060 }; |
|
1061 #endif |
|
1062 #endif |
|
1063 |
|
1064 /* ************************************************************************** */ |
|
1065 |
|
1066 #ifndef MNG_SKIPCHUNK_MAGN |
|
1067 MNG_LOCAL mng_field_descriptor mng_fields_magn [] = |
|
1068 { |
|
1069 {mng_debunk_magn, |
|
1070 MNG_NULL, |
|
1071 0, 0, 0, 0, |
|
1072 MNG_NULL, MNG_NULL, MNG_NULL} |
|
1073 }; |
|
1074 #endif |
|
1075 |
|
1076 /* ************************************************************************** */ |
|
1077 |
|
1078 #ifdef MNG_INCLUDE_MPNG_PROPOSAL |
|
1079 MNG_LOCAL mng_field_descriptor mng_fields_mpng [] = |
|
1080 { |
|
1081 {MNG_NULL, |
|
1082 MNG_FIELD_INT, |
|
1083 1, 0, 4, 4, |
|
1084 offsetof(mng_mpng, iFramewidth), MNG_NULL, MNG_NULL}, |
|
1085 {MNG_NULL, |
|
1086 MNG_FIELD_INT, |
|
1087 1, 0, 4, 4, |
|
1088 offsetof(mng_mpng, iFrameheight), MNG_NULL, MNG_NULL}, |
|
1089 {MNG_NULL, |
|
1090 MNG_FIELD_INT, |
|
1091 0, 0xFFFF, 2, 2, |
|
1092 offsetof(mng_mpng, iNumplays), MNG_NULL, MNG_NULL}, |
|
1093 {MNG_NULL, |
|
1094 MNG_FIELD_INT, |
|
1095 1, 0xFFFF, 2, 2, |
|
1096 offsetof(mng_mpng, iTickspersec), MNG_NULL, MNG_NULL}, |
|
1097 {MNG_NULL, |
|
1098 MNG_FIELD_INT, |
|
1099 0, 0, 1, 1, |
|
1100 offsetof(mng_mpng, iCompressionmethod), MNG_NULL, MNG_NULL}, |
|
1101 {MNG_NULL, |
|
1102 MNG_FIELD_DEFLATED, |
|
1103 0, 0, 1, 0, |
|
1104 offsetof(mng_mpng, pFrames), MNG_NULL, offsetof(mng_mpng, iFramessize)} |
|
1105 }; |
|
1106 #endif |
|
1107 |
|
1108 /* ************************************************************************** */ |
|
1109 |
|
1110 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
1111 MNG_LOCAL mng_field_descriptor mng_fields_ahdr [] = |
|
1112 { |
|
1113 {MNG_NULL, |
|
1114 MNG_FIELD_INT, |
|
1115 1, 0, 4, 4, |
|
1116 offsetof(mng_ahdr, iNumframes), MNG_NULL, MNG_NULL}, |
|
1117 {MNG_NULL, |
|
1118 MNG_FIELD_INT, |
|
1119 0, 0, 4, 4, |
|
1120 offsetof(mng_ahdr, iTickspersec), MNG_NULL, MNG_NULL}, |
|
1121 {MNG_NULL, |
|
1122 MNG_FIELD_INT, |
|
1123 0, 0, 4, 4, |
|
1124 offsetof(mng_ahdr, iNumplays), MNG_NULL, MNG_NULL}, |
|
1125 {MNG_NULL, |
|
1126 MNG_FIELD_INT, |
|
1127 1, 0, 4, 4, |
|
1128 offsetof(mng_ahdr, iTilewidth), MNG_NULL, MNG_NULL}, |
|
1129 {MNG_NULL, |
|
1130 MNG_FIELD_INT, |
|
1131 1, 0, 4, 4, |
|
1132 offsetof(mng_ahdr, iTileheight), MNG_NULL, MNG_NULL}, |
|
1133 {MNG_NULL, |
|
1134 MNG_FIELD_INT, |
|
1135 0, 1, 1, 1, |
|
1136 offsetof(mng_ahdr, iInterlace), MNG_NULL, MNG_NULL}, |
|
1137 {MNG_NULL, |
|
1138 MNG_FIELD_INT, |
|
1139 0, 1, 1, 1, |
|
1140 offsetof(mng_ahdr, iStillused), MNG_NULL, MNG_NULL} |
|
1141 }; |
|
1142 |
|
1143 MNG_LOCAL mng_field_descriptor mng_fields_adat [] = |
|
1144 { |
|
1145 {mng_adat_tiles, |
|
1146 MNG_NULL, |
|
1147 0, 0, 0, 0, |
|
1148 MNG_NULL, MNG_NULL, MNG_NULL} |
|
1149 }; |
|
1150 #endif |
|
1151 |
|
1152 /* ************************************************************************** */ |
|
1153 |
|
1154 #ifndef MNG_SKIPCHUNK_evNT |
|
1155 MNG_LOCAL mng_field_descriptor mng_fields_evnt [] = |
|
1156 { |
|
1157 {mng_evnt_entries, |
|
1158 MNG_NULL, |
|
1159 0, 0, 0, 0, |
|
1160 MNG_NULL, MNG_NULL, MNG_NULL} |
|
1161 }; |
|
1162 #endif |
|
1163 |
|
1164 /* ************************************************************************** */ |
|
1165 |
|
1166 MNG_LOCAL mng_field_descriptor mng_fields_unknown [] = |
|
1167 { |
|
1168 {MNG_NULL, |
|
1169 MNG_NULL, |
|
1170 0, 0, 1, 0, |
|
1171 offsetof(mng_unknown_chunk, pData), MNG_NULL, offsetof(mng_unknown_chunk, iDatasize)} |
|
1172 }; |
|
1173 |
|
1174 /* ************************************************************************** */ |
|
1175 /* ************************************************************************** */ |
|
1176 /* PNG chunks */ |
|
1177 |
|
1178 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ihdr = |
|
1179 {mng_it_png, mng_create_none, 0, 0, |
|
1180 MNG_NULL, MNG_NULL, mng_special_ihdr, |
|
1181 mng_fields_ihdr, (sizeof(mng_fields_ihdr) / sizeof(mng_field_descriptor)), |
|
1182 MNG_DESCR_GLOBAL, |
|
1183 MNG_NULL, |
|
1184 MNG_DESCR_NOIHDR | MNG_DESCR_NOJHDR | MNG_DESCR_NOBASI | MNG_DESCR_NOIDAT | MNG_DESCR_NOPLTE}; |
|
1185 |
|
1186 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_plte = |
|
1187 {mng_it_png, mng_create_none, 0, offsetof(mng_plte, bEmpty), |
|
1188 MNG_NULL, MNG_NULL, mng_special_plte, |
|
1189 mng_fields_plte, (sizeof(mng_fields_plte) / sizeof(mng_field_descriptor)), |
|
1190 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED, |
|
1191 MNG_DESCR_GenHDR, |
|
1192 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1193 |
|
1194 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_idat = |
|
1195 {mng_it_png, mng_create_none, 0, offsetof(mng_idat, bEmpty), |
|
1196 MNG_NULL, MNG_NULL, mng_special_idat, |
|
1197 mng_fields_idat, (sizeof(mng_fields_idat) / sizeof(mng_field_descriptor)), |
|
1198 MNG_DESCR_EMPTYEMBED, |
|
1199 MNG_DESCR_GenHDR, |
|
1200 MNG_DESCR_NOJSEP}; |
|
1201 |
|
1202 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_iend = |
|
1203 {mng_it_png, mng_create_none, 0, 0, |
|
1204 MNG_NULL, MNG_NULL, mng_special_iend, |
|
1205 MNG_NULL, 0, |
|
1206 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED, |
|
1207 MNG_DESCR_GenHDR, |
|
1208 MNG_NULL}; |
|
1209 |
|
1210 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_trns = |
|
1211 {mng_it_png, mng_create_none, 0, offsetof(mng_trns, bEmpty), |
|
1212 MNG_NULL, MNG_NULL, mng_special_trns, |
|
1213 mng_fields_trns, (sizeof(mng_fields_trns) / sizeof(mng_field_descriptor)), |
|
1214 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED, |
|
1215 MNG_DESCR_GenHDR, |
|
1216 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1217 |
|
1218 #ifndef MNG_SKIPCHUNK_gAMA |
|
1219 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_gama = |
|
1220 {mng_it_png, mng_create_none, 0, offsetof(mng_gama, bEmpty), |
|
1221 MNG_NULL, MNG_NULL, mng_special_gama, |
|
1222 mng_fields_gama, (sizeof(mng_fields_gama) / sizeof(mng_field_descriptor)), |
|
1223 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1224 MNG_DESCR_GenHDR, |
|
1225 MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1226 #endif |
|
1227 |
|
1228 #ifndef MNG_SKIPCHUNK_cHRM |
|
1229 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_chrm = |
|
1230 {mng_it_png, mng_create_none, 0, offsetof(mng_chrm, bEmpty), |
|
1231 MNG_NULL, MNG_NULL, mng_special_chrm, |
|
1232 mng_fields_chrm, (sizeof(mng_fields_chrm) / sizeof(mng_field_descriptor)), |
|
1233 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1234 MNG_DESCR_GenHDR, |
|
1235 MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1236 #endif |
|
1237 |
|
1238 #ifndef MNG_SKIPCHUNK_sRGB |
|
1239 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_srgb = |
|
1240 {mng_it_png, mng_create_none, 0, offsetof(mng_srgb, bEmpty), |
|
1241 MNG_NULL, MNG_NULL, mng_special_srgb, |
|
1242 mng_fields_srgb, (sizeof(mng_fields_srgb) / sizeof(mng_field_descriptor)), |
|
1243 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1244 MNG_DESCR_GenHDR, |
|
1245 MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1246 #endif |
|
1247 |
|
1248 #ifndef MNG_SKIPCHUNK_iCCP |
|
1249 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_iccp = |
|
1250 {mng_it_png, mng_create_none, 0, offsetof(mng_iccp, bEmpty), |
|
1251 MNG_NULL, MNG_NULL, mng_special_iccp, |
|
1252 mng_fields_iccp, (sizeof(mng_fields_iccp) / sizeof(mng_field_descriptor)), |
|
1253 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1254 MNG_DESCR_GenHDR, |
|
1255 MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1256 #endif |
|
1257 |
|
1258 #ifndef MNG_SKIPCHUNK_tEXt |
|
1259 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_text = |
|
1260 {mng_it_png, mng_create_none, 0, 0, |
|
1261 MNG_NULL, MNG_NULL, mng_special_text, |
|
1262 mng_fields_text, (sizeof(mng_fields_text) / sizeof(mng_field_descriptor)), |
|
1263 MNG_DESCR_GLOBAL, |
|
1264 MNG_DESCR_GenHDR, |
|
1265 MNG_NULL}; |
|
1266 #endif |
|
1267 |
|
1268 #ifndef MNG_SKIPCHUNK_zTXt |
|
1269 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ztxt = |
|
1270 {mng_it_png, mng_create_none, 0, 0, |
|
1271 MNG_NULL, MNG_NULL, mng_special_ztxt, |
|
1272 mng_fields_ztxt, (sizeof(mng_fields_ztxt) / sizeof(mng_field_descriptor)), |
|
1273 MNG_DESCR_GLOBAL, |
|
1274 MNG_DESCR_GenHDR, |
|
1275 MNG_NULL}; |
|
1276 #endif |
|
1277 |
|
1278 #ifndef MNG_SKIPCHUNK_iTXt |
|
1279 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_itxt = |
|
1280 {mng_it_png, mng_create_none, 0, 0, |
|
1281 MNG_NULL, MNG_NULL, mng_special_itxt, |
|
1282 mng_fields_itxt, (sizeof(mng_fields_itxt) / sizeof(mng_field_descriptor)), |
|
1283 MNG_DESCR_GLOBAL, |
|
1284 MNG_DESCR_GenHDR, |
|
1285 MNG_NULL}; |
|
1286 #endif |
|
1287 |
|
1288 #ifndef MNG_SKIPCHUNK_bKGD |
|
1289 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_bkgd = |
|
1290 {mng_it_png, mng_create_none, 0, offsetof(mng_bkgd, bEmpty), |
|
1291 MNG_NULL, MNG_NULL, mng_special_bkgd, |
|
1292 mng_fields_bkgd, (sizeof(mng_fields_bkgd) / sizeof(mng_field_descriptor)), |
|
1293 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1294 MNG_DESCR_GenHDR, |
|
1295 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1296 #endif |
|
1297 |
|
1298 #ifndef MNG_SKIPCHUNK_pHYs |
|
1299 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_phys = |
|
1300 {mng_it_png, mng_create_none, 0, offsetof(mng_phys, bEmpty), |
|
1301 MNG_NULL, MNG_NULL, mng_special_phys, |
|
1302 mng_fields_phys, (sizeof(mng_fields_phys) / sizeof(mng_field_descriptor)), |
|
1303 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1304 MNG_DESCR_GenHDR, |
|
1305 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1306 #endif |
|
1307 |
|
1308 #ifndef MNG_SKIPCHUNK_sBIT |
|
1309 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_sbit = |
|
1310 {mng_it_png, mng_create_none, 0, offsetof(mng_sbit, bEmpty), |
|
1311 MNG_NULL, MNG_NULL, mng_special_sbit, |
|
1312 mng_fields_sbit, (sizeof(mng_fields_sbit) / sizeof(mng_field_descriptor)), |
|
1313 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1314 MNG_DESCR_GenHDR, |
|
1315 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1316 #endif |
|
1317 |
|
1318 #ifndef MNG_SKIPCHUNK_sPLT |
|
1319 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_splt = |
|
1320 {mng_it_png, mng_create_none, 0, offsetof(mng_splt, bEmpty), |
|
1321 MNG_NULL, MNG_NULL, mng_special_splt, |
|
1322 mng_fields_splt, (sizeof(mng_fields_splt) / sizeof(mng_field_descriptor)), |
|
1323 MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL, |
|
1324 MNG_DESCR_GenHDR, |
|
1325 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1326 #endif |
|
1327 |
|
1328 #ifndef MNG_SKIPCHUNK_hIST |
|
1329 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_hist = |
|
1330 {mng_it_png, mng_create_none, 0, 0, |
|
1331 MNG_NULL, MNG_NULL, mng_special_hist, |
|
1332 mng_fields_hist, (sizeof(mng_fields_hist) / sizeof(mng_field_descriptor)), |
|
1333 MNG_NULL, |
|
1334 MNG_DESCR_GenHDR | MNG_DESCR_PLTE, |
|
1335 MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA}; |
|
1336 #endif |
|
1337 |
|
1338 #ifndef MNG_SKIPCHUNK_tIME |
|
1339 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_time = |
|
1340 {mng_it_png, mng_create_none, 0, 0, |
|
1341 MNG_NULL, MNG_NULL, mng_special_time, |
|
1342 mng_fields_time, (sizeof(mng_fields_time) / sizeof(mng_field_descriptor)), |
|
1343 MNG_DESCR_GLOBAL, |
|
1344 MNG_DESCR_GenHDR, |
|
1345 MNG_NULL}; |
|
1346 #endif |
|
1347 |
|
1348 /* ************************************************************************** */ |
|
1349 /* JNG chunks */ |
|
1350 |
|
1351 #ifdef MNG_INCLUDE_JNG |
|
1352 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jhdr = |
|
1353 {mng_it_jng, mng_create_none, 0, 0, |
|
1354 MNG_NULL, MNG_NULL, mng_special_jhdr, |
|
1355 mng_fields_jhdr, (sizeof(mng_fields_jhdr) / sizeof(mng_field_descriptor)), |
|
1356 MNG_NULL, |
|
1357 MNG_NULL, |
|
1358 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1359 #endif |
|
1360 |
|
1361 #ifdef MNG_INCLUDE_JNG |
|
1362 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jdaa = |
|
1363 {mng_it_jng, mng_create_none, 0, 0, |
|
1364 MNG_NULL, MNG_NULL, mng_special_jdaa, |
|
1365 mng_fields_jdaa, (sizeof(mng_fields_jdaa) / sizeof(mng_field_descriptor)), |
|
1366 MNG_NULL, |
|
1367 MNG_DESCR_JngHDR, |
|
1368 MNG_DESCR_NOJSEP}; |
|
1369 #endif |
|
1370 |
|
1371 #ifdef MNG_INCLUDE_JNG |
|
1372 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jdat = |
|
1373 {mng_it_jng, mng_create_none, 0, 0, |
|
1374 MNG_NULL, MNG_NULL, mng_special_jdat, |
|
1375 mng_fields_jdat, (sizeof(mng_fields_jdat) / sizeof(mng_field_descriptor)), |
|
1376 MNG_DESCR_EMPTYEMBED, |
|
1377 MNG_DESCR_JngHDR, |
|
1378 MNG_NULL}; |
|
1379 #endif |
|
1380 |
|
1381 #ifdef MNG_INCLUDE_JNG |
|
1382 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jsep = |
|
1383 {mng_it_jng, mng_create_none, 0, 0, |
|
1384 MNG_NULL, MNG_NULL, mng_special_jsep, |
|
1385 MNG_NULL, 0, |
|
1386 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED, |
|
1387 MNG_DESCR_JngHDR, |
|
1388 MNG_DESCR_NOJSEP}; |
|
1389 #endif |
|
1390 |
|
1391 /* ************************************************************************** */ |
|
1392 /* MNG chunks */ |
|
1393 |
|
1394 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_mhdr = |
|
1395 {mng_it_mng, mng_create_none, 0, 0, |
|
1396 MNG_NULL, MNG_NULL, mng_special_mhdr, |
|
1397 mng_fields_mhdr, (sizeof(mng_fields_mhdr) / sizeof(mng_field_descriptor)), |
|
1398 MNG_NULL, |
|
1399 MNG_NULL, |
|
1400 MNG_DESCR_NOMHDR | MNG_DESCR_NOIHDR | MNG_DESCR_NOJHDR}; |
|
1401 |
|
1402 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_mend = |
|
1403 {mng_it_mng, mng_create_none, 0, 0, |
|
1404 MNG_NULL, MNG_NULL, mng_special_mend, |
|
1405 MNG_NULL, 0, |
|
1406 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL, |
|
1407 MNG_DESCR_MHDR, |
|
1408 MNG_NULL}; |
|
1409 |
|
1410 #ifndef MNG_SKIPCHUNK_LOOP |
|
1411 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_loop = |
|
1412 {mng_it_mng, mng_create_none, 0, 0, |
|
1413 MNG_NULL, MNG_NULL, mng_special_loop, |
|
1414 mng_fields_loop, (sizeof(mng_fields_loop) / sizeof(mng_field_descriptor)), |
|
1415 MNG_NULL, |
|
1416 MNG_DESCR_MHDR, |
|
1417 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1418 |
|
1419 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_endl = |
|
1420 {mng_it_mng, mng_create_none, 0, 0, |
|
1421 MNG_NULL, MNG_NULL, mng_special_endl, |
|
1422 mng_fields_endl, (sizeof(mng_fields_endl) / sizeof(mng_field_descriptor)), |
|
1423 MNG_NULL, |
|
1424 MNG_DESCR_MHDR, |
|
1425 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1426 #endif |
|
1427 |
|
1428 #ifndef MNG_SKIPCHUNK_DEFI |
|
1429 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_defi = |
|
1430 {mng_it_mng, mng_create_none, 0, 0, |
|
1431 MNG_NULL, MNG_NULL, mng_special_defi, |
|
1432 mng_fields_defi, (sizeof(mng_fields_defi) / sizeof(mng_field_descriptor)), |
|
1433 MNG_NULL, |
|
1434 MNG_DESCR_MHDR, |
|
1435 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1436 #endif |
|
1437 |
|
1438 #ifndef MNG_SKIPCHUNK_BASI |
|
1439 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_basi = |
|
1440 {mng_it_mng, mng_create_none, 0, 0, |
|
1441 MNG_NULL, MNG_NULL, mng_special_basi, |
|
1442 mng_fields_basi, (sizeof(mng_fields_basi) / sizeof(mng_field_descriptor)), |
|
1443 MNG_NULL, |
|
1444 MNG_DESCR_MHDR, |
|
1445 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1446 #endif |
|
1447 |
|
1448 #ifndef MNG_SKIPCHUNK_CLON |
|
1449 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_clon = |
|
1450 {mng_it_mng, mng_create_none, 0, 0, |
|
1451 MNG_NULL, MNG_NULL, mng_special_clon, |
|
1452 mng_fields_clon, (sizeof(mng_fields_clon) / sizeof(mng_field_descriptor)), |
|
1453 MNG_NULL, |
|
1454 MNG_DESCR_MHDR, |
|
1455 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1456 #endif |
|
1457 |
|
1458 #ifndef MNG_SKIPCHUNK_PAST |
|
1459 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_past = |
|
1460 {mng_it_mng, mng_create_none, 0, 0, |
|
1461 MNG_NULL, MNG_NULL, mng_special_past, |
|
1462 mng_fields_past, (sizeof(mng_fields_past) / sizeof(mng_field_descriptor)), |
|
1463 MNG_NULL, |
|
1464 MNG_DESCR_MHDR, |
|
1465 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1466 #endif |
|
1467 |
|
1468 #ifndef MNG_SKIPCHUNK_DISC |
|
1469 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_disc = |
|
1470 {mng_it_mng, mng_create_none, 0, 0, |
|
1471 MNG_NULL, MNG_NULL, mng_special_disc, |
|
1472 mng_fields_disc, (sizeof(mng_fields_disc) / sizeof(mng_field_descriptor)), |
|
1473 MNG_NULL, |
|
1474 MNG_DESCR_MHDR, |
|
1475 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1476 #endif |
|
1477 |
|
1478 #ifndef MNG_SKIPCHUNK_BACK |
|
1479 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_back = |
|
1480 {mng_it_mng, mng_create_none, 0, 0, |
|
1481 MNG_NULL, MNG_NULL, mng_special_back, |
|
1482 mng_fields_back, (sizeof(mng_fields_back) / sizeof(mng_field_descriptor)), |
|
1483 MNG_NULL, |
|
1484 MNG_DESCR_MHDR, |
|
1485 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1486 #endif |
|
1487 |
|
1488 #ifndef MNG_SKIPCHUNK_FRAM |
|
1489 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_fram = |
|
1490 {mng_it_mng, mng_create_none, 0, offsetof(mng_fram, bEmpty), |
|
1491 MNG_NULL, MNG_NULL, mng_special_fram, |
|
1492 mng_fields_fram, (sizeof(mng_fields_fram) / sizeof(mng_field_descriptor)), |
|
1493 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL, |
|
1494 MNG_DESCR_MHDR, |
|
1495 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1496 #endif |
|
1497 |
|
1498 #ifndef MNG_SKIPCHUNK_MOVE |
|
1499 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_move = |
|
1500 {mng_it_mng, mng_create_none, 0, 0, |
|
1501 MNG_NULL, MNG_NULL, mng_special_move, |
|
1502 mng_fields_move, (sizeof(mng_fields_move) / sizeof(mng_field_descriptor)), |
|
1503 MNG_NULL, |
|
1504 MNG_DESCR_MHDR, |
|
1505 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1506 #endif |
|
1507 |
|
1508 #ifndef MNG_SKIPCHUNK_CLIP |
|
1509 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_clip = |
|
1510 {mng_it_mng, mng_create_none, 0, 0, |
|
1511 MNG_NULL, MNG_NULL, mng_special_clip, |
|
1512 mng_fields_clip, (sizeof(mng_fields_clip) / sizeof(mng_field_descriptor)), |
|
1513 MNG_NULL, |
|
1514 MNG_DESCR_MHDR, |
|
1515 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1516 #endif |
|
1517 |
|
1518 #ifndef MNG_SKIPCHUNK_SHOW |
|
1519 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_show = |
|
1520 {mng_it_mng, mng_create_none, 0, offsetof(mng_show, bEmpty), |
|
1521 MNG_NULL, MNG_NULL, mng_special_show, |
|
1522 mng_fields_show, (sizeof(mng_fields_show) / sizeof(mng_field_descriptor)), |
|
1523 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL, |
|
1524 MNG_DESCR_MHDR, |
|
1525 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1526 #endif |
|
1527 |
|
1528 #ifndef MNG_SKIPCHUNK_TERM |
|
1529 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_term = |
|
1530 {mng_it_mng, mng_create_none, 0, 0, |
|
1531 MNG_NULL, MNG_NULL, mng_special_term, |
|
1532 mng_fields_term, (sizeof(mng_fields_term) / sizeof(mng_field_descriptor)), |
|
1533 MNG_NULL, |
|
1534 MNG_DESCR_MHDR, |
|
1535 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR | MNG_DESCR_NOTERM | MNG_DESCR_NOLOOP}; |
|
1536 #endif |
|
1537 |
|
1538 #ifndef MNG_SKIPCHUNK_SAVE |
|
1539 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_save = |
|
1540 {mng_it_mng, mng_create_none, 0, 0, |
|
1541 MNG_NULL, MNG_NULL, mng_special_save, |
|
1542 mng_fields_save, (sizeof(mng_fields_save) / sizeof(mng_field_descriptor)), |
|
1543 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL, |
|
1544 MNG_DESCR_MHDR, |
|
1545 MNG_DESCR_NOSAVE | MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1546 #endif |
|
1547 |
|
1548 #ifndef MNG_SKIPCHUNK_SEEK |
|
1549 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_seek = |
|
1550 {mng_it_mng, mng_create_none, 0, 0, |
|
1551 MNG_NULL, MNG_NULL, mng_special_seek, |
|
1552 mng_fields_seek, (sizeof(mng_fields_seek) / sizeof(mng_field_descriptor)), |
|
1553 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL, |
|
1554 MNG_DESCR_MHDR | MNG_DESCR_SAVE, |
|
1555 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1556 #endif |
|
1557 |
|
1558 #ifndef MNG_SKIPCHUNK_eXPI |
|
1559 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_expi = |
|
1560 {mng_it_mng, mng_create_none, 0, 0, |
|
1561 MNG_NULL, MNG_NULL, mng_special_expi, |
|
1562 mng_fields_expi, (sizeof(mng_fields_expi) / sizeof(mng_field_descriptor)), |
|
1563 MNG_NULL, |
|
1564 MNG_DESCR_MHDR, |
|
1565 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1566 #endif |
|
1567 |
|
1568 #ifndef MNG_SKIPCHUNK_fPRI |
|
1569 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_fpri = |
|
1570 {mng_it_mng, mng_create_none, 0, 0, |
|
1571 MNG_NULL, MNG_NULL, mng_special_fpri, |
|
1572 mng_fields_fpri, (sizeof(mng_fields_fpri) / sizeof(mng_field_descriptor)), |
|
1573 MNG_NULL, |
|
1574 MNG_DESCR_MHDR, |
|
1575 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1576 #endif |
|
1577 |
|
1578 #ifndef MNG_SKIPCHUNK_nEED |
|
1579 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_need = |
|
1580 {mng_it_mng, mng_create_none, 0, 0, |
|
1581 MNG_NULL, MNG_NULL, mng_special_need, |
|
1582 mng_fields_need, (sizeof(mng_fields_need) / sizeof(mng_field_descriptor)), |
|
1583 MNG_NULL, |
|
1584 MNG_DESCR_MHDR, |
|
1585 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1586 #endif |
|
1587 |
|
1588 #ifndef MNG_SKIPCHUNK_pHYg |
|
1589 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_phyg = |
|
1590 {mng_it_mng, mng_create_none, 0, 0, |
|
1591 MNG_NULL, MNG_NULL, mng_special_phyg, |
|
1592 mng_fields_phyg, (sizeof(mng_fields_phyg) / sizeof(mng_field_descriptor)), |
|
1593 MNG_NULL, |
|
1594 MNG_DESCR_MHDR, |
|
1595 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1596 #endif |
|
1597 |
|
1598 #ifndef MNG_NO_DELTA_PNG |
|
1599 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_dhdr = |
|
1600 {mng_it_mng, mng_create_none, 0, 0, |
|
1601 MNG_NULL, MNG_NULL, mng_special_dhdr, |
|
1602 mng_fields_dhdr, (sizeof(mng_fields_dhdr) / sizeof(mng_field_descriptor)), |
|
1603 MNG_NULL, |
|
1604 MNG_DESCR_MHDR, |
|
1605 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1606 #endif |
|
1607 |
|
1608 #ifndef MNG_NO_DELTA_PNG |
|
1609 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_prom = |
|
1610 {mng_it_mng, mng_create_none, 0, 0, |
|
1611 MNG_NULL, MNG_NULL, mng_special_prom, |
|
1612 mng_fields_prom, (sizeof(mng_fields_prom) / sizeof(mng_field_descriptor)), |
|
1613 MNG_NULL, |
|
1614 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1615 MNG_NULL}; |
|
1616 #endif |
|
1617 |
|
1618 #ifndef MNG_NO_DELTA_PNG |
|
1619 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ipng = |
|
1620 {mng_it_mng, mng_create_none, 0, 0, |
|
1621 MNG_NULL, MNG_NULL, mng_special_ipng, |
|
1622 MNG_NULL, 0, |
|
1623 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED, |
|
1624 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1625 MNG_NULL}; |
|
1626 #endif |
|
1627 |
|
1628 #ifndef MNG_NO_DELTA_PNG |
|
1629 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_pplt = |
|
1630 {mng_it_mng, mng_create_none, 0, 0, |
|
1631 MNG_NULL, MNG_NULL, mng_special_pplt, |
|
1632 mng_fields_pplt, (sizeof(mng_fields_pplt) / sizeof(mng_field_descriptor)), |
|
1633 MNG_NULL, |
|
1634 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1635 MNG_NULL}; |
|
1636 #endif |
|
1637 |
|
1638 #ifndef MNG_NO_DELTA_PNG |
|
1639 #ifdef MNG_INCLUDE_JNG |
|
1640 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ijng = |
|
1641 {mng_it_mng, mng_create_none, 0, 0, |
|
1642 MNG_NULL, MNG_NULL, mng_special_ijng, |
|
1643 MNG_NULL, 0, |
|
1644 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED, |
|
1645 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1646 MNG_NULL}; |
|
1647 #endif |
|
1648 #endif |
|
1649 |
|
1650 #ifndef MNG_NO_DELTA_PNG |
|
1651 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_drop = |
|
1652 {mng_it_mng, mng_create_none, 0, 0, |
|
1653 MNG_NULL, MNG_NULL, mng_special_drop, |
|
1654 mng_fields_drop, (sizeof(mng_fields_drop) / sizeof(mng_field_descriptor)), |
|
1655 MNG_NULL, |
|
1656 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1657 MNG_NULL}; |
|
1658 #endif |
|
1659 |
|
1660 #ifndef MNG_NO_DELTA_PNG |
|
1661 #ifndef MNG_SKIPCHUNK_DBYK |
|
1662 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_dbyk = |
|
1663 {mng_it_mng, mng_create_none, 0, 0, |
|
1664 MNG_NULL, MNG_NULL, mng_special_dbyk, |
|
1665 mng_fields_dbyk, (sizeof(mng_fields_dbyk) / sizeof(mng_field_descriptor)), |
|
1666 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED, |
|
1667 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1668 MNG_NULL}; |
|
1669 #endif |
|
1670 #endif |
|
1671 |
|
1672 #ifndef MNG_NO_DELTA_PNG |
|
1673 #ifndef MNG_SKIPCHUNK_ORDR |
|
1674 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ordr = |
|
1675 {mng_it_mng, mng_create_none, 0, 0, |
|
1676 MNG_NULL, MNG_NULL, mng_special_ordr, |
|
1677 mng_fields_ordr, (sizeof(mng_fields_ordr) / sizeof(mng_field_descriptor)), |
|
1678 MNG_NULL, |
|
1679 MNG_DESCR_MHDR | MNG_DESCR_DHDR, |
|
1680 MNG_NULL}; |
|
1681 #endif |
|
1682 #endif |
|
1683 |
|
1684 #ifndef MNG_SKIPCHUNK_MAGN |
|
1685 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_magn = |
|
1686 {mng_it_mng, mng_create_none, 0, 0, |
|
1687 MNG_NULL, MNG_NULL, mng_special_magn, |
|
1688 mng_fields_magn, (sizeof(mng_fields_magn) / sizeof(mng_field_descriptor)), |
|
1689 MNG_NULL, |
|
1690 MNG_DESCR_MHDR, |
|
1691 MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR}; |
|
1692 #endif |
|
1693 |
|
1694 #ifndef MNG_SKIPCHUNK_evNT |
|
1695 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_evnt = |
|
1696 {mng_it_mng, mng_create_none, 0, 0, |
|
1697 MNG_NULL, MNG_NULL, mng_special_evnt, |
|
1698 mng_fields_evnt, (sizeof(mng_fields_evnt) / sizeof(mng_field_descriptor)), |
|
1699 MNG_NULL, |
|
1700 MNG_DESCR_MHDR, |
|
1701 MNG_DESCR_NOSAVE}; |
|
1702 #endif |
|
1703 |
|
1704 #ifdef MNG_INCLUDE_MPNG_PROPOSAL |
|
1705 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_mpng = |
|
1706 {mng_it_mpng, mng_create_none, 0, 0, |
|
1707 MNG_NULL, MNG_NULL, mng_special_mpng, |
|
1708 mng_fields_mpng, (sizeof(mng_fields_mpng) / sizeof(mng_field_descriptor)), |
|
1709 MNG_NULL, |
|
1710 MNG_NULL, |
|
1711 MNG_DESCR_NOMHDR | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT}; |
|
1712 #endif |
|
1713 |
|
1714 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
1715 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ahdr = |
|
1716 {mng_it_ang, mng_create_none, 0, 0, |
|
1717 MNG_NULL, MNG_NULL, mng_special_ahdr, |
|
1718 mng_fields_ahdr, (sizeof(mng_fields_ahdr) / sizeof(mng_field_descriptor)), |
|
1719 MNG_NULL, |
|
1720 MNG_DESCR_IHDR, |
|
1721 MNG_DESCR_NOMHDR | MNG_DESCR_NOJHDR | MNG_DESCR_NOIDAT}; |
|
1722 |
|
1723 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_adat = |
|
1724 {mng_it_ang, mng_create_none, 0, 0, |
|
1725 MNG_NULL, MNG_NULL, mng_special_adat, |
|
1726 mng_fields_adat, (sizeof(mng_fields_adat) / sizeof(mng_field_descriptor)), |
|
1727 MNG_NULL, |
|
1728 MNG_DESCR_IHDR, |
|
1729 MNG_DESCR_NOMHDR | MNG_DESCR_NOJHDR}; |
|
1730 #endif |
|
1731 |
|
1732 /* ************************************************************************** */ |
|
1733 /* ************************************************************************** */ |
|
1734 /* the good ol' unknown babe */ |
|
1735 |
|
1736 MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_unknown = |
|
1737 {mng_it_png, mng_create_none, 0, 0, |
|
1738 MNG_NULL, MNG_NULL, mng_special_unknown, |
|
1739 mng_fields_unknown, (sizeof(mng_fields_unknown) / sizeof(mng_field_descriptor)), |
|
1740 MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED, |
|
1741 MNG_NULL, |
|
1742 MNG_NULL}; |
|
1743 |
|
1744 /* ************************************************************************** */ |
|
1745 /* ************************************************************************** */ |
|
1746 |
|
1747 MNG_LOCAL mng_chunk_header mng_chunk_unknown = |
|
1748 {MNG_UINT_HUH, mng_init_general, mng_free_unknown, |
|
1749 mng_read_general, mng_write_unknown, mng_assign_unknown, |
|
1750 0, 0, sizeof(mng_unknown_chunk), &mng_chunk_descr_unknown}; |
|
1751 |
|
1752 /* ************************************************************************** */ |
|
1753 |
|
1754 /* the table-idea & binary search code was adapted from |
|
1755 libpng 1.1.0 (pngread.c) */ |
|
1756 /* NOTE1: the table must remain sorted by chunkname, otherwise the binary |
|
1757 search will break !!! (ps. watch upper-/lower-case chunknames !!) */ |
|
1758 /* NOTE2: the layout must remain equal to the header part of all the |
|
1759 chunk-structures (yes, that means even the pNext and pPrev fields; |
|
1760 it's wasting a bit of space, but hey, the code is a lot easier) */ |
|
1761 |
|
1762 MNG_LOCAL mng_chunk_header mng_chunk_table [] = |
|
1763 { |
|
1764 #ifndef MNG_SKIPCHUNK_BACK |
|
1765 {MNG_UINT_BACK, mng_init_general, mng_free_general, mng_read_general, mng_write_back, mng_assign_general, 0, 0, sizeof(mng_back), &mng_chunk_descr_back}, |
|
1766 #endif |
|
1767 #ifndef MNG_SKIPCHUNK_BASI |
|
1768 {MNG_UINT_BASI, mng_init_general, mng_free_general, mng_read_general, mng_write_basi, mng_assign_general, 0, 0, sizeof(mng_basi), &mng_chunk_descr_basi}, |
|
1769 #endif |
|
1770 #ifndef MNG_SKIPCHUNK_CLIP |
|
1771 {MNG_UINT_CLIP, mng_init_general, mng_free_general, mng_read_general, mng_write_clip, mng_assign_general, 0, 0, sizeof(mng_clip), &mng_chunk_descr_clip}, |
|
1772 #endif |
|
1773 #ifndef MNG_SKIPCHUNK_CLON |
|
1774 {MNG_UINT_CLON, mng_init_general, mng_free_general, mng_read_general, mng_write_clon, mng_assign_general, 0, 0, sizeof(mng_clon), &mng_chunk_descr_clon}, |
|
1775 #endif |
|
1776 #ifndef MNG_NO_DELTA_PNG |
|
1777 #ifndef MNG_SKIPCHUNK_DBYK |
|
1778 {MNG_UINT_DBYK, mng_init_general, mng_free_dbyk, mng_read_general, mng_write_dbyk, mng_assign_dbyk, 0, 0, sizeof(mng_dbyk), &mng_chunk_descr_dbyk}, |
|
1779 #endif |
|
1780 #endif |
|
1781 #ifndef MNG_SKIPCHUNK_DEFI |
|
1782 {MNG_UINT_DEFI, mng_init_general, mng_free_general, mng_read_general, mng_write_defi, mng_assign_general, 0, 0, sizeof(mng_defi), &mng_chunk_descr_defi}, |
|
1783 #endif |
|
1784 #ifndef MNG_NO_DELTA_PNG |
|
1785 {MNG_UINT_DHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_dhdr, mng_assign_general, 0, 0, sizeof(mng_dhdr), &mng_chunk_descr_dhdr}, |
|
1786 #endif |
|
1787 #ifndef MNG_SKIPCHUNK_DISC |
|
1788 {MNG_UINT_DISC, mng_init_general, mng_free_disc, mng_read_general, mng_write_disc, mng_assign_disc, 0, 0, sizeof(mng_disc), &mng_chunk_descr_disc}, |
|
1789 #endif |
|
1790 #ifndef MNG_NO_DELTA_PNG |
|
1791 #ifndef MNG_SKIPCHUNK_DROP |
|
1792 {MNG_UINT_DROP, mng_init_general, mng_free_drop, mng_read_general, mng_write_drop, mng_assign_drop, 0, 0, sizeof(mng_drop), &mng_chunk_descr_drop}, |
|
1793 #endif |
|
1794 #endif |
|
1795 #ifndef MNG_SKIPCHUNK_LOOP |
|
1796 {MNG_UINT_ENDL, mng_init_general, mng_free_general, mng_read_general, mng_write_endl, mng_assign_general, 0, 0, sizeof(mng_endl), &mng_chunk_descr_endl}, |
|
1797 #endif |
|
1798 #ifndef MNG_SKIPCHUNK_FRAM |
|
1799 {MNG_UINT_FRAM, mng_init_general, mng_free_fram, mng_read_general, mng_write_fram, mng_assign_fram, 0, 0, sizeof(mng_fram), &mng_chunk_descr_fram}, |
|
1800 #endif |
|
1801 {MNG_UINT_IDAT, mng_init_general, mng_free_idat, mng_read_general, mng_write_idat, mng_assign_idat, 0, 0, sizeof(mng_idat), &mng_chunk_descr_idat}, /* 12-th element! */ |
|
1802 {MNG_UINT_IEND, mng_init_general, mng_free_general, mng_read_general, mng_write_iend, mng_assign_general, 0, 0, sizeof(mng_iend), &mng_chunk_descr_iend}, |
|
1803 {MNG_UINT_IHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_ihdr, mng_assign_general, 0, 0, sizeof(mng_ihdr), &mng_chunk_descr_ihdr}, |
|
1804 #ifndef MNG_NO_DELTA_PNG |
|
1805 #ifdef MNG_INCLUDE_JNG |
|
1806 {MNG_UINT_IJNG, mng_init_general, mng_free_general, mng_read_general, mng_write_ijng, mng_assign_general, 0, 0, sizeof(mng_ijng), &mng_chunk_descr_ijng}, |
|
1807 #endif |
|
1808 {MNG_UINT_IPNG, mng_init_general, mng_free_general, mng_read_general, mng_write_ipng, mng_assign_general, 0, 0, sizeof(mng_ipng), &mng_chunk_descr_ipng}, |
|
1809 #endif |
|
1810 #ifdef MNG_INCLUDE_JNG |
|
1811 {MNG_UINT_JDAA, mng_init_general, mng_free_jdaa, mng_read_general, mng_write_jdaa, mng_assign_jdaa, 0, 0, sizeof(mng_jdaa), &mng_chunk_descr_jdaa}, |
|
1812 {MNG_UINT_JDAT, mng_init_general, mng_free_jdat, mng_read_general, mng_write_jdat, mng_assign_jdat, 0, 0, sizeof(mng_jdat), &mng_chunk_descr_jdat}, |
|
1813 {MNG_UINT_JHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_jhdr, mng_assign_general, 0, 0, sizeof(mng_jhdr), &mng_chunk_descr_jhdr}, |
|
1814 {MNG_UINT_JSEP, mng_init_general, mng_free_general, mng_read_general, mng_write_jsep, mng_assign_general, 0, 0, sizeof(mng_jsep), &mng_chunk_descr_jsep}, |
|
1815 {MNG_UINT_JdAA, mng_init_general, mng_free_jdaa, mng_read_general, mng_write_jdaa, mng_assign_jdaa, 0, 0, sizeof(mng_jdaa), &mng_chunk_descr_jdaa}, |
|
1816 #endif |
|
1817 #ifndef MNG_SKIPCHUNK_LOOP |
|
1818 {MNG_UINT_LOOP, mng_init_general, mng_free_loop, mng_read_general, mng_write_loop, mng_assign_loop, 0, 0, sizeof(mng_loop), &mng_chunk_descr_loop}, |
|
1819 #endif |
|
1820 #ifndef MNG_SKIPCHUNK_MAGN |
|
1821 {MNG_UINT_MAGN, mng_init_general, mng_free_general, mng_read_general, mng_write_magn, mng_assign_general, 0, 0, sizeof(mng_magn), &mng_chunk_descr_magn}, |
|
1822 #endif |
|
1823 {MNG_UINT_MEND, mng_init_general, mng_free_general, mng_read_general, mng_write_mend, mng_assign_general, 0, 0, sizeof(mng_mend), &mng_chunk_descr_mend}, |
|
1824 {MNG_UINT_MHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_mhdr, mng_assign_general, 0, 0, sizeof(mng_mhdr), &mng_chunk_descr_mhdr}, |
|
1825 #ifndef MNG_SKIPCHUNK_MOVE |
|
1826 {MNG_UINT_MOVE, mng_init_general, mng_free_general, mng_read_general, mng_write_move, mng_assign_general, 0, 0, sizeof(mng_move), &mng_chunk_descr_move}, |
|
1827 #endif |
|
1828 #ifndef MNG_NO_DELTA_PNG |
|
1829 #ifndef MNG_SKIPCHUNK_ORDR |
|
1830 {MNG_UINT_ORDR, mng_init_general, mng_free_ordr, mng_read_general, mng_write_ordr, mng_assign_ordr, 0, 0, sizeof(mng_ordr), &mng_chunk_descr_ordr}, |
|
1831 #endif |
|
1832 #endif |
|
1833 #ifndef MNG_SKIPCHUNK_PAST |
|
1834 {MNG_UINT_PAST, mng_init_general, mng_free_past, mng_read_general, mng_write_past, mng_assign_past, 0, 0, sizeof(mng_past), &mng_chunk_descr_past}, |
|
1835 #endif |
|
1836 {MNG_UINT_PLTE, mng_init_general, mng_free_general, mng_read_general, mng_write_plte, mng_assign_general, 0, 0, sizeof(mng_plte), &mng_chunk_descr_plte}, |
|
1837 #ifndef MNG_NO_DELTA_PNG |
|
1838 {MNG_UINT_PPLT, mng_init_general, mng_free_general, mng_read_general, mng_write_pplt, mng_assign_general, 0, 0, sizeof(mng_pplt), &mng_chunk_descr_pplt}, |
|
1839 {MNG_UINT_PROM, mng_init_general, mng_free_general, mng_read_general, mng_write_prom, mng_assign_general, 0, 0, sizeof(mng_prom), &mng_chunk_descr_prom}, |
|
1840 #endif |
|
1841 #ifndef MNG_SKIPCHUNK_SAVE |
|
1842 {MNG_UINT_SAVE, mng_init_general, mng_free_save, mng_read_general, mng_write_save, mng_assign_save, 0, 0, sizeof(mng_save), &mng_chunk_descr_save}, |
|
1843 #endif |
|
1844 #ifndef MNG_SKIPCHUNK_SEEK |
|
1845 {MNG_UINT_SEEK, mng_init_general, mng_free_seek, mng_read_general, mng_write_seek, mng_assign_seek, 0, 0, sizeof(mng_seek), &mng_chunk_descr_seek}, |
|
1846 #endif |
|
1847 #ifndef MNG_SKIPCHUNK_SHOW |
|
1848 {MNG_UINT_SHOW, mng_init_general, mng_free_general, mng_read_general, mng_write_show, mng_assign_general, 0, 0, sizeof(mng_show), &mng_chunk_descr_show}, |
|
1849 #endif |
|
1850 #ifndef MNG_SKIPCHUNK_TERM |
|
1851 {MNG_UINT_TERM, mng_init_general, mng_free_general, mng_read_general, mng_write_term, mng_assign_general, 0, 0, sizeof(mng_term), &mng_chunk_descr_term}, |
|
1852 #endif |
|
1853 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
1854 {MNG_UINT_adAT, mng_init_general, mng_free_adat, mng_read_general, mng_write_adat, mng_assign_adat, 0, 0, sizeof(mng_adat), &mng_chunk_descr_adat}, |
|
1855 {MNG_UINT_ahDR, mng_init_general, mng_free_general, mng_read_general, mng_write_ahdr, mng_assign_ahdr, 0, 0, sizeof(mng_ahdr), &mng_chunk_descr_ahdr}, |
|
1856 #endif |
|
1857 #ifndef MNG_SKIPCHUNK_bKGD |
|
1858 {MNG_UINT_bKGD, mng_init_general, mng_free_general, mng_read_general, mng_write_bkgd, mng_assign_general, 0, 0, sizeof(mng_bkgd), &mng_chunk_descr_bkgd}, |
|
1859 #endif |
|
1860 #ifndef MNG_SKIPCHUNK_cHRM |
|
1861 {MNG_UINT_cHRM, mng_init_general, mng_free_general, mng_read_general, mng_write_chrm, mng_assign_general, 0, 0, sizeof(mng_chrm), &mng_chunk_descr_chrm}, |
|
1862 #endif |
|
1863 #ifndef MNG_SKIPCHUNK_eXPI |
|
1864 {MNG_UINT_eXPI, mng_init_general, mng_free_expi, mng_read_general, mng_write_expi, mng_assign_expi, 0, 0, sizeof(mng_expi), &mng_chunk_descr_expi}, |
|
1865 #endif |
|
1866 #ifndef MNG_SKIPCHUNK_evNT |
|
1867 {MNG_UINT_evNT, mng_init_general, mng_free_evnt, mng_read_general, mng_write_evnt, mng_assign_evnt, 0, 0, sizeof(mng_evnt), &mng_chunk_descr_evnt}, |
|
1868 #endif |
|
1869 #ifndef MNG_SKIPCHUNK_fPRI |
|
1870 {MNG_UINT_fPRI, mng_init_general, mng_free_general, mng_read_general, mng_write_fpri, mng_assign_general, 0, 0, sizeof(mng_fpri), &mng_chunk_descr_fpri}, |
|
1871 #endif |
|
1872 #ifndef MNG_SKIPCHUNK_gAMA |
|
1873 {MNG_UINT_gAMA, mng_init_general, mng_free_general, mng_read_general, mng_write_gama, mng_assign_general, 0, 0, sizeof(mng_gama), &mng_chunk_descr_gama}, |
|
1874 #endif |
|
1875 #ifndef MNG_SKIPCHUNK_hIST |
|
1876 {MNG_UINT_hIST, mng_init_general, mng_free_general, mng_read_general, mng_write_hist, mng_assign_general, 0, 0, sizeof(mng_hist), &mng_chunk_descr_hist}, |
|
1877 #endif |
|
1878 #ifndef MNG_SKIPCHUNK_iCCP |
|
1879 {MNG_UINT_iCCP, mng_init_general, mng_free_iccp, mng_read_general, mng_write_iccp, mng_assign_iccp, 0, 0, sizeof(mng_iccp), &mng_chunk_descr_iccp}, |
|
1880 #endif |
|
1881 #ifndef MNG_SKIPCHUNK_iTXt |
|
1882 {MNG_UINT_iTXt, mng_init_general, mng_free_itxt, mng_read_general, mng_write_itxt, mng_assign_itxt, 0, 0, sizeof(mng_itxt), &mng_chunk_descr_itxt}, |
|
1883 #endif |
|
1884 #ifdef MNG_INCLUDE_MPNG_PROPOSAL |
|
1885 {MNG_UINT_mpNG, mng_init_general, mng_free_mpng, mng_read_general, mng_write_mpng, mng_assign_mpng, 0, 0, sizeof(mng_mpng), &mng_chunk_descr_mpng}, |
|
1886 #endif |
|
1887 #ifndef MNG_SKIPCHUNK_nEED |
|
1888 {MNG_UINT_nEED, mng_init_general, mng_free_need, mng_read_general, mng_write_need, mng_assign_need, 0, 0, sizeof(mng_need), &mng_chunk_descr_need}, |
|
1889 #endif |
|
1890 /* TODO: {MNG_UINT_oFFs, 0, 0, 0, 0, 0, 0}, */ |
|
1891 /* TODO: {MNG_UINT_pCAL, 0, 0, 0, 0, 0, 0}, */ |
|
1892 #ifndef MNG_SKIPCHUNK_pHYg |
|
1893 {MNG_UINT_pHYg, mng_init_general, mng_free_general, mng_read_general, mng_write_phyg, mng_assign_general, 0, 0, sizeof(mng_phyg), &mng_chunk_descr_phyg}, |
|
1894 #endif |
|
1895 #ifndef MNG_SKIPCHUNK_pHYs |
|
1896 {MNG_UINT_pHYs, mng_init_general, mng_free_general, mng_read_general, mng_write_phys, mng_assign_general, 0, 0, sizeof(mng_phys), &mng_chunk_descr_phys}, |
|
1897 #endif |
|
1898 #ifndef MNG_SKIPCHUNK_sBIT |
|
1899 {MNG_UINT_sBIT, mng_init_general, mng_free_general, mng_read_general, mng_write_sbit, mng_assign_general, 0, 0, sizeof(mng_sbit), &mng_chunk_descr_sbit}, |
|
1900 #endif |
|
1901 /* TODO: {MNG_UINT_sCAL, 0, 0, 0, 0, 0, 0}, */ |
|
1902 #ifndef MNG_SKIPCHUNK_sPLT |
|
1903 {MNG_UINT_sPLT, mng_init_general, mng_free_splt, mng_read_general, mng_write_splt, mng_assign_splt, 0, 0, sizeof(mng_splt), &mng_chunk_descr_splt}, |
|
1904 #endif |
|
1905 {MNG_UINT_sRGB, mng_init_general, mng_free_general, mng_read_general, mng_write_srgb, mng_assign_general, 0, 0, sizeof(mng_srgb), &mng_chunk_descr_srgb}, |
|
1906 #ifndef MNG_SKIPCHUNK_tEXt |
|
1907 {MNG_UINT_tEXt, mng_init_general, mng_free_text, mng_read_general, mng_write_text, mng_assign_text, 0, 0, sizeof(mng_text), &mng_chunk_descr_text}, |
|
1908 #endif |
|
1909 #ifndef MNG_SKIPCHUNK_tIME |
|
1910 {MNG_UINT_tIME, mng_init_general, mng_free_general, mng_read_general, mng_write_time, mng_assign_general, 0, 0, sizeof(mng_time), &mng_chunk_descr_time}, |
|
1911 #endif |
|
1912 {MNG_UINT_tRNS, mng_init_general, mng_free_general, mng_read_general, mng_write_trns, mng_assign_general, 0, 0, sizeof(mng_trns), &mng_chunk_descr_trns}, |
|
1913 #ifndef MNG_SKIPCHUNK_zTXt |
|
1914 {MNG_UINT_zTXt, mng_init_general, mng_free_ztxt, mng_read_general, mng_write_ztxt, mng_assign_ztxt, 0, 0, sizeof(mng_ztxt), &mng_chunk_descr_ztxt}, |
|
1915 #endif |
|
1916 }; |
|
1917 |
|
1918 /* ************************************************************************** */ |
|
1919 /* ************************************************************************** */ |
|
1920 |
|
1921 void mng_get_chunkheader (mng_chunkid iChunkname, |
|
1922 mng_chunk_headerp pResult) |
|
1923 { |
|
1924 /* binary search variables */ |
|
1925 mng_int32 iTop, iLower, iUpper, iMiddle; |
|
1926 mng_chunk_headerp pEntry; /* pointer to found entry */ |
|
1927 /* determine max index of table */ |
|
1928 iTop = (sizeof (mng_chunk_table) / sizeof (mng_chunk_table [0])) - 1; |
|
1929 |
|
1930 /* binary search; with 54 chunks, worst-case is 7 comparisons */ |
|
1931 iLower = 0; |
|
1932 #ifndef MNG_NO_DELTA_PNG |
|
1933 iMiddle = 11; /* start with the IDAT entry */ |
|
1934 #else |
|
1935 iMiddle = 8; |
|
1936 #endif |
|
1937 iUpper = iTop; |
|
1938 pEntry = 0; /* no goods yet! */ |
|
1939 |
|
1940 do /* the binary search itself */ |
|
1941 { |
|
1942 if (mng_chunk_table [iMiddle].iChunkname < iChunkname) |
|
1943 iLower = iMiddle + 1; |
|
1944 else if (mng_chunk_table [iMiddle].iChunkname > iChunkname) |
|
1945 iUpper = iMiddle - 1; |
|
1946 else |
|
1947 { |
|
1948 pEntry = &mng_chunk_table [iMiddle]; |
|
1949 break; |
|
1950 } |
|
1951 iMiddle = (iLower + iUpper) >> 1; |
|
1952 } |
|
1953 while (iLower <= iUpper); |
|
1954 |
|
1955 if (!pEntry) /* unknown chunk ? */ |
|
1956 pEntry = &mng_chunk_unknown; /* make it so! */ |
|
1957 |
|
1958 MNG_COPY (pResult, pEntry, sizeof(mng_chunk_header)); |
|
1959 |
|
1960 return; |
|
1961 } |
|
1962 |
|
1963 /* ************************************************************************** */ |
|
1964 /* ************************************************************************** */ |
|
1965 /* PNG chunks */ |
|
1966 |
|
1967 MNG_C_SPECIALFUNC (mng_special_ihdr) |
|
1968 { |
|
1969 pData->bHasIHDR = MNG_TRUE; /* indicate IHDR is present */ |
|
1970 /* and store interesting fields */ |
|
1971 if ((!pData->bHasDHDR) || (pData->iDeltatype == MNG_DELTATYPE_NOCHANGE)) |
|
1972 { |
|
1973 pData->iDatawidth = ((mng_ihdrp)pChunk)->iWidth; |
|
1974 pData->iDataheight = ((mng_ihdrp)pChunk)->iHeight; |
|
1975 } |
|
1976 |
|
1977 pData->iBitdepth = ((mng_ihdrp)pChunk)->iBitdepth; |
|
1978 pData->iColortype = ((mng_ihdrp)pChunk)->iColortype; |
|
1979 pData->iCompression = ((mng_ihdrp)pChunk)->iCompression; |
|
1980 pData->iFilter = ((mng_ihdrp)pChunk)->iFilter; |
|
1981 pData->iInterlace = ((mng_ihdrp)pChunk)->iInterlace; |
|
1982 |
|
1983 #if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT) |
|
1984 pData->iPNGmult = 1; |
|
1985 pData->iPNGdepth = pData->iBitdepth; |
|
1986 #endif |
|
1987 |
|
1988 #ifdef MNG_NO_1_2_4BIT_SUPPORT |
|
1989 if (pData->iBitdepth < 8) |
|
1990 pData->iBitdepth = 8; |
|
1991 #endif |
|
1992 |
|
1993 #ifdef MNG_NO_16BIT_SUPPORT |
|
1994 if (pData->iBitdepth > 8) |
|
1995 { |
|
1996 pData->iBitdepth = 8; |
|
1997 pData->iPNGmult = 2; |
|
1998 } |
|
1999 #endif |
|
2000 |
|
2001 if ((pData->iBitdepth != 8) /* parameter validity checks */ |
|
2002 #ifndef MNG_NO_1_2_4BIT_SUPPORT |
|
2003 && (pData->iBitdepth != 1) && |
|
2004 (pData->iBitdepth != 2) && |
|
2005 (pData->iBitdepth != 4) |
|
2006 #endif |
|
2007 #ifndef MNG_NO_16BIT_SUPPORT |
|
2008 && (pData->iBitdepth != 16) |
|
2009 #endif |
|
2010 ) |
|
2011 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
2012 |
|
2013 if ((pData->iColortype != MNG_COLORTYPE_GRAY ) && |
|
2014 (pData->iColortype != MNG_COLORTYPE_RGB ) && |
|
2015 (pData->iColortype != MNG_COLORTYPE_INDEXED) && |
|
2016 (pData->iColortype != MNG_COLORTYPE_GRAYA ) && |
|
2017 (pData->iColortype != MNG_COLORTYPE_RGBA ) ) |
|
2018 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE); |
|
2019 |
|
2020 if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8)) |
|
2021 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
2022 |
|
2023 if (((pData->iColortype == MNG_COLORTYPE_RGB ) || |
|
2024 (pData->iColortype == MNG_COLORTYPE_GRAYA ) || |
|
2025 (pData->iColortype == MNG_COLORTYPE_RGBA ) ) && |
|
2026 (pData->iBitdepth < 8 ) ) |
|
2027 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
2028 |
|
2029 if (pData->iCompression != MNG_COMPRESSION_DEFLATE) |
|
2030 MNG_ERROR (pData, MNG_INVALIDCOMPRESS); |
|
2031 |
|
2032 #if defined(FILTER192) || defined(FILTER193) |
|
2033 if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) && |
|
2034 #if defined(FILTER192) && defined(FILTER193) |
|
2035 (pData->iFilter != MNG_FILTER_DIFFERING) && |
|
2036 (pData->iFilter != MNG_FILTER_NOFILTER ) ) |
|
2037 #else |
|
2038 #ifdef FILTER192 |
|
2039 (pData->iFilter != MNG_FILTER_DIFFERING) ) |
|
2040 #else |
|
2041 (pData->iFilter != MNG_FILTER_NOFILTER ) ) |
|
2042 #endif |
|
2043 #endif |
|
2044 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
2045 #else |
|
2046 if (pData->iFilter) |
|
2047 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
2048 #endif |
|
2049 |
|
2050 if ((pData->iInterlace != MNG_INTERLACE_NONE ) && |
|
2051 (pData->iInterlace != MNG_INTERLACE_ADAM7) ) |
|
2052 MNG_ERROR (pData, MNG_INVALIDINTERLACE); |
|
2053 |
|
2054 #ifdef MNG_SUPPORT_DISPLAY |
|
2055 #ifndef MNG_NO_DELTA_PNG |
|
2056 if (pData->bHasDHDR) /* check the colortype for delta-images ! */ |
|
2057 { |
|
2058 mng_imagedatap pBuf = ((mng_imagep)pData->pObjzero)->pImgbuf; |
|
2059 |
|
2060 if (pData->iColortype != pBuf->iColortype) |
|
2061 { |
|
2062 if ( ( (pData->iColortype != MNG_COLORTYPE_INDEXED) || |
|
2063 (pBuf->iColortype == MNG_COLORTYPE_GRAY ) ) && |
|
2064 ( (pData->iColortype != MNG_COLORTYPE_GRAY ) || |
|
2065 (pBuf->iColortype == MNG_COLORTYPE_INDEXED) ) ) |
|
2066 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE); |
|
2067 } |
|
2068 } |
|
2069 #endif |
|
2070 #endif |
|
2071 |
|
2072 if (!pData->bHasheader) /* first chunk ? */ |
|
2073 { |
|
2074 pData->bHasheader = MNG_TRUE; /* we've got a header */ |
|
2075 pData->eImagetype = mng_it_png; /* then this must be a PNG */ |
|
2076 pData->iWidth = pData->iDatawidth; |
|
2077 pData->iHeight = pData->iDataheight; |
|
2078 /* predict alpha-depth ! */ |
|
2079 if ((pData->iColortype == MNG_COLORTYPE_GRAYA ) || |
|
2080 (pData->iColortype == MNG_COLORTYPE_RGBA ) ) |
|
2081 pData->iAlphadepth = pData->iBitdepth; |
|
2082 else |
|
2083 if (pData->iColortype == MNG_COLORTYPE_INDEXED) |
|
2084 pData->iAlphadepth = 8; /* worst case scenario */ |
|
2085 else |
|
2086 pData->iAlphadepth = 1; /* Possible tRNS cheap binary transparency */ |
|
2087 /* fits on maximum canvas ? */ |
|
2088 if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight)) |
|
2089 MNG_WARNING (pData, MNG_IMAGETOOLARGE); |
|
2090 |
|
2091 #if !defined(MNG_INCLUDE_MPNG_PROPOSAL) || !defined(MNG_SUPPORT_DISPLAY) |
|
2092 if (pData->fProcessheader) /* inform the app ? */ |
|
2093 if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight)) |
|
2094 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
2095 #endif |
|
2096 } |
|
2097 |
|
2098 if (!pData->bHasDHDR) |
|
2099 pData->iImagelevel++; /* one level deeper */ |
|
2100 |
|
2101 #ifdef MNG_SUPPORT_DISPLAY |
|
2102 return mng_process_display_ihdr (pData); |
|
2103 #else |
|
2104 return MNG_NOERROR; |
|
2105 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2106 } |
|
2107 |
|
2108 /* ************************************************************************** */ |
|
2109 |
|
2110 MNG_F_SPECIALFUNC (mng_debunk_plte) |
|
2111 { |
|
2112 mng_pltep pPLTE = (mng_pltep)pChunk; |
|
2113 mng_uint32 iRawlen = *piRawlen; |
|
2114 mng_uint8p pRawdata = *ppRawdata; |
|
2115 /* length must be multiple of 3 */ |
|
2116 if (((iRawlen % 3) != 0) || (iRawlen > 768)) |
|
2117 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2118 /* this is the exact length */ |
|
2119 pPLTE->iEntrycount = iRawlen / 3; |
|
2120 |
|
2121 MNG_COPY (pPLTE->aEntries, pRawdata, iRawlen); |
|
2122 |
|
2123 *piRawlen = 0; |
|
2124 |
|
2125 return MNG_NOERROR; |
|
2126 } |
|
2127 |
|
2128 /* ************************************************************************** */ |
|
2129 |
|
2130 MNG_C_SPECIALFUNC (mng_special_plte) |
|
2131 { /* multiple PLTE only inside BASI */ |
|
2132 if ((pData->bHasPLTE) && (!pData->bHasBASI)) |
|
2133 MNG_ERROR (pData, MNG_MULTIPLEERROR); |
|
2134 |
|
2135 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2136 { /* only allowed for indexed-color or |
|
2137 rgb(a)-color! */ |
|
2138 if ((pData->iColortype != MNG_COLORTYPE_RGB ) && |
|
2139 (pData->iColortype != MNG_COLORTYPE_INDEXED) && |
|
2140 (pData->iColortype != MNG_COLORTYPE_RGBA ) ) |
|
2141 MNG_ERROR (pData, MNG_CHUNKNOTALLOWED); |
|
2142 /* empty only allowed if global present */ |
|
2143 if ((((mng_pltep)pChunk)->bEmpty) && (!pData->bHasglobalPLTE)) |
|
2144 MNG_ERROR (pData, MNG_CANNOTBEEMPTY); |
|
2145 } |
|
2146 else |
|
2147 { |
|
2148 if (((mng_pltep)pChunk)->bEmpty) /* cannot be empty as global! */ |
|
2149 MNG_ERROR (pData, MNG_CANNOTBEEMPTY); |
|
2150 } |
|
2151 |
|
2152 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2153 pData->bHasPLTE = MNG_TRUE; /* got it! */ |
|
2154 else |
|
2155 pData->bHasglobalPLTE = MNG_TRUE; |
|
2156 |
|
2157 pData->iPLTEcount = ((mng_pltep)pChunk)->iEntrycount; |
|
2158 |
|
2159 #ifdef MNG_SUPPORT_DISPLAY |
|
2160 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2161 { |
|
2162 mng_imagep pImage; |
|
2163 mng_imagedatap pBuf; |
|
2164 |
|
2165 #ifndef MNG_NO_DELTA_PNG |
|
2166 if (pData->bHasDHDR) /* processing delta-image ? */ |
|
2167 { /* store in object 0 !!! */ |
|
2168 pImage = (mng_imagep)pData->pObjzero; |
|
2169 pBuf = pImage->pImgbuf; |
|
2170 pBuf->bHasPLTE = MNG_TRUE; /* it's definitely got a PLTE now */ |
|
2171 pBuf->iPLTEcount = ((mng_pltep)pChunk)->iEntrycount; |
|
2172 MNG_COPY (pBuf->aPLTEentries, ((mng_pltep)pChunk)->aEntries, |
|
2173 sizeof (pBuf->aPLTEentries)); |
|
2174 } |
|
2175 else |
|
2176 #endif |
|
2177 { /* get the current object */ |
|
2178 pImage = (mng_imagep)pData->pCurrentobj; |
|
2179 if (!pImage) /* no object then dump it in obj 0 */ |
|
2180 pImage = (mng_imagep)pData->pObjzero; |
|
2181 |
|
2182 pBuf = pImage->pImgbuf; /* address the object buffer */ |
|
2183 pBuf->bHasPLTE = MNG_TRUE; /* and tell it it's got a PLTE now */ |
|
2184 |
|
2185 if (((mng_pltep)pChunk)->bEmpty) /* if empty, inherit from global */ |
|
2186 { |
|
2187 pBuf->iPLTEcount = pData->iGlobalPLTEcount; |
|
2188 MNG_COPY (pBuf->aPLTEentries, pData->aGlobalPLTEentries, |
|
2189 sizeof (pBuf->aPLTEentries)); |
|
2190 |
|
2191 if (pData->bHasglobalTRNS) /* also copy global tRNS ? */ |
|
2192 { |
|
2193 mng_uint32 iRawlen2 = pData->iGlobalTRNSrawlen; |
|
2194 mng_uint8p pRawdata2 = (mng_uint8p)(pData->aGlobalTRNSrawdata); |
|
2195 /* indicate tRNS available */ |
|
2196 pBuf->bHasTRNS = MNG_TRUE; |
|
2197 /* global length oke ? */ |
|
2198 if ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount)) |
|
2199 MNG_ERROR (pData, MNG_GLOBALLENGTHERR); |
|
2200 /* copy it */ |
|
2201 pBuf->iTRNScount = iRawlen2; |
|
2202 MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2); |
|
2203 } |
|
2204 } |
|
2205 else |
|
2206 { /* store fields for future reference */ |
|
2207 pBuf->iPLTEcount = ((mng_pltep)pChunk)->iEntrycount; |
|
2208 MNG_COPY (pBuf->aPLTEentries, ((mng_pltep)pChunk)->aEntries, |
|
2209 sizeof (pBuf->aPLTEentries)); |
|
2210 } |
|
2211 } |
|
2212 } |
|
2213 else /* store as global */ |
|
2214 { |
|
2215 pData->iGlobalPLTEcount = ((mng_pltep)pChunk)->iEntrycount; |
|
2216 MNG_COPY (pData->aGlobalPLTEentries, ((mng_pltep)pChunk)->aEntries, |
|
2217 sizeof (pData->aGlobalPLTEentries)); |
|
2218 /* create an animation object */ |
|
2219 return mng_create_ani_plte (pData); |
|
2220 } |
|
2221 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2222 |
|
2223 return MNG_NOERROR; /* done */ |
|
2224 } |
|
2225 |
|
2226 /* ************************************************************************** */ |
|
2227 |
|
2228 MNG_C_SPECIALFUNC (mng_special_idat) |
|
2229 { |
|
2230 #ifdef MNG_INCLUDE_JNG |
|
2231 if ((pData->bHasJHDR) && |
|
2232 (pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE)) |
|
2233 MNG_ERROR (pData, MNG_SEQUENCEERROR); |
|
2234 #endif |
|
2235 /* not allowed for deltatype NO_CHANGE */ |
|
2236 #ifndef MNG_NO_DELTA_PNG |
|
2237 if ((pData->bHasDHDR) && ((pData->iDeltatype == MNG_DELTATYPE_NOCHANGE))) |
|
2238 MNG_ERROR (pData, MNG_CHUNKNOTALLOWED); |
|
2239 #endif |
|
2240 /* can only be empty in BASI-block! */ |
|
2241 if ((((mng_idatp)pChunk)->bEmpty) && (!pData->bHasBASI)) |
|
2242 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2243 /* indexed-color requires PLTE */ |
|
2244 if ((pData->bHasIHDR) && (pData->iColortype == 3) && (!pData->bHasPLTE)) |
|
2245 MNG_ERROR (pData, MNG_PLTEMISSING); |
|
2246 |
|
2247 pData->bHasIDAT = MNG_TRUE; /* got some IDAT now, don't we */ |
|
2248 |
|
2249 return MNG_NOERROR; /* done */ |
|
2250 } |
|
2251 |
|
2252 /* ************************************************************************** */ |
|
2253 |
|
2254 MNG_C_SPECIALFUNC (mng_special_iend) |
|
2255 { /* IHDR-block requires IDAT */ |
|
2256 if ((pData->bHasIHDR) && (!pData->bHasIDAT)) |
|
2257 MNG_ERROR (pData, MNG_IDATMISSING); |
|
2258 |
|
2259 pData->iImagelevel--; /* one level up */ |
|
2260 |
|
2261 #ifdef MNG_SUPPORT_DISPLAY |
|
2262 { /* create an animation object */ |
|
2263 mng_retcode iRetcode = mng_create_ani_image (pData); |
|
2264 if (iRetcode) /* on error bail out */ |
|
2265 return iRetcode; |
|
2266 /* display processing */ |
|
2267 iRetcode = mng_process_display_iend (pData); |
|
2268 if (iRetcode) /* on error bail out */ |
|
2269 return iRetcode; |
|
2270 } |
|
2271 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2272 |
|
2273 #ifdef MNG_SUPPORT_DISPLAY |
|
2274 if (!pData->bTimerset) /* reset only if not broken !!! */ |
|
2275 { |
|
2276 #endif |
|
2277 /* IEND signals the end for most ... */ |
|
2278 pData->bHasIHDR = MNG_FALSE; |
|
2279 pData->bHasBASI = MNG_FALSE; |
|
2280 pData->bHasDHDR = MNG_FALSE; |
|
2281 #ifdef MNG_INCLUDE_JNG |
|
2282 pData->bHasJHDR = MNG_FALSE; |
|
2283 pData->bHasJSEP = MNG_FALSE; |
|
2284 pData->bHasJDAA = MNG_FALSE; |
|
2285 pData->bHasJDAT = MNG_FALSE; |
|
2286 #endif |
|
2287 pData->bHasPLTE = MNG_FALSE; |
|
2288 pData->bHasTRNS = MNG_FALSE; |
|
2289 pData->bHasGAMA = MNG_FALSE; |
|
2290 pData->bHasCHRM = MNG_FALSE; |
|
2291 pData->bHasSRGB = MNG_FALSE; |
|
2292 pData->bHasICCP = MNG_FALSE; |
|
2293 pData->bHasBKGD = MNG_FALSE; |
|
2294 pData->bHasIDAT = MNG_FALSE; |
|
2295 #ifdef MNG_SUPPORT_DISPLAY |
|
2296 } |
|
2297 #endif |
|
2298 |
|
2299 return MNG_NOERROR; /* done */ |
|
2300 } |
|
2301 |
|
2302 /* ************************************************************************** */ |
|
2303 |
|
2304 MNG_F_SPECIALFUNC (mng_debunk_trns) |
|
2305 { |
|
2306 mng_trnsp pTRNS = (mng_trnsp)pChunk; |
|
2307 mng_uint32 iRawlen = *piRawlen; |
|
2308 mng_uint8p pRawdata = *ppRawdata; |
|
2309 |
|
2310 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2311 { /* not global! */ |
|
2312 pTRNS->bGlobal = MNG_FALSE; |
|
2313 pTRNS->iType = pData->iColortype; |
|
2314 |
|
2315 if (iRawlen != 0) |
|
2316 { |
|
2317 switch (pData->iColortype) /* store fields */ |
|
2318 { |
|
2319 case 0: { /* gray */ |
|
2320 if (iRawlen != 2) |
|
2321 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2322 pTRNS->iGray = mng_get_uint16 (pRawdata); |
|
2323 break; |
|
2324 } |
|
2325 case 2: { /* rgb */ |
|
2326 if (iRawlen != 6) |
|
2327 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2328 pTRNS->iRed = mng_get_uint16 (pRawdata); |
|
2329 pTRNS->iGreen = mng_get_uint16 (pRawdata+2); |
|
2330 pTRNS->iBlue = mng_get_uint16 (pRawdata+4); |
|
2331 break; |
|
2332 } |
|
2333 case 3: { /* indexed */ |
|
2334 if (iRawlen > 256) |
|
2335 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2336 pTRNS->iCount = iRawlen; |
|
2337 MNG_COPY (pTRNS->aEntries, pRawdata, iRawlen); |
|
2338 break; |
|
2339 } |
|
2340 } |
|
2341 } |
|
2342 } |
|
2343 else /* it's global! */ |
|
2344 { |
|
2345 if (iRawlen == 0) |
|
2346 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2347 pTRNS->bGlobal = MNG_TRUE; |
|
2348 pTRNS->iType = 0; |
|
2349 pTRNS->iRawlen = iRawlen; |
|
2350 MNG_COPY (pTRNS->aRawdata, pRawdata, iRawlen); |
|
2351 |
|
2352 pData->iGlobalTRNSrawlen = iRawlen; |
|
2353 MNG_COPY (pData->aGlobalTRNSrawdata, pRawdata, iRawlen); |
|
2354 } |
|
2355 |
|
2356 *piRawlen = 0; |
|
2357 |
|
2358 return MNG_NOERROR; |
|
2359 } |
|
2360 |
|
2361 /* ************************************************************************** */ |
|
2362 |
|
2363 MNG_C_SPECIALFUNC (mng_special_trns) |
|
2364 { /* multiple tRNS only inside BASI */ |
|
2365 if ((pData->bHasTRNS) && (!pData->bHasBASI)) |
|
2366 MNG_ERROR (pData, MNG_MULTIPLEERROR); |
|
2367 |
|
2368 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2369 { /* not allowed with full alpha-channel */ |
|
2370 if ((pData->iColortype == 4) || (pData->iColortype == 6)) |
|
2371 MNG_ERROR (pData, MNG_CHUNKNOTALLOWED); |
|
2372 |
|
2373 if (!((mng_trnsp)pChunk)->bEmpty) /* filled ? */ |
|
2374 { |
|
2375 #ifdef MNG_SUPPORT_DISPLAY |
|
2376 if (pData->iColortype == 3) |
|
2377 { |
|
2378 mng_imagep pImage = (mng_imagep)pData->pCurrentobj; |
|
2379 mng_imagedatap pBuf; |
|
2380 |
|
2381 if (!pImage) /* no object then check obj 0 */ |
|
2382 pImage = (mng_imagep)pData->pObjzero; |
|
2383 |
|
2384 pBuf = pImage->pImgbuf; /* address object buffer */ |
|
2385 |
|
2386 if (((mng_trnsp)pChunk)->iCount > pBuf->iPLTEcount) |
|
2387 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
2388 } |
|
2389 #endif |
|
2390 } |
|
2391 else /* if empty there must be global stuff! */ |
|
2392 { |
|
2393 if (!pData->bHasglobalTRNS) |
|
2394 MNG_ERROR (pData, MNG_CANNOTBEEMPTY); |
|
2395 } |
|
2396 } |
|
2397 |
|
2398 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2399 pData->bHasTRNS = MNG_TRUE; /* indicate tRNS available */ |
|
2400 else |
|
2401 pData->bHasglobalTRNS = MNG_TRUE; |
|
2402 |
|
2403 #ifdef MNG_SUPPORT_DISPLAY |
|
2404 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2405 { |
|
2406 mng_imagep pImage; |
|
2407 mng_imagedatap pBuf; |
|
2408 mng_uint8p pRawdata2; |
|
2409 mng_uint32 iRawlen2; |
|
2410 |
|
2411 #ifndef MNG_NO_DELTA_PNG |
|
2412 if (pData->bHasDHDR) /* processing delta-image ? */ |
|
2413 { /* store in object 0 !!! */ |
|
2414 #if defined(MNG_NO_1_2_4BIT_SUPPORT) |
|
2415 mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1,0,0,0,0,0,0,0,1}; |
|
2416 #endif |
|
2417 pImage = (mng_imagep)pData->pObjzero; |
|
2418 pBuf = pImage->pImgbuf; /* address object buffer */ |
|
2419 pBuf->bHasTRNS = MNG_TRUE; /* tell it it's got a tRNS now */ |
|
2420 pBuf->iTRNSgray = 0; |
|
2421 pBuf->iTRNSred = 0; |
|
2422 pBuf->iTRNSgreen = 0; |
|
2423 pBuf->iTRNSblue = 0; |
|
2424 pBuf->iTRNScount = 0; |
|
2425 |
|
2426 switch (pData->iColortype) /* store fields for future reference */ |
|
2427 { |
|
2428 case 0: { /* gray */ |
|
2429 pBuf->iTRNSgray = ((mng_trnsp)pChunk)->iGray; |
|
2430 #if defined(MNG_NO_1_2_4BIT_SUPPORT) |
|
2431 pBuf->iTRNSgray *= multiplier[pData->iPNGdepth]; |
|
2432 #endif |
|
2433 #if defined(MNG_NO_16BIT_SUPPORT) |
|
2434 if (pData->iPNGmult == 2) |
|
2435 pBuf->iTRNSgray >>= 8; |
|
2436 #endif |
|
2437 break; |
|
2438 } |
|
2439 case 2: { /* rgb */ |
|
2440 pBuf->iTRNSred = ((mng_trnsp)pChunk)->iRed; |
|
2441 pBuf->iTRNSgreen = ((mng_trnsp)pChunk)->iGreen; |
|
2442 pBuf->iTRNSblue = ((mng_trnsp)pChunk)->iBlue; |
|
2443 #if defined(MNG_NO_16BIT_SUPPORT) |
|
2444 if (pData->iPNGmult == 2) |
|
2445 { |
|
2446 pBuf->iTRNSred >>= 8; |
|
2447 pBuf->iTRNSgreen >>= 8; |
|
2448 pBuf->iTRNSblue >>= 8; |
|
2449 } |
|
2450 #endif |
|
2451 break; |
|
2452 } |
|
2453 case 3: { /* indexed */ |
|
2454 pBuf->iTRNScount = ((mng_trnsp)pChunk)->iCount; |
|
2455 MNG_COPY (pBuf->aTRNSentries, |
|
2456 ((mng_trnsp)pChunk)->aEntries, |
|
2457 ((mng_trnsp)pChunk)->iCount); |
|
2458 break; |
|
2459 } |
|
2460 } |
|
2461 } |
|
2462 else |
|
2463 #endif |
|
2464 { /* address current object */ |
|
2465 pImage = (mng_imagep)pData->pCurrentobj; |
|
2466 |
|
2467 if (!pImage) /* no object then dump it in obj 0 */ |
|
2468 pImage = (mng_imagep)pData->pObjzero; |
|
2469 |
|
2470 pBuf = pImage->pImgbuf; /* address object buffer */ |
|
2471 pBuf->bHasTRNS = MNG_TRUE; /* and tell it it's got a tRNS now */ |
|
2472 pBuf->iTRNSgray = 0; |
|
2473 pBuf->iTRNSred = 0; |
|
2474 pBuf->iTRNSgreen = 0; |
|
2475 pBuf->iTRNSblue = 0; |
|
2476 pBuf->iTRNScount = 0; |
|
2477 |
|
2478 if (((mng_trnsp)pChunk)->bEmpty) /* if empty, inherit from global */ |
|
2479 { |
|
2480 iRawlen2 = pData->iGlobalTRNSrawlen; |
|
2481 pRawdata2 = (mng_ptr)(pData->aGlobalTRNSrawdata); |
|
2482 /* global length oke ? */ |
|
2483 if ((pData->iColortype == 0) && (iRawlen2 != 2)) |
|
2484 MNG_ERROR (pData, MNG_GLOBALLENGTHERR); |
|
2485 |
|
2486 if ((pData->iColortype == 2) && (iRawlen2 != 6)) |
|
2487 MNG_ERROR (pData, MNG_GLOBALLENGTHERR); |
|
2488 |
|
2489 if ((pData->iColortype == 3) && ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount))) |
|
2490 MNG_ERROR (pData, MNG_GLOBALLENGTHERR); |
|
2491 |
|
2492 switch (pData->iColortype) /* store fields for future reference */ |
|
2493 { |
|
2494 case 0: { /* gray */ |
|
2495 pBuf->iTRNSgray = mng_get_uint16 (pRawdata2); |
|
2496 #if defined(MNG_NO_16BIT_SUPPORT) |
|
2497 if (pData->iPNGmult == 2) |
|
2498 pBuf->iTRNSgray >>= 8; |
|
2499 #endif |
|
2500 break; |
|
2501 } |
|
2502 case 2: { /* rgb */ |
|
2503 pBuf->iTRNSred = mng_get_uint16 (pRawdata2); |
|
2504 pBuf->iTRNSgreen = mng_get_uint16 (pRawdata2+2); |
|
2505 pBuf->iTRNSblue = mng_get_uint16 (pRawdata2+4); |
|
2506 #if defined(MNG_NO_16BIT_SUPPORT) |
|
2507 if (pData->iPNGmult == 2) |
|
2508 { |
|
2509 pBuf->iTRNSred >>= 8; |
|
2510 pBuf->iTRNSgreen >>= 8; |
|
2511 pBuf->iTRNSblue >>= 8; |
|
2512 } |
|
2513 #endif |
|
2514 break; |
|
2515 } |
|
2516 case 3: { /* indexed */ |
|
2517 pBuf->iTRNScount = iRawlen2; |
|
2518 MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2); |
|
2519 break; |
|
2520 } |
|
2521 } |
|
2522 } |
|
2523 else |
|
2524 { |
|
2525 switch (pData->iColortype) /* store fields for future reference */ |
|
2526 { |
|
2527 case 0: { /* gray */ |
|
2528 pBuf->iTRNSgray = ((mng_trnsp)pChunk)->iGray; |
|
2529 #if defined(MNG_NO_16BIT_SUPPORT) |
|
2530 if (pData->iPNGmult == 2) |
|
2531 pBuf->iTRNSgray >>= 8; |
|
2532 #endif |
|
2533 break; |
|
2534 } |
|
2535 case 2: { /* rgb */ |
|
2536 pBuf->iTRNSred = ((mng_trnsp)pChunk)->iRed; |
|
2537 pBuf->iTRNSgreen = ((mng_trnsp)pChunk)->iGreen; |
|
2538 pBuf->iTRNSblue = ((mng_trnsp)pChunk)->iBlue; |
|
2539 #if defined(MNG_NO_16BIT_SUPPORT) |
|
2540 if (pData->iPNGmult == 2) |
|
2541 { |
|
2542 pBuf->iTRNSred >>= 8; |
|
2543 pBuf->iTRNSgreen >>= 8; |
|
2544 pBuf->iTRNSblue >>= 8; |
|
2545 } |
|
2546 #endif |
|
2547 break; |
|
2548 } |
|
2549 case 3: { /* indexed */ |
|
2550 pBuf->iTRNScount = ((mng_trnsp)pChunk)->iCount; |
|
2551 MNG_COPY (pBuf->aTRNSentries, |
|
2552 ((mng_trnsp)pChunk)->aEntries, |
|
2553 ((mng_trnsp)pChunk)->iCount); |
|
2554 break; |
|
2555 } |
|
2556 } |
|
2557 } |
|
2558 } |
|
2559 } |
|
2560 else |
|
2561 { /* create an animation object */ |
|
2562 return mng_create_ani_trns (pData); |
|
2563 } |
|
2564 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2565 |
|
2566 return MNG_NOERROR; /* done */ |
|
2567 } |
|
2568 |
|
2569 /* ************************************************************************** */ |
|
2570 |
|
2571 MNG_C_SPECIALFUNC (mng_special_gama) |
|
2572 { |
|
2573 #ifdef MNG_INCLUDE_JNG |
|
2574 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2575 #else |
|
2576 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2577 #endif |
|
2578 pData->bHasGAMA = MNG_TRUE; /* indicate we've got it */ |
|
2579 else |
|
2580 pData->bHasglobalGAMA = (mng_bool)!((mng_gamap)pChunk)->bEmpty; |
|
2581 |
|
2582 #ifdef MNG_SUPPORT_DISPLAY |
|
2583 #ifdef MNG_INCLUDE_JNG |
|
2584 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2585 #else |
|
2586 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2587 #endif |
|
2588 { |
|
2589 mng_imagep pImage; |
|
2590 |
|
2591 #ifndef MNG_NO_DELTA_PNG |
|
2592 if (pData->bHasDHDR) /* update delta image ? */ |
|
2593 pImage = (mng_imagep)pData->pObjzero; |
|
2594 else |
|
2595 #endif |
|
2596 { |
|
2597 pImage = (mng_imagep)pData->pCurrentobj; |
|
2598 if (!pImage) /* no object then dump it in obj 0 */ |
|
2599 pImage = (mng_imagep)pData->pObjzero; |
|
2600 } |
|
2601 /* store for color-processing routines */ |
|
2602 pImage->pImgbuf->iGamma = ((mng_gamap)pChunk)->iGamma; |
|
2603 pImage->pImgbuf->bHasGAMA = MNG_TRUE; |
|
2604 } |
|
2605 else |
|
2606 { /* store as global */ |
|
2607 if (!((mng_gamap)pChunk)->bEmpty) |
|
2608 pData->iGlobalGamma = ((mng_gamap)pChunk)->iGamma; |
|
2609 /* create an animation object */ |
|
2610 return mng_create_ani_gama (pData, pChunk); |
|
2611 } |
|
2612 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2613 |
|
2614 return MNG_NOERROR; /* done */ |
|
2615 } |
|
2616 |
|
2617 /* ************************************************************************** */ |
|
2618 |
|
2619 #ifndef MNG_SKIPCHUNK_cHRM |
|
2620 MNG_C_SPECIALFUNC (mng_special_chrm) |
|
2621 { |
|
2622 #ifdef MNG_INCLUDE_JNG |
|
2623 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2624 #else |
|
2625 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2626 #endif |
|
2627 pData->bHasCHRM = MNG_TRUE; /* indicate we've got it */ |
|
2628 else |
|
2629 pData->bHasglobalCHRM = (mng_bool)!((mng_chrmp)pChunk)->bEmpty; |
|
2630 |
|
2631 #ifdef MNG_SUPPORT_DISPLAY |
|
2632 { |
|
2633 #ifdef MNG_INCLUDE_JNG |
|
2634 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2635 #else |
|
2636 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2637 #endif |
|
2638 { |
|
2639 mng_imagep pImage; |
|
2640 mng_imagedatap pBuf; |
|
2641 |
|
2642 #ifndef MNG_NO_DELTA_PNG |
|
2643 if (pData->bHasDHDR) /* update delta image ? */ |
|
2644 pImage = (mng_imagep)pData->pObjzero; |
|
2645 else |
|
2646 #endif |
|
2647 { |
|
2648 pImage = (mng_imagep)pData->pCurrentobj; |
|
2649 if (!pImage) /* no object then dump it in obj 0 */ |
|
2650 pImage = (mng_imagep)pData->pObjzero; |
|
2651 } |
|
2652 |
|
2653 pBuf = pImage->pImgbuf; /* address object buffer */ |
|
2654 pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */ |
|
2655 /* store for color-processing routines */ |
|
2656 pBuf->iWhitepointx = ((mng_chrmp)pChunk)->iWhitepointx; |
|
2657 pBuf->iWhitepointy = ((mng_chrmp)pChunk)->iWhitepointy; |
|
2658 pBuf->iPrimaryredx = ((mng_chrmp)pChunk)->iRedx; |
|
2659 pBuf->iPrimaryredy = ((mng_chrmp)pChunk)->iRedy; |
|
2660 pBuf->iPrimarygreenx = ((mng_chrmp)pChunk)->iGreenx; |
|
2661 pBuf->iPrimarygreeny = ((mng_chrmp)pChunk)->iGreeny; |
|
2662 pBuf->iPrimarybluex = ((mng_chrmp)pChunk)->iBluex; |
|
2663 pBuf->iPrimarybluey = ((mng_chrmp)pChunk)->iBluey; |
|
2664 } |
|
2665 else |
|
2666 { /* store as global */ |
|
2667 if (!((mng_chrmp)pChunk)->bEmpty) |
|
2668 { |
|
2669 pData->iGlobalWhitepointx = ((mng_chrmp)pChunk)->iWhitepointx; |
|
2670 pData->iGlobalWhitepointy = ((mng_chrmp)pChunk)->iWhitepointy; |
|
2671 pData->iGlobalPrimaryredx = ((mng_chrmp)pChunk)->iRedx; |
|
2672 pData->iGlobalPrimaryredy = ((mng_chrmp)pChunk)->iRedy; |
|
2673 pData->iGlobalPrimarygreenx = ((mng_chrmp)pChunk)->iGreenx; |
|
2674 pData->iGlobalPrimarygreeny = ((mng_chrmp)pChunk)->iGreeny; |
|
2675 pData->iGlobalPrimarybluex = ((mng_chrmp)pChunk)->iBluex; |
|
2676 pData->iGlobalPrimarybluey = ((mng_chrmp)pChunk)->iBluey; |
|
2677 } |
|
2678 /* create an animation object */ |
|
2679 return mng_create_ani_chrm (pData, pChunk); |
|
2680 } |
|
2681 } |
|
2682 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2683 |
|
2684 return MNG_NOERROR; /* done */ |
|
2685 } |
|
2686 #endif |
|
2687 |
|
2688 /* ************************************************************************** */ |
|
2689 |
|
2690 MNG_C_SPECIALFUNC (mng_special_srgb) |
|
2691 { |
|
2692 #ifdef MNG_INCLUDE_JNG |
|
2693 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2694 #else |
|
2695 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2696 #endif |
|
2697 pData->bHasSRGB = MNG_TRUE; /* indicate we've got it */ |
|
2698 else |
|
2699 pData->bHasglobalSRGB = (mng_bool)!((mng_srgbp)pChunk)->bEmpty; |
|
2700 |
|
2701 #ifdef MNG_SUPPORT_DISPLAY |
|
2702 #ifdef MNG_INCLUDE_JNG |
|
2703 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2704 #else |
|
2705 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2706 #endif |
|
2707 { |
|
2708 mng_imagep pImage; |
|
2709 |
|
2710 #ifndef MNG_NO_DELTA_PNG |
|
2711 if (pData->bHasDHDR) /* update delta image ? */ |
|
2712 pImage = (mng_imagep)pData->pObjzero; |
|
2713 else |
|
2714 #endif |
|
2715 { |
|
2716 pImage = (mng_imagep)pData->pCurrentobj; |
|
2717 if (!pImage) /* no object then dump it in obj 0 */ |
|
2718 pImage = (mng_imagep)pData->pObjzero; |
|
2719 } |
|
2720 /* store for color-processing routines */ |
|
2721 pImage->pImgbuf->iRenderingintent = ((mng_srgbp)pChunk)->iRenderingintent; |
|
2722 pImage->pImgbuf->bHasSRGB = MNG_TRUE; |
|
2723 } |
|
2724 else |
|
2725 { /* store as global */ |
|
2726 if (!((mng_srgbp)pChunk)->bEmpty) |
|
2727 pData->iGlobalRendintent = ((mng_srgbp)pChunk)->iRenderingintent; |
|
2728 /* create an animation object */ |
|
2729 return mng_create_ani_srgb (pData, pChunk); |
|
2730 } |
|
2731 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2732 |
|
2733 return MNG_NOERROR; /* done */ |
|
2734 } |
|
2735 |
|
2736 /* ************************************************************************** */ |
|
2737 |
|
2738 #ifndef MNG_SKIPCHUNK_iCCP |
|
2739 MNG_C_SPECIALFUNC (mng_special_iccp) |
|
2740 { |
|
2741 mng_retcode iRetcode; |
|
2742 mng_chunk_headerp pDummy; |
|
2743 |
|
2744 #ifdef MNG_CHECK_BAD_ICCP /* Check for bad iCCP chunk */ |
|
2745 if (!strncmp (((mng_iccpp)pChunk)->zName, "Photoshop ICC profile", 21)) |
|
2746 { |
|
2747 if (((mng_iccpp)pChunk)->iProfilesize == 2615) /* is it the sRGB profile ? */ |
|
2748 { |
|
2749 mng_chunk_header chunk_srgb; |
|
2750 mng_get_chunkheader (MNG_UINT_sRGB, &chunk_srgb); |
|
2751 /* pretend it's an sRGB chunk then ! */ |
|
2752 iRetcode = mng_read_general (pData, &chunk_srgb, 1, (mng_ptr)"0", &pDummy); |
|
2753 if (iRetcode) /* on error bail out */ |
|
2754 return iRetcode; |
|
2755 |
|
2756 pDummy->fCleanup (pData, pDummy); |
|
2757 } |
|
2758 } |
|
2759 else |
|
2760 { |
|
2761 #endif /* MNG_CHECK_BAD_ICCP */ |
|
2762 |
|
2763 #ifdef MNG_INCLUDE_JNG |
|
2764 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2765 #else |
|
2766 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2767 #endif |
|
2768 pData->bHasICCP = MNG_TRUE; /* indicate we've got it */ |
|
2769 else |
|
2770 pData->bHasglobalICCP = (mng_bool)!((mng_iccpp)pChunk)->bEmpty; |
|
2771 |
|
2772 #ifdef MNG_SUPPORT_DISPLAY |
|
2773 #ifdef MNG_INCLUDE_JNG |
|
2774 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2775 #else |
|
2776 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2777 #endif |
|
2778 { |
|
2779 mng_imagep pImage; |
|
2780 |
|
2781 #ifndef MNG_NO_DELTA_PNG |
|
2782 if (pData->bHasDHDR) /* update delta image ? */ |
|
2783 { /* store in object 0 ! */ |
|
2784 pImage = (mng_imagep)pData->pObjzero; |
|
2785 |
|
2786 if (pImage->pImgbuf->pProfile) /* profile existed ? */ |
|
2787 MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize); |
|
2788 /* allocate a buffer & copy it */ |
|
2789 MNG_ALLOC (pData, pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->iProfilesize); |
|
2790 MNG_COPY (pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->pProfile, ((mng_iccpp)pChunk)->iProfilesize); |
|
2791 /* store its length as well */ |
|
2792 pImage->pImgbuf->iProfilesize = ((mng_iccpp)pChunk)->iProfilesize; |
|
2793 pImage->pImgbuf->bHasICCP = MNG_TRUE; |
|
2794 } |
|
2795 else |
|
2796 #endif |
|
2797 { |
|
2798 pImage = (mng_imagep)pData->pCurrentobj; |
|
2799 |
|
2800 if (!pImage) /* no object then dump it in obj 0 */ |
|
2801 pImage = (mng_imagep)pData->pObjzero; |
|
2802 |
|
2803 if (pImage->pImgbuf->pProfile) /* profile existed ? */ |
|
2804 MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize); |
|
2805 /* allocate a buffer & copy it */ |
|
2806 MNG_ALLOC (pData, pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->iProfilesize); |
|
2807 MNG_COPY (pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->pProfile, ((mng_iccpp)pChunk)->iProfilesize); |
|
2808 /* store its length as well */ |
|
2809 pImage->pImgbuf->iProfilesize = ((mng_iccpp)pChunk)->iProfilesize; |
|
2810 pImage->pImgbuf->bHasICCP = MNG_TRUE; |
|
2811 } |
|
2812 } |
|
2813 else |
|
2814 { /* store as global */ |
|
2815 if (pData->pGlobalProfile) /* did we have a global profile ? */ |
|
2816 MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize); |
|
2817 |
|
2818 if (((mng_iccpp)pChunk)->bEmpty) /* empty chunk ? */ |
|
2819 { |
|
2820 pData->iGlobalProfilesize = 0; /* reset to null */ |
|
2821 pData->pGlobalProfile = MNG_NULL; |
|
2822 } |
|
2823 else |
|
2824 { /* allocate a global buffer & copy it */ |
|
2825 MNG_ALLOC (pData, pData->pGlobalProfile, ((mng_iccpp)pChunk)->iProfilesize); |
|
2826 MNG_COPY (pData->pGlobalProfile, ((mng_iccpp)pChunk)->pProfile, ((mng_iccpp)pChunk)->iProfilesize); |
|
2827 /* store its length as well */ |
|
2828 pData->iGlobalProfilesize = ((mng_iccpp)pChunk)->iProfilesize; |
|
2829 } |
|
2830 /* create an animation object */ |
|
2831 return mng_create_ani_iccp (pData, pChunk); |
|
2832 } |
|
2833 #endif /* MNG_SUPPORT_DISPLAY */ |
|
2834 |
|
2835 #ifdef MNG_CHECK_BAD_ICCP |
|
2836 } |
|
2837 #endif |
|
2838 |
|
2839 return MNG_NOERROR; /* done */ |
|
2840 } |
|
2841 #endif |
|
2842 |
|
2843 /* ************************************************************************** */ |
|
2844 |
|
2845 #ifndef MNG_SKIPCHUNK_tEXt |
|
2846 MNG_C_SPECIALFUNC (mng_special_text) |
|
2847 { |
|
2848 if (pData->fProcesstext) /* inform the application ? */ |
|
2849 { |
|
2850 mng_bool bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_TEXT, |
|
2851 ((mng_textp)pChunk)->zKeyword, |
|
2852 ((mng_textp)pChunk)->zText, 0, 0); |
|
2853 if (!bOke) |
|
2854 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
2855 } |
|
2856 |
|
2857 return MNG_NOERROR; /* done */ |
|
2858 } |
|
2859 #endif |
|
2860 |
|
2861 /* ************************************************************************** */ |
|
2862 |
|
2863 #ifndef MNG_SKIPCHUNK_zTXt |
|
2864 MNG_C_SPECIALFUNC (mng_special_ztxt) |
|
2865 { |
|
2866 if (pData->fProcesstext) /* inform the application ? */ |
|
2867 { |
|
2868 mng_bool bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ZTXT, |
|
2869 ((mng_ztxtp)pChunk)->zKeyword, |
|
2870 ((mng_ztxtp)pChunk)->zText, 0, 0); |
|
2871 if (!bOke) |
|
2872 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
2873 } |
|
2874 |
|
2875 return MNG_NOERROR; /* done */ |
|
2876 } |
|
2877 #endif |
|
2878 |
|
2879 /* ************************************************************************** */ |
|
2880 |
|
2881 #ifndef MNG_SKIPCHUNK_iTXt |
|
2882 MNG_F_SPECIALFUNC (mng_deflate_itxt) |
|
2883 { |
|
2884 mng_itxtp pITXT = (mng_itxtp)pChunk; |
|
2885 mng_uint32 iBufsize = 0; |
|
2886 mng_uint8p pBuf = 0; |
|
2887 mng_uint32 iTextlen = 0; |
|
2888 |
|
2889 if (pITXT->iCompressionflag) /* decompress the text ? */ |
|
2890 { |
|
2891 mng_retcode iRetcode = mng_inflate_buffer (pData, *ppRawdata, *piRawlen, |
|
2892 &pBuf, &iBufsize, &iTextlen); |
|
2893 |
|
2894 if (iRetcode) /* on error bail out */ |
|
2895 { /* don't forget to drop the temp buffer */ |
|
2896 MNG_FREEX (pData, pBuf, iBufsize); |
|
2897 return iRetcode; |
|
2898 } |
|
2899 |
|
2900 MNG_ALLOC (pData, pITXT->zText, iTextlen+1); |
|
2901 MNG_COPY (pITXT->zText, pBuf, iTextlen); |
|
2902 |
|
2903 pITXT->iTextsize = iTextlen; |
|
2904 |
|
2905 MNG_FREEX (pData, pBuf, iBufsize); |
|
2906 |
|
2907 } else { |
|
2908 |
|
2909 MNG_ALLOC (pData, pITXT->zText, (*piRawlen)+1); |
|
2910 MNG_COPY (pITXT->zText, *ppRawdata, *piRawlen); |
|
2911 |
|
2912 pITXT->iTextsize = *piRawlen; |
|
2913 } |
|
2914 |
|
2915 *piRawlen = 0; |
|
2916 |
|
2917 return MNG_NOERROR; |
|
2918 } |
|
2919 #endif |
|
2920 |
|
2921 /* ************************************************************************** */ |
|
2922 |
|
2923 #ifndef MNG_SKIPCHUNK_iTXt |
|
2924 MNG_C_SPECIALFUNC (mng_special_itxt) |
|
2925 { |
|
2926 if (pData->fProcesstext) /* inform the application ? */ |
|
2927 { |
|
2928 mng_bool bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ITXT, |
|
2929 ((mng_itxtp)pChunk)->zKeyword, |
|
2930 ((mng_itxtp)pChunk)->zText, |
|
2931 ((mng_itxtp)pChunk)->zLanguage, |
|
2932 ((mng_itxtp)pChunk)->zTranslation); |
|
2933 if (!bOke) |
|
2934 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
2935 } |
|
2936 |
|
2937 return MNG_NOERROR; /* done */ |
|
2938 } |
|
2939 #endif |
|
2940 |
|
2941 /* ************************************************************************** */ |
|
2942 |
|
2943 #ifndef MNG_SKIPCHUNK_bKGD |
|
2944 MNG_C_SPECIALFUNC (mng_special_bkgd) |
|
2945 { |
|
2946 #ifdef MNG_SUPPORT_DISPLAY |
|
2947 mng_imagep pImage = (mng_imagep)pData->pCurrentobj; |
|
2948 mng_imagedatap pBuf; |
|
2949 #endif |
|
2950 |
|
2951 #ifdef MNG_INCLUDE_JNG |
|
2952 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR)) |
|
2953 #else |
|
2954 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2955 #endif |
|
2956 pData->bHasBKGD = MNG_TRUE; /* indicate bKGD available */ |
|
2957 else |
|
2958 pData->bHasglobalBKGD = (mng_bool)!(((mng_bkgdp)pChunk)->bEmpty); |
|
2959 |
|
2960 #ifdef MNG_SUPPORT_DISPLAY |
|
2961 if (!pImage) /* if no object dump it in obj 0 */ |
|
2962 pImage = (mng_imagep)pData->pObjzero; |
|
2963 pBuf = pImage->pImgbuf; /* address object buffer */ |
|
2964 |
|
2965 #ifdef MNG_INCLUDE_JNG |
|
2966 if (pData->bHasJHDR) |
|
2967 { |
|
2968 pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */ |
|
2969 |
|
2970 switch (pData->iJHDRcolortype) /* store fields for future reference */ |
|
2971 { |
|
2972 case 8 : ; /* gray */ |
|
2973 case 12 : { /* graya */ |
|
2974 pBuf->iBKGDgray = ((mng_bkgdp)pChunk)->iGray; |
|
2975 break; |
|
2976 } |
|
2977 case 10 : ; /* rgb */ |
|
2978 case 14 : { /* rgba */ |
|
2979 pBuf->iBKGDred = ((mng_bkgdp)pChunk)->iRed; |
|
2980 pBuf->iBKGDgreen = ((mng_bkgdp)pChunk)->iGreen; |
|
2981 pBuf->iBKGDblue = ((mng_bkgdp)pChunk)->iBlue; |
|
2982 break; |
|
2983 } |
|
2984 } |
|
2985 } |
|
2986 else |
|
2987 #endif /* MNG_INCLUDE_JNG */ |
|
2988 if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR)) |
|
2989 { |
|
2990 pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */ |
|
2991 |
|
2992 switch (pData->iColortype) /* store fields for future reference */ |
|
2993 { |
|
2994 case 0 : ; /* gray */ |
|
2995 case 4 : { /* graya */ |
|
2996 pBuf->iBKGDgray = ((mng_bkgdp)pChunk)->iGray; |
|
2997 break; |
|
2998 } |
|
2999 case 2 : ; /* rgb */ |
|
3000 case 6 : { /* rgba */ |
|
3001 pBuf->iBKGDred = ((mng_bkgdp)pChunk)->iRed; |
|
3002 pBuf->iBKGDgreen = ((mng_bkgdp)pChunk)->iGreen; |
|
3003 pBuf->iBKGDblue = ((mng_bkgdp)pChunk)->iBlue; |
|
3004 break; |
|
3005 } |
|
3006 case 3 : { /* indexed */ |
|
3007 pBuf->iBKGDindex = ((mng_bkgdp)pChunk)->iIndex; |
|
3008 break; |
|
3009 } |
|
3010 } |
|
3011 } |
|
3012 else /* store as global */ |
|
3013 { |
|
3014 if (!(((mng_bkgdp)pChunk)->bEmpty)) |
|
3015 { |
|
3016 pData->iGlobalBKGDred = ((mng_bkgdp)pChunk)->iRed; |
|
3017 pData->iGlobalBKGDgreen = ((mng_bkgdp)pChunk)->iGreen; |
|
3018 pData->iGlobalBKGDblue = ((mng_bkgdp)pChunk)->iBlue; |
|
3019 } |
|
3020 /* create an animation object */ |
|
3021 return mng_create_ani_bkgd (pData); |
|
3022 } |
|
3023 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3024 |
|
3025 return MNG_NOERROR; /* done */ |
|
3026 } |
|
3027 #endif |
|
3028 |
|
3029 /* ************************************************************************** */ |
|
3030 |
|
3031 #ifndef MNG_SKIPCHUNK_pHYs |
|
3032 MNG_C_SPECIALFUNC (mng_special_phys) |
|
3033 { |
|
3034 #ifdef MNG_SUPPORT_DISPLAY |
|
3035 { |
|
3036 |
|
3037 |
|
3038 /* TODO: something !!! */ |
|
3039 |
|
3040 |
|
3041 } |
|
3042 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3043 |
|
3044 return MNG_NOERROR; /* done */ |
|
3045 } |
|
3046 #endif |
|
3047 |
|
3048 /* ************************************************************************** */ |
|
3049 |
|
3050 #ifndef MNG_SKIPCHUNK_sBIT |
|
3051 MNG_C_SPECIALFUNC (mng_special_sbit) |
|
3052 { |
|
3053 #ifdef MNG_SUPPORT_DISPLAY |
|
3054 { |
|
3055 |
|
3056 |
|
3057 /* TODO: something !!! */ |
|
3058 |
|
3059 |
|
3060 } |
|
3061 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3062 |
|
3063 return MNG_NOERROR; /* done */ |
|
3064 } |
|
3065 #endif |
|
3066 |
|
3067 /* ************************************************************************** */ |
|
3068 |
|
3069 #ifndef MNG_SKIPCHUNK_sPLT |
|
3070 MNG_F_SPECIALFUNC (mng_splt_entries) |
|
3071 { |
|
3072 mng_spltp pSPLT = (mng_spltp)pChunk; |
|
3073 mng_uint32 iRawlen = *piRawlen; |
|
3074 mng_uint8p pRawdata = *ppRawdata; |
|
3075 |
|
3076 if ((pSPLT->iSampledepth != MNG_BITDEPTH_8 ) && |
|
3077 (pSPLT->iSampledepth != MNG_BITDEPTH_16) ) |
|
3078 MNG_ERROR (pData, MNG_INVSAMPLEDEPTH); |
|
3079 /* check remaining length */ |
|
3080 if ( ((pSPLT->iSampledepth == MNG_BITDEPTH_8 ) && (iRawlen % 6 != 0)) || |
|
3081 ((pSPLT->iSampledepth == MNG_BITDEPTH_16) && (iRawlen % 10 != 0)) ) |
|
3082 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3083 |
|
3084 if (pSPLT->iSampledepth == MNG_BITDEPTH_8) |
|
3085 pSPLT->iEntrycount = iRawlen / 6; |
|
3086 else |
|
3087 pSPLT->iEntrycount = iRawlen / 10; |
|
3088 |
|
3089 if (iRawlen) |
|
3090 { |
|
3091 MNG_ALLOC (pData, pSPLT->pEntries, iRawlen); |
|
3092 MNG_COPY (pSPLT->pEntries, pRawdata, iRawlen); |
|
3093 } |
|
3094 |
|
3095 *piRawlen = 0; |
|
3096 |
|
3097 return MNG_NOERROR; |
|
3098 } |
|
3099 #endif |
|
3100 |
|
3101 /* ************************************************************************** */ |
|
3102 |
|
3103 #ifndef MNG_SKIPCHUNK_sPLT |
|
3104 MNG_C_SPECIALFUNC (mng_special_splt) |
|
3105 { |
|
3106 #ifdef MNG_SUPPORT_DISPLAY |
|
3107 { |
|
3108 |
|
3109 |
|
3110 /* TODO: something !!! */ |
|
3111 |
|
3112 |
|
3113 } |
|
3114 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3115 |
|
3116 return MNG_NOERROR; /* done */ |
|
3117 } |
|
3118 #endif |
|
3119 |
|
3120 /* ************************************************************************** */ |
|
3121 |
|
3122 #ifndef MNG_SKIPCHUNK_hIST |
|
3123 MNG_F_SPECIALFUNC (mng_hist_entries) |
|
3124 { |
|
3125 mng_histp pHIST = (mng_histp)pChunk; |
|
3126 mng_uint32 iRawlen = *piRawlen; |
|
3127 mng_uint8p pRawdata = *ppRawdata; |
|
3128 mng_uint32 iX; |
|
3129 |
|
3130 if ( ((iRawlen & 0x01) != 0) || ((iRawlen >> 1) != pData->iPLTEcount) ) |
|
3131 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3132 |
|
3133 pHIST->iEntrycount = iRawlen >> 1; |
|
3134 |
|
3135 for (iX = 0; iX < pHIST->iEntrycount; iX++) |
|
3136 { |
|
3137 pHIST->aEntries[iX] = mng_get_uint16 (pRawdata); |
|
3138 pRawdata += 2; |
|
3139 } |
|
3140 |
|
3141 *piRawlen = 0; |
|
3142 |
|
3143 return MNG_NOERROR; |
|
3144 } |
|
3145 #endif |
|
3146 |
|
3147 /* ************************************************************************** */ |
|
3148 |
|
3149 #ifndef MNG_SKIPCHUNK_hIST |
|
3150 MNG_C_SPECIALFUNC (mng_special_hist) |
|
3151 { |
|
3152 #ifdef MNG_SUPPORT_DISPLAY |
|
3153 { |
|
3154 |
|
3155 |
|
3156 /* TODO: something !!! */ |
|
3157 |
|
3158 |
|
3159 } |
|
3160 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3161 |
|
3162 return MNG_NOERROR; /* done */ |
|
3163 } |
|
3164 #endif |
|
3165 |
|
3166 /* ************************************************************************** */ |
|
3167 |
|
3168 #ifndef MNG_SKIPCHUNK_tIME |
|
3169 MNG_C_SPECIALFUNC (mng_special_time) |
|
3170 { |
|
3171 /* if (pData->fProcesstime) */ /* inform the application ? */ |
|
3172 /* { |
|
3173 |
|
3174 pData->fProcesstime ((mng_handle)pData, ); |
|
3175 } */ |
|
3176 |
|
3177 return MNG_NOERROR; /* done */ |
|
3178 } |
|
3179 #endif |
|
3180 |
|
3181 /* ************************************************************************** */ |
|
3182 /* ************************************************************************** */ |
|
3183 /* JNG chunks */ |
|
3184 |
|
3185 #ifdef MNG_INCLUDE_JNG |
|
3186 MNG_C_SPECIALFUNC (mng_special_jhdr) |
|
3187 { |
|
3188 if ((pData->eSigtype == mng_it_jng) && (pData->iChunkseq > 1)) |
|
3189 MNG_ERROR (pData, MNG_SEQUENCEERROR); |
|
3190 /* inside a JHDR-IEND block now */ |
|
3191 pData->bHasJHDR = MNG_TRUE; |
|
3192 /* and store interesting fields */ |
|
3193 pData->iDatawidth = ((mng_jhdrp)pChunk)->iWidth; |
|
3194 pData->iDataheight = ((mng_jhdrp)pChunk)->iHeight; |
|
3195 pData->iJHDRcolortype = ((mng_jhdrp)pChunk)->iColortype; |
|
3196 pData->iJHDRimgbitdepth = ((mng_jhdrp)pChunk)->iImagesampledepth; |
|
3197 pData->iJHDRimgcompression = ((mng_jhdrp)pChunk)->iImagecompression; |
|
3198 pData->iJHDRimginterlace = ((mng_jhdrp)pChunk)->iImageinterlace; |
|
3199 pData->iJHDRalphabitdepth = ((mng_jhdrp)pChunk)->iAlphasampledepth; |
|
3200 pData->iJHDRalphacompression = ((mng_jhdrp)pChunk)->iAlphacompression; |
|
3201 pData->iJHDRalphafilter = ((mng_jhdrp)pChunk)->iAlphafilter; |
|
3202 pData->iJHDRalphainterlace = ((mng_jhdrp)pChunk)->iAlphainterlace; |
|
3203 |
|
3204 #if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT) |
|
3205 pData->iPNGmult = 1; |
|
3206 pData->iPNGdepth = pData->iJHDRalphabitdepth; |
|
3207 #endif |
|
3208 |
|
3209 #ifdef MNG_NO_1_2_4BIT_SUPPORT |
|
3210 if (pData->iJHDRalphabitdepth < 8) |
|
3211 pData->iJHDRalphabitdepth = 8; |
|
3212 #endif |
|
3213 |
|
3214 #ifdef MNG_NO_16BIT_SUPPORT |
|
3215 if (pData->iJHDRalphabitdepth > 8) |
|
3216 { |
|
3217 pData->iPNGmult = 2; |
|
3218 pData->iJHDRalphabitdepth = 8; |
|
3219 } |
|
3220 #endif |
|
3221 /* parameter validity checks */ |
|
3222 if ((pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAY ) && |
|
3223 (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLOR ) && |
|
3224 (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAYA ) && |
|
3225 (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLORA) ) |
|
3226 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE); |
|
3227 |
|
3228 if ((pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8 ) && |
|
3229 (pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG12 ) && |
|
3230 (pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8AND12) ) |
|
3231 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3232 |
|
3233 if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) || |
|
3234 (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) ) |
|
3235 { |
|
3236 if ((pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 ) |
|
3237 #ifndef MNG_NO_1_2_4BIT_SUPPORT |
|
3238 && (pData->iJHDRalphabitdepth != MNG_BITDEPTH_1 ) && |
|
3239 (pData->iJHDRalphabitdepth != MNG_BITDEPTH_2 ) && |
|
3240 (pData->iJHDRalphabitdepth != MNG_BITDEPTH_4 ) |
|
3241 #endif |
|
3242 #ifndef MNG_NO_16BIT_SUPPORT |
|
3243 && (pData->iJHDRalphabitdepth != MNG_BITDEPTH_16) |
|
3244 #endif |
|
3245 ) |
|
3246 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3247 |
|
3248 if ((pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE ) && |
|
3249 (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG) ) |
|
3250 MNG_ERROR (pData, MNG_INVALIDCOMPRESS); |
|
3251 |
|
3252 if ((pData->iJHDRalphacompression == MNG_COMPRESSION_BASELINEJPEG) && |
|
3253 (pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 ) ) |
|
3254 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3255 |
|
3256 #if defined(FILTER192) || defined(FILTER193) |
|
3257 if ((pData->iJHDRalphafilter != MNG_FILTER_ADAPTIVE ) && |
|
3258 #if defined(FILTER192) && defined(FILTER193) |
|
3259 (pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) && |
|
3260 (pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) ) |
|
3261 #else |
|
3262 #ifdef FILTER192 |
|
3263 (pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) ) |
|
3264 #else |
|
3265 (pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) ) |
|
3266 #endif |
|
3267 #endif |
|
3268 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
3269 #else |
|
3270 if (pData->iJHDRalphafilter) |
|
3271 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
3272 #endif |
|
3273 |
|
3274 } |
|
3275 else |
|
3276 { |
|
3277 if (pData->iJHDRalphabitdepth) |
|
3278 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3279 if (pData->iJHDRalphacompression) |
|
3280 MNG_ERROR (pData, MNG_INVALIDCOMPRESS); |
|
3281 if (pData->iJHDRalphafilter) |
|
3282 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
3283 if (pData->iJHDRalphainterlace) |
|
3284 MNG_ERROR (pData, MNG_INVALIDINTERLACE); |
|
3285 } |
|
3286 |
|
3287 if (!pData->bHasheader) /* first chunk ? */ |
|
3288 { |
|
3289 pData->bHasheader = MNG_TRUE; /* we've got a header */ |
|
3290 pData->eImagetype = mng_it_jng; /* then this must be a JNG */ |
|
3291 pData->iWidth = ((mng_jhdrp)pChunk)->iWidth; |
|
3292 pData->iHeight = ((mng_jhdrp)pChunk)->iHeight; |
|
3293 /* predict alpha-depth ! */ |
|
3294 if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) || |
|
3295 (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) ) |
|
3296 pData->iAlphadepth = pData->iJHDRalphabitdepth; |
|
3297 else |
|
3298 pData->iAlphadepth = 0; |
|
3299 /* fits on maximum canvas ? */ |
|
3300 if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight)) |
|
3301 MNG_WARNING (pData, MNG_IMAGETOOLARGE); |
|
3302 |
|
3303 if (pData->fProcessheader) /* inform the app ? */ |
|
3304 if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight)) |
|
3305 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
3306 |
|
3307 } |
|
3308 |
|
3309 pData->iColortype = 0; /* fake grayscale for other routines */ |
|
3310 pData->iImagelevel++; /* one level deeper */ |
|
3311 |
|
3312 #ifdef MNG_SUPPORT_DISPLAY |
|
3313 { |
|
3314 mng_retcode iRetcode = mng_process_display_jhdr (pData); |
|
3315 if (iRetcode) /* on error bail out */ |
|
3316 return iRetcode; |
|
3317 } |
|
3318 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3319 |
|
3320 #ifdef MNG_NO_16BIT_SUPPORT |
|
3321 if (((mng_jhdrp)pChunk)->iAlphasampledepth > 8) |
|
3322 ((mng_jhdrp)pChunk)->iAlphasampledepth = 8; |
|
3323 #endif |
|
3324 |
|
3325 return MNG_NOERROR; /* done */ |
|
3326 } |
|
3327 #endif /* MNG_INCLUDE_JNG */ |
|
3328 |
|
3329 /* ************************************************************************** */ |
|
3330 |
|
3331 #ifdef MNG_INCLUDE_JNG |
|
3332 MNG_C_SPECIALFUNC (mng_special_jdaa) |
|
3333 { |
|
3334 if (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG) |
|
3335 MNG_ERROR (pData, MNG_SEQUENCEERROR); |
|
3336 |
|
3337 pData->bHasJDAA = MNG_TRUE; /* got some JDAA now, don't we */ |
|
3338 return MNG_NOERROR; |
|
3339 } |
|
3340 #endif /* MNG_INCLUDE_JNG */ |
|
3341 |
|
3342 /* ************************************************************************** */ |
|
3343 |
|
3344 #ifdef MNG_INCLUDE_JNG |
|
3345 MNG_C_SPECIALFUNC (mng_special_jdat) |
|
3346 { |
|
3347 pData->bHasJDAT = MNG_TRUE; /* got some JDAT now, don't we */ |
|
3348 return MNG_NOERROR; |
|
3349 } |
|
3350 #endif /* MNG_INCLUDE_JNG */ |
|
3351 |
|
3352 /* ************************************************************************** */ |
|
3353 |
|
3354 #ifdef MNG_INCLUDE_JNG |
|
3355 MNG_C_SPECIALFUNC (mng_special_jsep) |
|
3356 { |
|
3357 pData->bHasJSEP = MNG_TRUE; /* indicate we've had the 8-/12-bit separator */ |
|
3358 return MNG_NOERROR; |
|
3359 } |
|
3360 #endif /* MNG_INCLUDE_JNG */ |
|
3361 |
|
3362 /* ************************************************************************** */ |
|
3363 /* ************************************************************************** */ |
|
3364 /* MNG chunks */ |
|
3365 |
|
3366 MNG_C_SPECIALFUNC (mng_special_mhdr) |
|
3367 { |
|
3368 if (pData->bHasheader) /* can only be the first chunk! */ |
|
3369 MNG_ERROR (pData, MNG_SEQUENCEERROR); |
|
3370 |
|
3371 pData->bHasMHDR = MNG_TRUE; /* oh boy, a real MNG */ |
|
3372 pData->bHasheader = MNG_TRUE; /* we've got a header */ |
|
3373 pData->eImagetype = mng_it_mng; /* fill header fields */ |
|
3374 pData->iWidth = ((mng_mhdrp)pChunk)->iWidth; |
|
3375 pData->iHeight = ((mng_mhdrp)pChunk)->iHeight; |
|
3376 pData->iTicks = ((mng_mhdrp)pChunk)->iTicks; |
|
3377 pData->iLayercount = ((mng_mhdrp)pChunk)->iLayercount; |
|
3378 pData->iFramecount = ((mng_mhdrp)pChunk)->iFramecount; |
|
3379 pData->iPlaytime = ((mng_mhdrp)pChunk)->iPlaytime; |
|
3380 pData->iSimplicity = ((mng_mhdrp)pChunk)->iSimplicity; |
|
3381 #ifndef MNG_NO_OLD_VERSIONS |
|
3382 pData->bPreDraft48 = MNG_FALSE; |
|
3383 #endif |
|
3384 /* predict alpha-depth */ |
|
3385 if ((pData->iSimplicity & 0x00000001) == 0) |
|
3386 #ifndef MNG_NO_16BIT_SUPPORT |
|
3387 pData->iAlphadepth = 16; /* no indicators = assume the worst */ |
|
3388 #else |
|
3389 pData->iAlphadepth = 8; /* anything else = assume the worst */ |
|
3390 #endif |
|
3391 else |
|
3392 if ((pData->iSimplicity & 0x00000008) == 0) |
|
3393 pData->iAlphadepth = 0; /* no transparency at all */ |
|
3394 else |
|
3395 if ((pData->iSimplicity & 0x00000140) == 0x00000040) |
|
3396 pData->iAlphadepth = 1; /* no semi-transparency guaranteed */ |
|
3397 else |
|
3398 #ifndef MNG_NO_16BIT_SUPPORT |
|
3399 pData->iAlphadepth = 16; /* anything else = assume the worst */ |
|
3400 #else |
|
3401 pData->iAlphadepth = 8; /* anything else = assume the worst */ |
|
3402 #endif |
|
3403 |
|
3404 #ifdef MNG_INCLUDE_JNG /* can we handle the complexity ? */ |
|
3405 if (pData->iSimplicity & 0x0000FC00) |
|
3406 #else |
|
3407 if (pData->iSimplicity & 0x0000FC10) |
|
3408 #endif |
|
3409 MNG_ERROR (pData, MNG_MNGTOOCOMPLEX); |
|
3410 /* fits on maximum canvas ? */ |
|
3411 if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight)) |
|
3412 MNG_WARNING (pData, MNG_IMAGETOOLARGE); |
|
3413 |
|
3414 if (pData->fProcessheader) /* inform the app ? */ |
|
3415 if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight)) |
|
3416 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
3417 |
|
3418 pData->iImagelevel++; /* one level deeper */ |
|
3419 |
|
3420 return MNG_NOERROR; /* done */ |
|
3421 } |
|
3422 |
|
3423 /* ************************************************************************** */ |
|
3424 |
|
3425 MNG_C_SPECIALFUNC (mng_special_mend) |
|
3426 { |
|
3427 #ifdef MNG_SUPPORT_DISPLAY |
|
3428 { /* do something */ |
|
3429 mng_retcode iRetcode = mng_process_display_mend (pData); |
|
3430 |
|
3431 if (iRetcode) /* on error bail out */ |
|
3432 return iRetcode; |
|
3433 |
|
3434 if (!pData->iTotalframes) /* save totals */ |
|
3435 pData->iTotalframes = pData->iFrameseq; |
|
3436 if (!pData->iTotallayers) |
|
3437 pData->iTotallayers = pData->iLayerseq; |
|
3438 if (!pData->iTotalplaytime) |
|
3439 pData->iTotalplaytime = pData->iFrametime; |
|
3440 } |
|
3441 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3442 |
|
3443 pData->bHasMHDR = MNG_FALSE; /* end of the line, bro! */ |
|
3444 |
|
3445 return MNG_NOERROR; /* done */ |
|
3446 } |
|
3447 |
|
3448 /* ************************************************************************** */ |
|
3449 |
|
3450 #ifndef MNG_SKIPCHUNK_LOOP |
|
3451 MNG_F_SPECIALFUNC (mng_debunk_loop) |
|
3452 { |
|
3453 mng_loopp pLOOP = (mng_loopp)pChunk; |
|
3454 mng_uint32 iRawlen = *piRawlen; |
|
3455 mng_uint8p pRawdata = *ppRawdata; |
|
3456 |
|
3457 if (iRawlen >= 5) /* length checks */ |
|
3458 { |
|
3459 if (iRawlen >= 6) |
|
3460 { |
|
3461 if ((iRawlen - 6) % 4 != 0) |
|
3462 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3463 } |
|
3464 } |
|
3465 else |
|
3466 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3467 |
|
3468 if (iRawlen >= 5) /* store the fields */ |
|
3469 { |
|
3470 pLOOP->iLevel = *pRawdata; |
|
3471 |
|
3472 #ifndef MNG_NO_OLD_VERSIONS |
|
3473 if (pData->bPreDraft48) |
|
3474 { |
|
3475 pLOOP->iTermination = *(pRawdata+1); |
|
3476 pLOOP->iRepeat = mng_get_uint32 (pRawdata+2); |
|
3477 } |
|
3478 else |
|
3479 #endif |
|
3480 { |
|
3481 pLOOP->iRepeat = mng_get_uint32 (pRawdata+1); |
|
3482 } |
|
3483 |
|
3484 if (iRawlen >= 6) |
|
3485 { |
|
3486 #ifndef MNG_NO_OLD_VERSIONS |
|
3487 if (!pData->bPreDraft48) |
|
3488 #endif |
|
3489 pLOOP->iTermination = *(pRawdata+5); |
|
3490 |
|
3491 if (iRawlen >= 10) |
|
3492 { |
|
3493 pLOOP->iItermin = mng_get_uint32 (pRawdata+6); |
|
3494 |
|
3495 #ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED |
|
3496 if (iRawlen >= 14) |
|
3497 { |
|
3498 pLOOP->iItermax = mng_get_uint32 (pRawdata+10); |
|
3499 pLOOP->iCount = (iRawlen - 14) / 4; |
|
3500 |
|
3501 if (pLOOP->iCount) |
|
3502 { |
|
3503 MNG_ALLOC (pData, pLOOP->pSignals, pLOOP->iCount << 2); |
|
3504 |
|
3505 #ifndef MNG_BIGENDIAN_SUPPORTED |
|
3506 { |
|
3507 mng_uint32 iX; |
|
3508 mng_uint8p pIn = pRawdata + 14; |
|
3509 mng_uint32p pOut = (mng_uint32p)pLOOP->pSignals; |
|
3510 |
|
3511 for (iX = 0; iX < pLOOP->iCount; iX++) |
|
3512 { |
|
3513 *pOut++ = mng_get_uint32 (pIn); |
|
3514 pIn += 4; |
|
3515 } |
|
3516 } |
|
3517 #else |
|
3518 MNG_COPY (pLOOP->pSignals, pRawdata + 14, pLOOP->iCount << 2); |
|
3519 #endif /* !MNG_BIGENDIAN_SUPPORTED */ |
|
3520 } |
|
3521 } |
|
3522 #endif |
|
3523 } |
|
3524 } |
|
3525 } |
|
3526 |
|
3527 *piRawlen = 0; |
|
3528 |
|
3529 return MNG_NOERROR; |
|
3530 } |
|
3531 #endif |
|
3532 |
|
3533 /* ************************************************************************** */ |
|
3534 |
|
3535 #ifndef MNG_SKIPCHUNK_LOOP |
|
3536 MNG_C_SPECIALFUNC (mng_special_loop) |
|
3537 { |
|
3538 if (!pData->bCacheplayback) /* must store playback info to work!! */ |
|
3539 MNG_ERROR (pData, MNG_LOOPWITHCACHEOFF); |
|
3540 |
|
3541 #ifdef MNG_SUPPORT_DISPLAY |
|
3542 { |
|
3543 mng_retcode iRetcode; |
|
3544 |
|
3545 pData->bHasLOOP = MNG_TRUE; /* indicate we're inside a loop */ |
|
3546 /* create the LOOP ani-object */ |
|
3547 iRetcode = mng_create_ani_loop (pData, pChunk); |
|
3548 if (iRetcode) /* on error bail out */ |
|
3549 return iRetcode; |
|
3550 /* skip till matching ENDL if iteration=0 */ |
|
3551 if ((!pData->bSkipping) && (((mng_loopp)pChunk)->iRepeat == 0)) |
|
3552 pData->bSkipping = MNG_TRUE; |
|
3553 } |
|
3554 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3555 |
|
3556 return MNG_NOERROR; /* done */ |
|
3557 } |
|
3558 #endif |
|
3559 |
|
3560 /* ************************************************************************** */ |
|
3561 |
|
3562 #ifndef MNG_SKIPCHUNK_LOOP |
|
3563 MNG_C_SPECIALFUNC (mng_special_endl) |
|
3564 { |
|
3565 #ifdef MNG_SUPPORT_DISPLAY |
|
3566 if (pData->bHasLOOP) /* are we really processing a loop ? */ |
|
3567 { |
|
3568 mng_uint8 iLevel = ((mng_endlp)pChunk)->iLevel; |
|
3569 /* create an ENDL animation object */ |
|
3570 return mng_create_ani_endl (pData, iLevel); |
|
3571 } |
|
3572 else |
|
3573 MNG_ERROR (pData, MNG_NOMATCHINGLOOP); |
|
3574 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3575 |
|
3576 return MNG_NOERROR; /* done */ |
|
3577 } |
|
3578 #endif |
|
3579 |
|
3580 /* ************************************************************************** */ |
|
3581 |
|
3582 #ifndef MNG_SKIPCHUNK_DEFI |
|
3583 MNG_C_SPECIALFUNC (mng_special_defi) |
|
3584 { |
|
3585 #ifdef MNG_SUPPORT_DISPLAY |
|
3586 mng_retcode iRetcode; |
|
3587 |
|
3588 pData->iDEFIobjectid = ((mng_defip)pChunk)->iObjectid; |
|
3589 pData->bDEFIhasdonotshow = ((mng_defip)pChunk)->bHasdonotshow; |
|
3590 pData->iDEFIdonotshow = ((mng_defip)pChunk)->iDonotshow; |
|
3591 pData->bDEFIhasconcrete = ((mng_defip)pChunk)->bHasconcrete; |
|
3592 pData->iDEFIconcrete = ((mng_defip)pChunk)->iConcrete; |
|
3593 pData->bDEFIhasloca = ((mng_defip)pChunk)->bHasloca; |
|
3594 pData->iDEFIlocax = ((mng_defip)pChunk)->iXlocation; |
|
3595 pData->iDEFIlocay = ((mng_defip)pChunk)->iYlocation; |
|
3596 pData->bDEFIhasclip = ((mng_defip)pChunk)->bHasclip; |
|
3597 pData->iDEFIclipl = ((mng_defip)pChunk)->iLeftcb; |
|
3598 pData->iDEFIclipr = ((mng_defip)pChunk)->iRightcb; |
|
3599 pData->iDEFIclipt = ((mng_defip)pChunk)->iTopcb; |
|
3600 pData->iDEFIclipb = ((mng_defip)pChunk)->iBottomcb; |
|
3601 /* create an animation object */ |
|
3602 iRetcode = mng_create_ani_defi (pData); |
|
3603 if (!iRetcode) /* do display processing */ |
|
3604 iRetcode = mng_process_display_defi (pData); |
|
3605 return iRetcode; |
|
3606 #else |
|
3607 return MNG_NOERROR; /* done */ |
|
3608 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3609 } |
|
3610 #endif |
|
3611 |
|
3612 /* ************************************************************************** */ |
|
3613 |
|
3614 #ifndef MNG_SKIPCHUNK_BASI |
|
3615 MNG_C_SPECIALFUNC (mng_special_basi) |
|
3616 { |
|
3617 pData->bHasBASI = MNG_TRUE; /* inside a BASI-IEND block now */ |
|
3618 /* store interesting fields */ |
|
3619 pData->iDatawidth = ((mng_basip)pChunk)->iWidth; |
|
3620 pData->iDataheight = ((mng_basip)pChunk)->iHeight; |
|
3621 pData->iBitdepth = ((mng_basip)pChunk)->iBitdepth; |
|
3622 pData->iColortype = ((mng_basip)pChunk)->iColortype; |
|
3623 pData->iCompression = ((mng_basip)pChunk)->iCompression; |
|
3624 pData->iFilter = ((mng_basip)pChunk)->iFilter; |
|
3625 pData->iInterlace = ((mng_basip)pChunk)->iInterlace; |
|
3626 |
|
3627 #if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT) |
|
3628 pData->iPNGmult = 1; |
|
3629 pData->iPNGdepth = pData->iBitdepth; |
|
3630 #endif |
|
3631 |
|
3632 #ifdef MNG_NO_1_2_4BIT_SUPPORT |
|
3633 if (pData->iBitdepth < 8) |
|
3634 pData->iBitdepth = 8; |
|
3635 #endif |
|
3636 #ifdef MNG_NO_16BIT_SUPPORT |
|
3637 if (pData->iBitdepth > 8) |
|
3638 { |
|
3639 pData->iBitdepth = 8; |
|
3640 pData->iPNGmult = 2; |
|
3641 } |
|
3642 #endif |
|
3643 |
|
3644 if ((pData->iBitdepth != 8) /* parameter validity checks */ |
|
3645 #ifndef MNG_NO_1_2_4BIT_SUPPORT |
|
3646 && (pData->iBitdepth != 1) && |
|
3647 (pData->iBitdepth != 2) && |
|
3648 (pData->iBitdepth != 4) |
|
3649 #endif |
|
3650 #ifndef MNG_NO_16BIT_SUPPORT |
|
3651 && (pData->iBitdepth != 16) |
|
3652 #endif |
|
3653 ) |
|
3654 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3655 |
|
3656 if ((pData->iColortype != MNG_COLORTYPE_GRAY ) && |
|
3657 (pData->iColortype != MNG_COLORTYPE_RGB ) && |
|
3658 (pData->iColortype != MNG_COLORTYPE_INDEXED) && |
|
3659 (pData->iColortype != MNG_COLORTYPE_GRAYA ) && |
|
3660 (pData->iColortype != MNG_COLORTYPE_RGBA ) ) |
|
3661 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE); |
|
3662 |
|
3663 if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8)) |
|
3664 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3665 |
|
3666 if (((pData->iColortype == MNG_COLORTYPE_RGB ) || |
|
3667 (pData->iColortype == MNG_COLORTYPE_GRAYA ) || |
|
3668 (pData->iColortype == MNG_COLORTYPE_RGBA ) ) && |
|
3669 (pData->iBitdepth < 8 ) ) |
|
3670 MNG_ERROR (pData, MNG_INVALIDBITDEPTH); |
|
3671 |
|
3672 #if defined(FILTER192) || defined(FILTER193) |
|
3673 if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) && |
|
3674 #if defined(FILTER192) && defined(FILTER193) |
|
3675 (pData->iFilter != MNG_FILTER_DIFFERING) && |
|
3676 (pData->iFilter != MNG_FILTER_NOFILTER ) ) |
|
3677 #else |
|
3678 #ifdef FILTER192 |
|
3679 (pData->iFilter != MNG_FILTER_DIFFERING) ) |
|
3680 #else |
|
3681 (pData->iFilter != MNG_FILTER_NOFILTER ) ) |
|
3682 #endif |
|
3683 #endif |
|
3684 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
3685 #else |
|
3686 if (pData->iFilter) |
|
3687 MNG_ERROR (pData, MNG_INVALIDFILTER); |
|
3688 #endif |
|
3689 |
|
3690 pData->iImagelevel++; /* one level deeper */ |
|
3691 |
|
3692 #ifdef MNG_SUPPORT_DISPLAY |
|
3693 { /* create an animation object */ |
|
3694 mng_retcode iRetcode = mng_create_ani_basi (pData, pChunk); |
|
3695 if (iRetcode) /* on error bail out */ |
|
3696 return iRetcode; |
|
3697 } |
|
3698 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3699 |
|
3700 #ifdef MNG_NO_16BIT_SUPPORT |
|
3701 if (((mng_basip)pChunk)->iBitdepth > 8) |
|
3702 ((mng_basip)pChunk)->iBitdepth = 8; |
|
3703 #endif |
|
3704 |
|
3705 return MNG_NOERROR; /* done */ |
|
3706 } |
|
3707 #endif |
|
3708 |
|
3709 /* ************************************************************************** */ |
|
3710 |
|
3711 #ifndef MNG_SKIPCHUNK_CLON |
|
3712 MNG_C_SPECIALFUNC (mng_special_clon) |
|
3713 { |
|
3714 #ifdef MNG_SUPPORT_DISPLAY |
|
3715 return mng_create_ani_clon (pData, pChunk); |
|
3716 #else |
|
3717 return MNG_NOERROR; /* done */ |
|
3718 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3719 } |
|
3720 #endif |
|
3721 |
|
3722 /* ************************************************************************** */ |
|
3723 |
|
3724 #ifndef MNG_SKIPCHUNK_PAST |
|
3725 MNG_F_SPECIALFUNC (mng_debunk_past) |
|
3726 { |
|
3727 mng_pastp pPAST = (mng_pastp)pChunk; |
|
3728 mng_uint32 iRawlen = *piRawlen; |
|
3729 mng_uint8p pRawdata = *ppRawdata; |
|
3730 mng_uint32 iSize; |
|
3731 mng_uint32 iX; |
|
3732 mng_past_sourcep pSource; |
|
3733 /* check the length */ |
|
3734 if ((iRawlen < 41) || (((iRawlen - 11) % 30) != 0)) |
|
3735 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3736 |
|
3737 pPAST->iDestid = mng_get_uint16 (pRawdata); |
|
3738 pPAST->iTargettype = *(pRawdata+2); |
|
3739 pPAST->iTargetx = mng_get_int32 (pRawdata+3); |
|
3740 pPAST->iTargety = mng_get_int32 (pRawdata+7); |
|
3741 pPAST->iCount = ((iRawlen - 11) / 30); /* how many entries again? */ |
|
3742 iSize = pPAST->iCount * sizeof (mng_past_source); |
|
3743 |
|
3744 pRawdata += 11; |
|
3745 /* get a buffer for all the source blocks */ |
|
3746 MNG_ALLOC (pData, pPAST->pSources, iSize); |
|
3747 |
|
3748 pSource = (mng_past_sourcep)(pPAST->pSources); |
|
3749 |
|
3750 for (iX = pPAST->iCount; iX > 0; iX--) |
|
3751 { /* now copy the source blocks */ |
|
3752 pSource->iSourceid = mng_get_uint16 (pRawdata); |
|
3753 pSource->iComposition = *(pRawdata+2); |
|
3754 pSource->iOrientation = *(pRawdata+3); |
|
3755 pSource->iOffsettype = *(pRawdata+4); |
|
3756 pSource->iOffsetx = mng_get_int32 (pRawdata+5); |
|
3757 pSource->iOffsety = mng_get_int32 (pRawdata+9); |
|
3758 pSource->iBoundarytype = *(pRawdata+13); |
|
3759 pSource->iBoundaryl = mng_get_int32 (pRawdata+14); |
|
3760 pSource->iBoundaryr = mng_get_int32 (pRawdata+18); |
|
3761 pSource->iBoundaryt = mng_get_int32 (pRawdata+22); |
|
3762 pSource->iBoundaryb = mng_get_int32 (pRawdata+26); |
|
3763 |
|
3764 pSource++; |
|
3765 pRawdata += 30; |
|
3766 } |
|
3767 |
|
3768 *piRawlen = 0; |
|
3769 |
|
3770 return MNG_NOERROR; |
|
3771 } |
|
3772 #endif |
|
3773 |
|
3774 /* ************************************************************************** */ |
|
3775 |
|
3776 #ifndef MNG_SKIPCHUNK_PAST |
|
3777 MNG_C_SPECIALFUNC (mng_special_past) |
|
3778 { |
|
3779 #ifdef MNG_SUPPORT_DISPLAY |
|
3780 return mng_create_ani_past (pData, pChunk); |
|
3781 #else |
|
3782 return MNG_NOERROR; |
|
3783 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3784 } |
|
3785 #endif |
|
3786 |
|
3787 /* ************************************************************************** */ |
|
3788 |
|
3789 #ifndef MNG_SKIPCHUNK_DISC |
|
3790 MNG_F_SPECIALFUNC (mng_disc_entries) |
|
3791 { |
|
3792 mng_discp pDISC = (mng_discp)pChunk; |
|
3793 mng_uint32 iRawlen = *piRawlen; |
|
3794 mng_uint8p pRawdata = *ppRawdata; |
|
3795 |
|
3796 if ((iRawlen % 2) != 0) /* check the length */ |
|
3797 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3798 |
|
3799 pDISC->iCount = (iRawlen / sizeof (mng_uint16)); |
|
3800 |
|
3801 if (pDISC->iCount) |
|
3802 { |
|
3803 MNG_ALLOC (pData, pDISC->pObjectids, iRawlen); |
|
3804 |
|
3805 #ifndef MNG_BIGENDIAN_SUPPORTED |
|
3806 { |
|
3807 mng_uint32 iX; |
|
3808 mng_uint8p pIn = pRawdata; |
|
3809 mng_uint16p pOut = pDISC->pObjectids; |
|
3810 |
|
3811 for (iX = pDISC->iCount; iX > 0; iX--) |
|
3812 { |
|
3813 *pOut++ = mng_get_uint16 (pIn); |
|
3814 pIn += 2; |
|
3815 } |
|
3816 } |
|
3817 #else |
|
3818 MNG_COPY (pDISC->pObjectids, pRawdata, iRawlen); |
|
3819 #endif /* !MNG_BIGENDIAN_SUPPORTED */ |
|
3820 } |
|
3821 |
|
3822 *piRawlen = 0; |
|
3823 |
|
3824 return MNG_NOERROR; |
|
3825 } |
|
3826 #endif |
|
3827 |
|
3828 /* ************************************************************************** */ |
|
3829 |
|
3830 #ifndef MNG_SKIPCHUNK_DISC |
|
3831 MNG_C_SPECIALFUNC (mng_special_disc) |
|
3832 { |
|
3833 #ifdef MNG_SUPPORT_DISPLAY |
|
3834 return mng_create_ani_disc (pData, pChunk); |
|
3835 #else |
|
3836 return MNG_NOERROR; |
|
3837 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3838 } |
|
3839 #endif |
|
3840 |
|
3841 /* ************************************************************************** */ |
|
3842 |
|
3843 #ifndef MNG_SKIPCHUNK_BACK |
|
3844 MNG_C_SPECIALFUNC (mng_special_back) |
|
3845 { |
|
3846 #ifdef MNG_SUPPORT_DISPLAY |
|
3847 /* retrieve the fields */ |
|
3848 pData->bHasBACK = MNG_TRUE; |
|
3849 pData->iBACKred = ((mng_backp)pChunk)->iRed; |
|
3850 pData->iBACKgreen = ((mng_backp)pChunk)->iGreen; |
|
3851 pData->iBACKblue = ((mng_backp)pChunk)->iBlue; |
|
3852 pData->iBACKmandatory = ((mng_backp)pChunk)->iMandatory; |
|
3853 pData->iBACKimageid = ((mng_backp)pChunk)->iImageid; |
|
3854 pData->iBACKtile = ((mng_backp)pChunk)->iTile; |
|
3855 |
|
3856 return mng_create_ani_back (pData); |
|
3857 #else |
|
3858 return MNG_NOERROR; |
|
3859 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3860 } |
|
3861 #endif |
|
3862 |
|
3863 /* ************************************************************************** */ |
|
3864 |
|
3865 #ifndef MNG_SKIPCHUNK_FRAM |
|
3866 MNG_F_SPECIALFUNC (mng_fram_remainder) |
|
3867 { |
|
3868 mng_framp pFRAM = (mng_framp)pChunk; |
|
3869 mng_uint32 iRawlen = *piRawlen; |
|
3870 mng_uint8p pRawdata = *ppRawdata; |
|
3871 mng_uint32 iRequired = 0; |
|
3872 |
|
3873 if (iRawlen < 4) /* must have at least 4 bytes */ |
|
3874 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3875 |
|
3876 iRequired = 4; /* calculate and check required remaining length */ |
|
3877 |
|
3878 pFRAM->iChangedelay = *pRawdata; |
|
3879 pFRAM->iChangetimeout = *(pRawdata+1); |
|
3880 pFRAM->iChangeclipping = *(pRawdata+2); |
|
3881 pFRAM->iChangesyncid = *(pRawdata+3); |
|
3882 |
|
3883 if (pFRAM->iChangedelay ) { iRequired += 4; } |
|
3884 if (pFRAM->iChangetimeout ) { iRequired += 4; } |
|
3885 if (pFRAM->iChangeclipping) { iRequired += 17; } |
|
3886 |
|
3887 if (pFRAM->iChangesyncid) |
|
3888 { |
|
3889 if ((iRawlen - iRequired) % 4 != 0) |
|
3890 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3891 } |
|
3892 else |
|
3893 { |
|
3894 if (iRawlen != iRequired) |
|
3895 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
3896 } |
|
3897 |
|
3898 pRawdata += 4; |
|
3899 |
|
3900 if (pFRAM->iChangedelay) /* delay changed ? */ |
|
3901 { |
|
3902 pFRAM->iDelay = mng_get_uint32 (pRawdata); |
|
3903 pRawdata += 4; |
|
3904 } |
|
3905 |
|
3906 if (pFRAM->iChangetimeout) /* timeout changed ? */ |
|
3907 { |
|
3908 pFRAM->iTimeout = mng_get_uint32 (pRawdata); |
|
3909 pRawdata += 4; |
|
3910 } |
|
3911 |
|
3912 if (pFRAM->iChangeclipping) /* clipping changed ? */ |
|
3913 { |
|
3914 pFRAM->iBoundarytype = *pRawdata; |
|
3915 pFRAM->iBoundaryl = mng_get_int32 (pRawdata+1); |
|
3916 pFRAM->iBoundaryr = mng_get_int32 (pRawdata+5); |
|
3917 pFRAM->iBoundaryt = mng_get_int32 (pRawdata+9); |
|
3918 pFRAM->iBoundaryb = mng_get_int32 (pRawdata+13); |
|
3919 pRawdata += 17; |
|
3920 } |
|
3921 |
|
3922 if (pFRAM->iChangesyncid) |
|
3923 { |
|
3924 pFRAM->iCount = (iRawlen - iRequired) / 4; |
|
3925 |
|
3926 if (pFRAM->iCount) |
|
3927 { |
|
3928 MNG_ALLOC (pData, pFRAM->pSyncids, pFRAM->iCount * 4); |
|
3929 |
|
3930 #ifndef MNG_BIGENDIAN_SUPPORTED |
|
3931 { |
|
3932 mng_uint32 iX; |
|
3933 mng_uint32p pOut = pFRAM->pSyncids; |
|
3934 |
|
3935 for (iX = pFRAM->iCount; iX > 0; iX--) |
|
3936 { |
|
3937 *pOut++ = mng_get_uint32 (pRawdata); |
|
3938 pRawdata += 4; |
|
3939 } |
|
3940 } |
|
3941 #else |
|
3942 MNG_COPY (pFRAM->pSyncids, pRawdata, pFRAM->iCount * 4); |
|
3943 #endif /* !MNG_BIGENDIAN_SUPPORTED */ |
|
3944 } |
|
3945 } |
|
3946 |
|
3947 #ifndef MNG_NO_OLD_VERSIONS |
|
3948 if (pData->bPreDraft48) /* old style input-stream ? */ |
|
3949 { |
|
3950 switch (pFRAM->iMode) /* fix the framing mode then */ |
|
3951 { |
|
3952 case 0: { break; } |
|
3953 case 1: { pFRAM->iMode = 3; break; } |
|
3954 case 2: { pFRAM->iMode = 4; break; } |
|
3955 case 3: { pFRAM->iMode = 1; break; } |
|
3956 case 4: { pFRAM->iMode = 1; break; } |
|
3957 case 5: { pFRAM->iMode = 2; break; } |
|
3958 default: { pFRAM->iMode = 1; break; } |
|
3959 } |
|
3960 } |
|
3961 #endif |
|
3962 |
|
3963 *piRawlen = 0; |
|
3964 |
|
3965 return MNG_NOERROR; |
|
3966 } |
|
3967 #endif |
|
3968 |
|
3969 /* ************************************************************************** */ |
|
3970 |
|
3971 #ifndef MNG_SKIPCHUNK_FRAM |
|
3972 MNG_C_SPECIALFUNC (mng_special_fram) |
|
3973 { |
|
3974 #ifdef MNG_SUPPORT_DISPLAY |
|
3975 return mng_create_ani_fram (pData, pChunk); |
|
3976 #else |
|
3977 return MNG_NOERROR; |
|
3978 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3979 } |
|
3980 #endif |
|
3981 |
|
3982 /* ************************************************************************** */ |
|
3983 |
|
3984 #ifndef MNG_SKIPCHUNK_MOVE |
|
3985 MNG_C_SPECIALFUNC (mng_special_move) |
|
3986 { |
|
3987 #ifdef MNG_SUPPORT_DISPLAY |
|
3988 return mng_create_ani_move (pData, pChunk); |
|
3989 #else |
|
3990 return MNG_NOERROR; |
|
3991 #endif /* MNG_SUPPORT_DISPLAY */ |
|
3992 } |
|
3993 #endif |
|
3994 |
|
3995 /* ************************************************************************** */ |
|
3996 |
|
3997 #ifndef MNG_SKIPCHUNK_CLIP |
|
3998 MNG_C_SPECIALFUNC (mng_special_clip) |
|
3999 { |
|
4000 #ifdef MNG_SUPPORT_DISPLAY |
|
4001 return mng_create_ani_clip (pData, pChunk); |
|
4002 #else |
|
4003 return MNG_NOERROR; |
|
4004 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4005 } |
|
4006 #endif |
|
4007 |
|
4008 /* ************************************************************************** */ |
|
4009 |
|
4010 #ifndef MNG_SKIPCHUNK_SHOW |
|
4011 MNG_C_SPECIALFUNC (mng_special_show) |
|
4012 { |
|
4013 #ifdef MNG_SUPPORT_DISPLAY |
|
4014 mng_retcode iRetcode; |
|
4015 |
|
4016 if (!((mng_showp)pChunk)->bEmpty) /* any data ? */ |
|
4017 { |
|
4018 if (!((mng_showp)pChunk)->bHaslastid) |
|
4019 ((mng_showp)pChunk)->iLastid = ((mng_showp)pChunk)->iFirstid; |
|
4020 |
|
4021 pData->iSHOWfromid = ((mng_showp)pChunk)->iFirstid; |
|
4022 pData->iSHOWtoid = ((mng_showp)pChunk)->iLastid; |
|
4023 pData->iSHOWmode = ((mng_showp)pChunk)->iMode; |
|
4024 } |
|
4025 else /* use defaults then */ |
|
4026 { |
|
4027 pData->iSHOWfromid = 1; |
|
4028 pData->iSHOWtoid = 65535; |
|
4029 pData->iSHOWmode = 2; |
|
4030 } |
|
4031 /* create a SHOW animation object */ |
|
4032 iRetcode = mng_create_ani_show (pData); |
|
4033 if (!iRetcode) /* go and do it! */ |
|
4034 iRetcode = mng_process_display_show (pData); |
|
4035 |
|
4036 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4037 |
|
4038 return iRetcode; |
|
4039 } |
|
4040 #endif |
|
4041 |
|
4042 /* ************************************************************************** */ |
|
4043 |
|
4044 #ifndef MNG_SKIPCHUNK_TERM |
|
4045 MNG_C_SPECIALFUNC (mng_special_term) |
|
4046 { |
|
4047 /* should be behind MHDR or SAVE !! */ |
|
4048 if ((!pData->bHasSAVE) && (pData->iChunkseq > 2)) |
|
4049 { |
|
4050 pData->bMisplacedTERM = MNG_TRUE; /* indicate we found a misplaced TERM */ |
|
4051 /* and send a warning signal!!! */ |
|
4052 MNG_WARNING (pData, MNG_SEQUENCEERROR); |
|
4053 } |
|
4054 |
|
4055 pData->bHasTERM = MNG_TRUE; |
|
4056 |
|
4057 if (pData->fProcessterm) /* inform the app ? */ |
|
4058 if (!pData->fProcessterm (((mng_handle)pData), |
|
4059 ((mng_termp)pChunk)->iTermaction, |
|
4060 ((mng_termp)pChunk)->iIteraction, |
|
4061 ((mng_termp)pChunk)->iDelay, |
|
4062 ((mng_termp)pChunk)->iItermax)) |
|
4063 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
4064 |
|
4065 #ifdef MNG_SUPPORT_DISPLAY |
|
4066 { /* create the TERM ani-object */ |
|
4067 mng_retcode iRetcode = mng_create_ani_term (pData, pChunk); |
|
4068 if (iRetcode) /* on error bail out */ |
|
4069 return iRetcode; |
|
4070 /* save for future reference */ |
|
4071 pData->pTermaniobj = pData->pLastaniobj; |
|
4072 } |
|
4073 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4074 |
|
4075 return MNG_NOERROR; /* done */ |
|
4076 } |
|
4077 #endif |
|
4078 |
|
4079 /* ************************************************************************** */ |
|
4080 |
|
4081 #ifndef MNG_SKIPCHUNK_SAVE |
|
4082 MNG_F_SPECIALFUNC (mng_save_entries) |
|
4083 { |
|
4084 mng_savep pSAVE = (mng_savep)pChunk; |
|
4085 mng_uint32 iRawlen = *piRawlen; |
|
4086 mng_uint8p pRawdata = *ppRawdata; |
|
4087 mng_save_entryp pEntry = MNG_NULL; |
|
4088 mng_uint32 iCount = 0; |
|
4089 mng_uint8 iOtype = *pRawdata; |
|
4090 mng_uint8 iEtype; |
|
4091 mng_uint8p pTemp; |
|
4092 mng_uint8p pNull; |
|
4093 mng_uint32 iLen; |
|
4094 mng_uint32 iOffset[2]; |
|
4095 mng_uint32 iStarttime[2]; |
|
4096 mng_uint32 iFramenr; |
|
4097 mng_uint32 iLayernr; |
|
4098 mng_uint32 iX; |
|
4099 mng_uint32 iNamesize; |
|
4100 |
|
4101 if ((iOtype != 4) && (iOtype != 8)) |
|
4102 MNG_ERROR (pData, MNG_INVOFFSETSIZE); |
|
4103 |
|
4104 pSAVE->iOffsettype = iOtype; |
|
4105 |
|
4106 for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */ |
|
4107 { |
|
4108 pTemp = pRawdata + 1; |
|
4109 iLen = iRawlen - 1; |
|
4110 |
|
4111 if (iX) /* second run ? */ |
|
4112 { |
|
4113 MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_save_entry))); |
|
4114 |
|
4115 pSAVE->iCount = iCount; |
|
4116 pSAVE->pEntries = pEntry; |
|
4117 } |
|
4118 |
|
4119 while (iLen) /* anything left ? */ |
|
4120 { |
|
4121 iEtype = *pTemp; /* entrytype */ |
|
4122 |
|
4123 if ((iEtype != 0) && (iEtype != 1) && (iEtype != 2) && (iEtype != 3)) |
|
4124 MNG_ERROR (pData, MNG_INVENTRYTYPE); |
|
4125 |
|
4126 pTemp++; |
|
4127 |
|
4128 if (iEtype > 1) |
|
4129 { |
|
4130 iOffset [0] = 0; |
|
4131 iOffset [1] = 0; |
|
4132 iStarttime [0] = 0; |
|
4133 iStarttime [1] = 0; |
|
4134 iLayernr = 0; |
|
4135 iFramenr = 0; |
|
4136 } |
|
4137 else |
|
4138 { |
|
4139 if (iOtype == 4) |
|
4140 { |
|
4141 iOffset [0] = 0; |
|
4142 iOffset [1] = mng_get_uint32 (pTemp); |
|
4143 |
|
4144 pTemp += 4; |
|
4145 } |
|
4146 else |
|
4147 { |
|
4148 iOffset [0] = mng_get_uint32 (pTemp); |
|
4149 iOffset [1] = mng_get_uint32 (pTemp+4); |
|
4150 |
|
4151 pTemp += 8; |
|
4152 } |
|
4153 |
|
4154 if (iEtype > 0) |
|
4155 { |
|
4156 iStarttime [0] = 0; |
|
4157 iStarttime [1] = 0; |
|
4158 iLayernr = 0; |
|
4159 iFramenr = 0; |
|
4160 } |
|
4161 else |
|
4162 { |
|
4163 if (iOtype == 4) |
|
4164 { |
|
4165 iStarttime [0] = 0; |
|
4166 iStarttime [1] = mng_get_uint32 (pTemp+0); |
|
4167 iLayernr = mng_get_uint32 (pTemp+4); |
|
4168 iFramenr = mng_get_uint32 (pTemp+8); |
|
4169 |
|
4170 pTemp += 12; |
|
4171 } |
|
4172 else |
|
4173 { |
|
4174 iStarttime [0] = mng_get_uint32 (pTemp+0); |
|
4175 iStarttime [1] = mng_get_uint32 (pTemp+4); |
|
4176 iLayernr = mng_get_uint32 (pTemp+8); |
|
4177 iFramenr = mng_get_uint32 (pTemp+12); |
|
4178 |
|
4179 pTemp += 16; |
|
4180 } |
|
4181 } |
|
4182 } |
|
4183 |
|
4184 pNull = pTemp; /* get the name length */ |
|
4185 while (*pNull) |
|
4186 pNull++; |
|
4187 |
|
4188 if ((pNull - pRawdata) > (mng_int32)iRawlen) |
|
4189 { |
|
4190 iNamesize = iLen; /* no null found; so end of SAVE */ |
|
4191 iLen = 0; |
|
4192 } |
|
4193 else |
|
4194 { |
|
4195 iNamesize = pNull - pTemp; /* should be another entry */ |
|
4196 iLen -= iNamesize; |
|
4197 |
|
4198 if (!iLen) /* must not end with a null ! */ |
|
4199 MNG_ERROR (pData, MNG_ENDWITHNULL); |
|
4200 } |
|
4201 |
|
4202 if (!pEntry) |
|
4203 { |
|
4204 iCount++; |
|
4205 } |
|
4206 else |
|
4207 { |
|
4208 pEntry->iEntrytype = iEtype; |
|
4209 pEntry->iOffset [0] = iOffset [0]; |
|
4210 pEntry->iOffset [1] = iOffset [1]; |
|
4211 pEntry->iStarttime [0] = iStarttime [0]; |
|
4212 pEntry->iStarttime [1] = iStarttime [1]; |
|
4213 pEntry->iLayernr = iLayernr; |
|
4214 pEntry->iFramenr = iFramenr; |
|
4215 pEntry->iNamesize = iNamesize; |
|
4216 |
|
4217 if (iNamesize) |
|
4218 { |
|
4219 MNG_ALLOC (pData, pEntry->zName, iNamesize+1); |
|
4220 MNG_COPY (pEntry->zName, pTemp, iNamesize); |
|
4221 } |
|
4222 |
|
4223 pEntry++; |
|
4224 } |
|
4225 |
|
4226 pTemp += iNamesize; |
|
4227 } |
|
4228 } |
|
4229 |
|
4230 *piRawlen = 0; |
|
4231 |
|
4232 return MNG_NOERROR; |
|
4233 } |
|
4234 #endif |
|
4235 |
|
4236 /* ************************************************************************** */ |
|
4237 |
|
4238 #ifndef MNG_SKIPCHUNK_SAVE |
|
4239 MNG_C_SPECIALFUNC (mng_special_save) |
|
4240 { |
|
4241 pData->bHasSAVE = MNG_TRUE; |
|
4242 |
|
4243 if (pData->fProcesssave) /* inform the application ? */ |
|
4244 { |
|
4245 mng_bool bOke = pData->fProcesssave ((mng_handle)pData); |
|
4246 if (!bOke) |
|
4247 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
4248 } |
|
4249 |
|
4250 #ifdef MNG_SUPPORT_DISPLAY |
|
4251 { |
|
4252 mng_retcode iRetcode; |
|
4253 |
|
4254 /* TODO: something with the parameters */ |
|
4255 |
|
4256 /* create a SAVE animation object */ |
|
4257 iRetcode = mng_create_ani_save (pData); |
|
4258 if (!iRetcode) /* process it */ |
|
4259 iRetcode = mng_process_display_save (pData); |
|
4260 if (iRetcode) /* on error bail out */ |
|
4261 return iRetcode; |
|
4262 } |
|
4263 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4264 |
|
4265 return MNG_NOERROR; /* done */ |
|
4266 } |
|
4267 #endif |
|
4268 |
|
4269 /* ************************************************************************** */ |
|
4270 |
|
4271 #ifndef MNG_SKIPCHUNK_SEEK |
|
4272 MNG_C_SPECIALFUNC (mng_special_seek) |
|
4273 { |
|
4274 mng_retcode iRetcode; |
|
4275 |
|
4276 #ifdef MNG_SUPPORT_DISPLAY |
|
4277 /* create a SEEK animation object */ |
|
4278 iRetcode = mng_create_ani_seek (pData, pChunk); |
|
4279 if (iRetcode) /* on error bail out */ |
|
4280 return iRetcode; |
|
4281 |
|
4282 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4283 |
|
4284 if (pData->fProcessseek) /* inform the app ? */ |
|
4285 if (!pData->fProcessseek ((mng_handle)pData, ((mng_seekp)pChunk)->zName)) |
|
4286 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
4287 |
|
4288 #ifdef MNG_SUPPORT_DISPLAY |
|
4289 return mng_process_display_seek (pData); |
|
4290 #else |
|
4291 return MNG_NOERROR; |
|
4292 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4293 } |
|
4294 #endif |
|
4295 |
|
4296 /* ************************************************************************** */ |
|
4297 |
|
4298 #ifndef MNG_SKIPCHUNK_eXPI |
|
4299 MNG_C_SPECIALFUNC (mng_special_expi) |
|
4300 { |
|
4301 #ifdef MNG_SUPPORT_DISPLAY |
|
4302 { |
|
4303 |
|
4304 |
|
4305 /* TODO: something !!! */ |
|
4306 |
|
4307 |
|
4308 } |
|
4309 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4310 |
|
4311 return MNG_NOERROR; /* done */ |
|
4312 } |
|
4313 #endif |
|
4314 |
|
4315 /* ************************************************************************** */ |
|
4316 |
|
4317 #ifndef MNG_SKIPCHUNK_fPRI |
|
4318 MNG_C_SPECIALFUNC (mng_special_fpri) |
|
4319 { |
|
4320 #ifdef MNG_SUPPORT_DISPLAY |
|
4321 { |
|
4322 |
|
4323 |
|
4324 /* TODO: something !!! */ |
|
4325 |
|
4326 |
|
4327 } |
|
4328 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4329 |
|
4330 return MNG_NOERROR; /* done */ |
|
4331 } |
|
4332 #endif |
|
4333 |
|
4334 /* ************************************************************************** */ |
|
4335 |
|
4336 #ifndef MNG_SKIPCHUNK_nEED |
|
4337 MNG_LOCAL mng_bool CheckKeyword (mng_datap pData, |
|
4338 mng_uint8p pKeyword) |
|
4339 { |
|
4340 mng_chunkid handled_chunks [] = |
|
4341 { |
|
4342 MNG_UINT_BACK, /* keep it sorted !!!! */ |
|
4343 MNG_UINT_BASI, |
|
4344 MNG_UINT_CLIP, |
|
4345 MNG_UINT_CLON, |
|
4346 #ifndef MNG_NO_DELTA_PNG |
|
4347 /* TODO: MNG_UINT_DBYK, */ |
|
4348 #endif |
|
4349 MNG_UINT_DEFI, |
|
4350 #ifndef MNG_NO_DELTA_PNG |
|
4351 MNG_UINT_DHDR, |
|
4352 #endif |
|
4353 MNG_UINT_DISC, |
|
4354 #ifndef MNG_NO_DELTA_PNG |
|
4355 /* TODO: MNG_UINT_DROP, */ |
|
4356 #endif |
|
4357 MNG_UINT_ENDL, |
|
4358 MNG_UINT_FRAM, |
|
4359 MNG_UINT_IDAT, |
|
4360 MNG_UINT_IEND, |
|
4361 MNG_UINT_IHDR, |
|
4362 #ifndef MNG_NO_DELTA_PNG |
|
4363 #ifdef MNG_INCLUDE_JNG |
|
4364 MNG_UINT_IJNG, |
|
4365 #endif |
|
4366 MNG_UINT_IPNG, |
|
4367 #endif |
|
4368 #ifdef MNG_INCLUDE_JNG |
|
4369 MNG_UINT_JDAA, |
|
4370 MNG_UINT_JDAT, |
|
4371 MNG_UINT_JHDR, |
|
4372 /* TODO: MNG_UINT_JSEP, */ |
|
4373 MNG_UINT_JdAA, |
|
4374 #endif |
|
4375 MNG_UINT_LOOP, |
|
4376 MNG_UINT_MAGN, |
|
4377 MNG_UINT_MEND, |
|
4378 MNG_UINT_MHDR, |
|
4379 MNG_UINT_MOVE, |
|
4380 /* TODO: MNG_UINT_ORDR, */ |
|
4381 MNG_UINT_PAST, |
|
4382 MNG_UINT_PLTE, |
|
4383 #ifndef MNG_NO_DELTA_PNG |
|
4384 MNG_UINT_PPLT, |
|
4385 MNG_UINT_PROM, |
|
4386 #endif |
|
4387 MNG_UINT_SAVE, |
|
4388 MNG_UINT_SEEK, |
|
4389 MNG_UINT_SHOW, |
|
4390 MNG_UINT_TERM, |
|
4391 MNG_UINT_bKGD, |
|
4392 MNG_UINT_cHRM, |
|
4393 /* TODO: MNG_UINT_eXPI, */ |
|
4394 MNG_UINT_evNT, |
|
4395 /* TODO: MNG_UINT_fPRI, */ |
|
4396 MNG_UINT_gAMA, |
|
4397 /* TODO: MNG_UINT_hIST, */ |
|
4398 MNG_UINT_iCCP, |
|
4399 MNG_UINT_iTXt, |
|
4400 MNG_UINT_nEED, |
|
4401 /* TODO: MNG_UINT_oFFs, */ |
|
4402 /* TODO: MNG_UINT_pCAL, */ |
|
4403 /* TODO: MNG_UINT_pHYg, */ |
|
4404 /* TODO: MNG_UINT_pHYs, */ |
|
4405 /* TODO: MNG_UINT_sBIT, */ |
|
4406 /* TODO: MNG_UINT_sCAL, */ |
|
4407 /* TODO: MNG_UINT_sPLT, */ |
|
4408 MNG_UINT_sRGB, |
|
4409 MNG_UINT_tEXt, |
|
4410 MNG_UINT_tIME, |
|
4411 MNG_UINT_tRNS, |
|
4412 MNG_UINT_zTXt, |
|
4413 }; |
|
4414 |
|
4415 mng_bool bOke = MNG_FALSE; |
|
4416 |
|
4417 if (pData->fProcessneed) /* does the app handle it ? */ |
|
4418 bOke = pData->fProcessneed ((mng_handle)pData, (mng_pchar)pKeyword); |
|
4419 |
|
4420 if (!bOke) |
|
4421 { /* find the keyword length */ |
|
4422 mng_uint8p pNull = pKeyword; |
|
4423 while (*pNull) |
|
4424 pNull++; |
|
4425 |
|
4426 if ((pNull - pKeyword) == 4) /* test a chunk ? */ |
|
4427 { /* get the chunk-id */ |
|
4428 mng_chunkid iChunkid = (*pKeyword << 24) + (*(pKeyword+1) << 16) + |
|
4429 (*(pKeyword+2) << 8) + (*(pKeyword+3) ); |
|
4430 /* binary search variables */ |
|
4431 mng_int32 iTop, iLower, iUpper, iMiddle; |
|
4432 /* determine max index of table */ |
|
4433 iTop = (sizeof (handled_chunks) / sizeof (handled_chunks [0])) - 1; |
|
4434 |
|
4435 /* binary search; with 52 chunks, worst-case is 7 comparisons */ |
|
4436 iLower = 0; |
|
4437 iMiddle = iTop >> 1; |
|
4438 iUpper = iTop; |
|
4439 |
|
4440 do /* the binary search itself */ |
|
4441 { |
|
4442 if (handled_chunks [iMiddle] < iChunkid) |
|
4443 iLower = iMiddle + 1; |
|
4444 else if (handled_chunks [iMiddle] > iChunkid) |
|
4445 iUpper = iMiddle - 1; |
|
4446 else |
|
4447 { |
|
4448 bOke = MNG_TRUE; |
|
4449 break; |
|
4450 } |
|
4451 |
|
4452 iMiddle = (iLower + iUpper) >> 1; |
|
4453 } |
|
4454 while (iLower <= iUpper); |
|
4455 } |
|
4456 /* test draft ? */ |
|
4457 if ((!bOke) && ((pNull - pKeyword) == 8) && |
|
4458 (*pKeyword == 'd') && (*(pKeyword+1) == 'r') && |
|
4459 (*(pKeyword+2) == 'a') && (*(pKeyword+3) == 'f') && |
|
4460 (*(pKeyword+4) == 't') && (*(pKeyword+5) == ' ')) |
|
4461 { |
|
4462 mng_uint32 iDraft; |
|
4463 |
|
4464 iDraft = (*(pKeyword+6) - '0') * 10 + (*(pKeyword+7) - '0'); |
|
4465 bOke = (mng_bool)(iDraft <= MNG_MNG_DRAFT); |
|
4466 } |
|
4467 /* test MNG 1.0/1.1 ? */ |
|
4468 if ((!bOke) && ((pNull - pKeyword) == 7) && |
|
4469 (*pKeyword == 'M') && (*(pKeyword+1) == 'N') && |
|
4470 (*(pKeyword+2) == 'G') && (*(pKeyword+3) == '-') && |
|
4471 (*(pKeyword+4) == '1') && (*(pKeyword+5) == '.') && |
|
4472 ((*(pKeyword+6) == '0') || (*(pKeyword+6) == '1'))) |
|
4473 bOke = MNG_TRUE; |
|
4474 /* test CACHEOFF ? */ |
|
4475 if ((!bOke) && ((pNull - pKeyword) == 8) && |
|
4476 (*pKeyword == 'C') && (*(pKeyword+1) == 'A') && |
|
4477 (*(pKeyword+2) == 'C') && (*(pKeyword+3) == 'H') && |
|
4478 (*(pKeyword+4) == 'E') && (*(pKeyword+5) == 'O') && |
|
4479 (*(pKeyword+6) == 'F') && (*(pKeyword+7) == 'F')) |
|
4480 { |
|
4481 if (!pData->pFirstaniobj) /* only if caching hasn't started yet ! */ |
|
4482 { |
|
4483 bOke = MNG_TRUE; |
|
4484 pData->bCacheplayback = MNG_FALSE; |
|
4485 pData->bStorechunks = MNG_FALSE; |
|
4486 } |
|
4487 } |
|
4488 } |
|
4489 |
|
4490 return bOke; |
|
4491 } |
|
4492 #endif |
|
4493 |
|
4494 /* ************************************************************************** */ |
|
4495 |
|
4496 #ifndef MNG_SKIPCHUNK_nEED |
|
4497 MNG_C_SPECIALFUNC (mng_special_need) |
|
4498 { |
|
4499 /* let's check it */ |
|
4500 mng_bool bOke = MNG_TRUE; |
|
4501 mng_uint8p pNull, pTemp, pMax; |
|
4502 |
|
4503 pTemp = (mng_uint8p)((mng_needp)pChunk)->zKeywords; |
|
4504 pMax = (mng_uint8p)(pTemp + ((mng_needp)pChunk)->iKeywordssize); |
|
4505 pNull = pTemp; |
|
4506 while (*pNull) |
|
4507 pNull++; |
|
4508 |
|
4509 while ((bOke) && (pNull < pMax)) |
|
4510 { |
|
4511 bOke = CheckKeyword (pData, pTemp); |
|
4512 pTemp = pNull + 1; |
|
4513 pNull = pTemp; |
|
4514 while (*pNull) |
|
4515 pNull++; |
|
4516 } |
|
4517 |
|
4518 if (bOke) |
|
4519 bOke = CheckKeyword (pData, pTemp); |
|
4520 |
|
4521 if (!bOke) |
|
4522 MNG_ERROR (pData, MNG_UNSUPPORTEDNEED); |
|
4523 |
|
4524 return MNG_NOERROR; /* done */ |
|
4525 } |
|
4526 #endif |
|
4527 |
|
4528 /* ************************************************************************** */ |
|
4529 |
|
4530 #ifndef MNG_SKIPCHUNK_pHYg |
|
4531 MNG_C_SPECIALFUNC (mng_special_phyg) |
|
4532 { |
|
4533 #ifdef MNG_SUPPORT_DISPLAY |
|
4534 { |
|
4535 |
|
4536 |
|
4537 /* TODO: something !!! */ |
|
4538 |
|
4539 |
|
4540 } |
|
4541 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4542 |
|
4543 return MNG_NOERROR; /* done */ |
|
4544 } |
|
4545 #endif |
|
4546 |
|
4547 /* ************************************************************************** */ |
|
4548 |
|
4549 #ifndef MNG_NO_DELTA_PNG |
|
4550 MNG_C_SPECIALFUNC (mng_special_dhdr) |
|
4551 { |
|
4552 if ((((mng_dhdrp)pChunk)->iDeltatype == MNG_DELTATYPE_REPLACE) && (((mng_dhdrp)pChunk)->bHasblockloc)) |
|
4553 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4554 if ((((mng_dhdrp)pChunk)->iDeltatype == MNG_DELTATYPE_NOCHANGE) && (((mng_dhdrp)pChunk)->bHasblocksize)) |
|
4555 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4556 |
|
4557 pData->bHasDHDR = MNG_TRUE; /* inside a DHDR-IEND block now */ |
|
4558 pData->iDeltatype = ((mng_dhdrp)pChunk)->iDeltatype; |
|
4559 |
|
4560 pData->iImagelevel++; /* one level deeper */ |
|
4561 |
|
4562 #ifdef MNG_SUPPORT_DISPLAY |
|
4563 return mng_create_ani_dhdr (pData, pChunk); |
|
4564 #else |
|
4565 return MNG_NOERROR; |
|
4566 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4567 } |
|
4568 #endif |
|
4569 |
|
4570 /* ************************************************************************** */ |
|
4571 |
|
4572 #ifndef MNG_NO_DELTA_PNG |
|
4573 MNG_C_SPECIALFUNC (mng_special_prom) |
|
4574 { |
|
4575 if ((((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_GRAY ) && |
|
4576 (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_RGB ) && |
|
4577 (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_INDEXED) && |
|
4578 (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_GRAYA ) && |
|
4579 (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_RGBA ) ) |
|
4580 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE); |
|
4581 |
|
4582 #ifdef MNG_NO_16BIT_SUPPORT |
|
4583 if (((mng_promp)pChunk)->iSampledepth == MNG_BITDEPTH_16 ) |
|
4584 ((mng_promp)pChunk)->iSampledepth = MNG_BITDEPTH_8; |
|
4585 #endif |
|
4586 |
|
4587 if ((((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_1 ) && |
|
4588 (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_2 ) && |
|
4589 (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_4 ) && |
|
4590 (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_8 ) |
|
4591 #ifndef MNG_NO_16BIT_SUPPORT |
|
4592 && (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_16) |
|
4593 #endif |
|
4594 ) |
|
4595 MNG_ERROR (pData, MNG_INVSAMPLEDEPTH); |
|
4596 |
|
4597 #ifdef MNG_SUPPORT_DISPLAY |
|
4598 { |
|
4599 mng_retcode iRetcode = mng_create_ani_prom (pData, pChunk); |
|
4600 if (iRetcode) /* on error bail out */ |
|
4601 return iRetcode; |
|
4602 } |
|
4603 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4604 |
|
4605 return MNG_NOERROR; /* done */ |
|
4606 } |
|
4607 #endif |
|
4608 |
|
4609 /* ************************************************************************** */ |
|
4610 |
|
4611 #ifndef MNG_NO_DELTA_PNG |
|
4612 MNG_C_SPECIALFUNC (mng_special_ipng) |
|
4613 { |
|
4614 #ifdef MNG_SUPPORT_DISPLAY |
|
4615 mng_retcode iRetcode = mng_create_ani_ipng (pData); |
|
4616 if (!iRetcode) /* process it */ |
|
4617 iRetcode = mng_process_display_ipng (pData); |
|
4618 if (iRetcode) /* on error bail out */ |
|
4619 return iRetcode; |
|
4620 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4621 |
|
4622 return MNG_NOERROR; /* done */ |
|
4623 } |
|
4624 #endif |
|
4625 |
|
4626 /* ************************************************************************** */ |
|
4627 |
|
4628 #ifndef MNG_NO_DELTA_PNG |
|
4629 MNG_F_SPECIALFUNC (mng_pplt_entries) |
|
4630 { |
|
4631 mng_ppltp pPPLT = (mng_ppltp)pChunk; |
|
4632 mng_uint32 iRawlen = *piRawlen; |
|
4633 mng_uint8p pRawdata = *ppRawdata; |
|
4634 mng_uint8 iDeltatype = pPPLT->iDeltatype; |
|
4635 mng_uint32 iMax = 0; |
|
4636 mng_int32 iX, iY, iM; |
|
4637 mng_rgbpaltab aIndexentries; |
|
4638 mng_uint8arr aAlphaentries; |
|
4639 mng_uint8arr aUsedentries; |
|
4640 /* must be indexed color ! */ |
|
4641 if (pData->iColortype != MNG_COLORTYPE_INDEXED) |
|
4642 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE); |
|
4643 |
|
4644 for (iY = 255; iY >= 0; iY--) /* reset arrays */ |
|
4645 { |
|
4646 aIndexentries [iY].iRed = 0; |
|
4647 aIndexentries [iY].iGreen = 0; |
|
4648 aIndexentries [iY].iBlue = 0; |
|
4649 aAlphaentries [iY] = 255; |
|
4650 aUsedentries [iY] = 0; |
|
4651 } |
|
4652 |
|
4653 while (iRawlen) /* as long as there are entries left ... */ |
|
4654 { |
|
4655 mng_uint32 iDiff; |
|
4656 |
|
4657 if (iRawlen < 2) |
|
4658 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4659 |
|
4660 iX = (mng_int32)(*pRawdata); /* get start and end index */ |
|
4661 iM = (mng_int32)(*(pRawdata+1)); |
|
4662 |
|
4663 if (iM < iX) |
|
4664 MNG_ERROR (pData, MNG_INVALIDINDEX); |
|
4665 |
|
4666 if (iM >= (mng_int32) iMax) /* determine highest used index */ |
|
4667 iMax = iM + 1; |
|
4668 |
|
4669 pRawdata += 2; |
|
4670 iRawlen -= 2; |
|
4671 iDiff = (iM - iX + 1); |
|
4672 if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) || |
|
4673 (iDeltatype == MNG_DELTATYPE_DELTARGB ) ) |
|
4674 iDiff = iDiff * 3; |
|
4675 else |
|
4676 if ((iDeltatype == MNG_DELTATYPE_REPLACERGBA) || |
|
4677 (iDeltatype == MNG_DELTATYPE_DELTARGBA ) ) |
|
4678 iDiff = iDiff * 4; |
|
4679 |
|
4680 if (iRawlen < iDiff) |
|
4681 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4682 |
|
4683 if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) || |
|
4684 (iDeltatype == MNG_DELTATYPE_DELTARGB ) ) |
|
4685 { |
|
4686 for (iY = iX; iY <= iM; iY++) |
|
4687 { |
|
4688 aIndexentries [iY].iRed = *pRawdata; |
|
4689 aIndexentries [iY].iGreen = *(pRawdata+1); |
|
4690 aIndexentries [iY].iBlue = *(pRawdata+2); |
|
4691 aUsedentries [iY] = 1; |
|
4692 |
|
4693 pRawdata += 3; |
|
4694 iRawlen -= 3; |
|
4695 } |
|
4696 } |
|
4697 else |
|
4698 if ((iDeltatype == MNG_DELTATYPE_REPLACEALPHA) || |
|
4699 (iDeltatype == MNG_DELTATYPE_DELTAALPHA ) ) |
|
4700 { |
|
4701 for (iY = iX; iY <= iM; iY++) |
|
4702 { |
|
4703 aAlphaentries [iY] = *pRawdata; |
|
4704 aUsedentries [iY] = 1; |
|
4705 |
|
4706 pRawdata++; |
|
4707 iRawlen--; |
|
4708 } |
|
4709 } |
|
4710 else |
|
4711 { |
|
4712 for (iY = iX; iY <= iM; iY++) |
|
4713 { |
|
4714 aIndexentries [iY].iRed = *pRawdata; |
|
4715 aIndexentries [iY].iGreen = *(pRawdata+1); |
|
4716 aIndexentries [iY].iBlue = *(pRawdata+2); |
|
4717 aAlphaentries [iY] = *(pRawdata+3); |
|
4718 aUsedentries [iY] = 1; |
|
4719 |
|
4720 pRawdata += 4; |
|
4721 iRawlen -= 4; |
|
4722 } |
|
4723 } |
|
4724 } |
|
4725 |
|
4726 switch (pData->iBitdepth) /* check maximum allowed entries for bitdepth */ |
|
4727 { |
|
4728 case MNG_BITDEPTH_1 : { |
|
4729 if (iMax > 2) |
|
4730 MNG_ERROR (pData, MNG_INVALIDINDEX); |
|
4731 break; |
|
4732 } |
|
4733 case MNG_BITDEPTH_2 : { |
|
4734 if (iMax > 4) |
|
4735 MNG_ERROR (pData, MNG_INVALIDINDEX); |
|
4736 break; |
|
4737 } |
|
4738 case MNG_BITDEPTH_4 : { |
|
4739 if (iMax > 16) |
|
4740 MNG_ERROR (pData, MNG_INVALIDINDEX); |
|
4741 break; |
|
4742 } |
|
4743 } |
|
4744 |
|
4745 pPPLT->iCount = iMax; |
|
4746 |
|
4747 for (iY = 255; iY >= 0; iY--) |
|
4748 { |
|
4749 pPPLT->aEntries [iY].iRed = aIndexentries [iY].iRed; |
|
4750 pPPLT->aEntries [iY].iGreen = aIndexentries [iY].iGreen; |
|
4751 pPPLT->aEntries [iY].iBlue = aIndexentries [iY].iBlue; |
|
4752 pPPLT->aEntries [iY].iAlpha = aAlphaentries [iY]; |
|
4753 pPPLT->aEntries [iY].bUsed = (mng_bool)(aUsedentries [iY]); |
|
4754 } |
|
4755 |
|
4756 { /* create animation object */ |
|
4757 mng_retcode iRetcode = mng_create_ani_pplt (pData, iDeltatype, iMax, |
|
4758 aIndexentries, aAlphaentries, |
|
4759 aUsedentries); |
|
4760 if (iRetcode) |
|
4761 return iRetcode; |
|
4762 } |
|
4763 |
|
4764 *piRawlen = 0; |
|
4765 |
|
4766 return MNG_NOERROR; |
|
4767 } |
|
4768 #endif |
|
4769 |
|
4770 /* ************************************************************************** */ |
|
4771 |
|
4772 #ifndef MNG_NO_DELTA_PNG |
|
4773 MNG_C_SPECIALFUNC (mng_special_pplt) |
|
4774 { |
|
4775 return MNG_NOERROR; |
|
4776 } |
|
4777 #endif |
|
4778 |
|
4779 /* ************************************************************************** */ |
|
4780 |
|
4781 #ifndef MNG_NO_DELTA_PNG |
|
4782 #ifdef MNG_INCLUDE_JNG |
|
4783 MNG_C_SPECIALFUNC (mng_special_ijng) |
|
4784 { |
|
4785 #ifdef MNG_SUPPORT_DISPLAY |
|
4786 mng_retcode iRetcode = mng_create_ani_ijng (pData); |
|
4787 if (!iRetcode) /* process it */ |
|
4788 iRetcode = mng_process_display_ijng (pData); |
|
4789 return iRetcode; |
|
4790 #else |
|
4791 return MNG_NOERROR; /* done */ |
|
4792 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4793 } |
|
4794 #endif |
|
4795 #endif |
|
4796 |
|
4797 /* ************************************************************************** */ |
|
4798 |
|
4799 #ifndef MNG_NO_DELTA_PNG |
|
4800 MNG_F_SPECIALFUNC (mng_drop_entries) |
|
4801 { |
|
4802 mng_dropp pDROP = (mng_dropp)pChunk; |
|
4803 mng_uint32 iRawlen = *piRawlen; |
|
4804 mng_uint8p pRawdata = *ppRawdata; |
|
4805 mng_uint32 iX; |
|
4806 mng_uint32p pEntry; |
|
4807 /* check length */ |
|
4808 if ((iRawlen < 4) || ((iRawlen % 4) != 0)) |
|
4809 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4810 |
|
4811 MNG_ALLOC (pData, pEntry, iRawlen); |
|
4812 pDROP->iCount = iRawlen / 4; |
|
4813 pDROP->pChunknames = (mng_ptr)pEntry; |
|
4814 |
|
4815 for (iX = pDROP->iCount; iX > 0; iX--) |
|
4816 { |
|
4817 *pEntry++ = mng_get_uint32 (pRawdata); |
|
4818 pRawdata += 4; |
|
4819 } |
|
4820 |
|
4821 *piRawlen = 0; |
|
4822 |
|
4823 return MNG_NOERROR; |
|
4824 } |
|
4825 #endif |
|
4826 |
|
4827 /* ************************************************************************** */ |
|
4828 |
|
4829 #ifndef MNG_NO_DELTA_PNG |
|
4830 MNG_C_SPECIALFUNC (mng_special_drop) |
|
4831 { |
|
4832 #ifdef MNG_SUPPORT_DISPLAY |
|
4833 { |
|
4834 |
|
4835 |
|
4836 /* TODO: something !!! */ |
|
4837 |
|
4838 |
|
4839 } |
|
4840 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4841 |
|
4842 return MNG_NOERROR; /* done */ |
|
4843 } |
|
4844 #endif |
|
4845 |
|
4846 /* ************************************************************************** */ |
|
4847 |
|
4848 #ifndef MNG_NO_DELTA_PNG |
|
4849 #ifndef MNG_SKIPCHUNK_DBYK |
|
4850 MNG_C_SPECIALFUNC (mng_special_dbyk) |
|
4851 { |
|
4852 #ifdef MNG_SUPPORT_DISPLAY |
|
4853 { |
|
4854 |
|
4855 |
|
4856 /* TODO: something !!! */ |
|
4857 |
|
4858 |
|
4859 } |
|
4860 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4861 |
|
4862 return MNG_NOERROR; /* done */ |
|
4863 } |
|
4864 #endif |
|
4865 #endif |
|
4866 |
|
4867 /* ************************************************************************** */ |
|
4868 |
|
4869 #ifndef MNG_NO_DELTA_PNG |
|
4870 #ifndef MNG_SKIPCHUNK_ORDR |
|
4871 MNG_F_SPECIALFUNC (mng_ordr_entries) |
|
4872 { |
|
4873 mng_ordrp pORDR = (mng_ordrp)pChunk; |
|
4874 mng_uint32 iRawlen = *piRawlen; |
|
4875 mng_uint8p pRawdata = *ppRawdata; |
|
4876 mng_uint32 iX; |
|
4877 mng_ordr_entryp pEntry; |
|
4878 /* check length */ |
|
4879 if ((iRawlen < 5) || ((iRawlen % 5) != 0)) |
|
4880 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4881 |
|
4882 MNG_ALLOC (pData, pEntry, iRawlen); |
|
4883 pORDR->iCount = iRawlen / 5; |
|
4884 pORDR->pEntries = (mng_ptr)pEntry; |
|
4885 |
|
4886 for (iX = pORDR->iCount; iX > 0; iX--) |
|
4887 { |
|
4888 pEntry->iChunkname = mng_get_uint32 (pRawdata); |
|
4889 pEntry->iOrdertype = *(pRawdata+4); |
|
4890 pEntry++; |
|
4891 pRawdata += 5; |
|
4892 } |
|
4893 |
|
4894 *piRawlen = 0; |
|
4895 |
|
4896 return MNG_NOERROR; |
|
4897 } |
|
4898 #endif |
|
4899 #endif |
|
4900 |
|
4901 /* ************************************************************************** */ |
|
4902 |
|
4903 #ifndef MNG_NO_DELTA_PNG |
|
4904 #ifndef MNG_SKIPCHUNK_ORDR |
|
4905 MNG_C_SPECIALFUNC (mng_special_ordr) |
|
4906 { |
|
4907 #ifdef MNG_SUPPORT_DISPLAY |
|
4908 { |
|
4909 |
|
4910 |
|
4911 /* TODO: something !!! */ |
|
4912 |
|
4913 |
|
4914 } |
|
4915 #endif /* MNG_SUPPORT_DISPLAY */ |
|
4916 |
|
4917 return MNG_NOERROR; /* done */ |
|
4918 } |
|
4919 #endif |
|
4920 #endif |
|
4921 |
|
4922 /* ************************************************************************** */ |
|
4923 |
|
4924 #ifndef MNG_SKIPCHUNK_MAGN |
|
4925 MNG_F_SPECIALFUNC (mng_debunk_magn) |
|
4926 { |
|
4927 mng_magnp pMAGN = (mng_magnp)pChunk; |
|
4928 mng_uint32 iRawlen = *piRawlen; |
|
4929 mng_uint8p pRawdata = *ppRawdata; |
|
4930 mng_bool bFaulty; |
|
4931 /* check length */ |
|
4932 if (iRawlen > 20) |
|
4933 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
4934 |
|
4935 /* following is an ugly hack to allow faulty layout caused by previous |
|
4936 versions of libmng and MNGeye, which wrote MAGN with a 16-bit |
|
4937 MethodX/MethodY (as opposed to the proper 8-bit as defined in the spec!) */ |
|
4938 |
|
4939 if ((iRawlen == 6) || (iRawlen == 8) || (iRawlen == 10) || (iRawlen == 12) || |
|
4940 (iRawlen == 14) || (iRawlen == 16) || (iRawlen == 20)) |
|
4941 bFaulty = MNG_TRUE; /* these lengths are all wrong */ |
|
4942 else /* length 18 can be right or wrong !!! */ |
|
4943 if ((iRawlen == 18) && (mng_get_uint16 (pRawdata+4) <= 5) && |
|
4944 (mng_get_uint16 (pRawdata+6) < 256) && |
|
4945 (mng_get_uint16 (pRawdata+8) < 256) && |
|
4946 (mng_get_uint16 (pRawdata+10) < 256) && |
|
4947 (mng_get_uint16 (pRawdata+12) < 256) && |
|
4948 (mng_get_uint16 (pRawdata+14) < 256) && |
|
4949 (mng_get_uint16 (pRawdata+16) < 256)) |
|
4950 bFaulty = MNG_TRUE; /* this is very likely the wrong layout */ |
|
4951 else |
|
4952 bFaulty = MNG_FALSE; /* all other cases are handled as right */ |
|
4953 |
|
4954 if (bFaulty) /* wrong layout ? */ |
|
4955 { |
|
4956 if (iRawlen > 0) /* get the fields */ |
|
4957 pMAGN->iFirstid = mng_get_uint16 (pRawdata); |
|
4958 else |
|
4959 pMAGN->iFirstid = 0; |
|
4960 |
|
4961 if (iRawlen > 2) |
|
4962 pMAGN->iLastid = mng_get_uint16 (pRawdata+2); |
|
4963 else |
|
4964 pMAGN->iLastid = pMAGN->iFirstid; |
|
4965 |
|
4966 if (iRawlen > 4) |
|
4967 pMAGN->iMethodX = (mng_uint8)(mng_get_uint16 (pRawdata+4)); |
|
4968 else |
|
4969 pMAGN->iMethodX = 0; |
|
4970 |
|
4971 if (iRawlen > 6) |
|
4972 pMAGN->iMX = mng_get_uint16 (pRawdata+6); |
|
4973 else |
|
4974 pMAGN->iMX = 1; |
|
4975 |
|
4976 if (iRawlen > 8) |
|
4977 pMAGN->iMY = mng_get_uint16 (pRawdata+8); |
|
4978 else |
|
4979 pMAGN->iMY = pMAGN->iMX; |
|
4980 |
|
4981 if (iRawlen > 10) |
|
4982 pMAGN->iML = mng_get_uint16 (pRawdata+10); |
|
4983 else |
|
4984 pMAGN->iML = pMAGN->iMX; |
|
4985 |
|
4986 if (iRawlen > 12) |
|
4987 pMAGN->iMR = mng_get_uint16 (pRawdata+12); |
|
4988 else |
|
4989 pMAGN->iMR = pMAGN->iMX; |
|
4990 |
|
4991 if (iRawlen > 14) |
|
4992 pMAGN->iMT = mng_get_uint16 (pRawdata+14); |
|
4993 else |
|
4994 pMAGN->iMT = pMAGN->iMY; |
|
4995 |
|
4996 if (iRawlen > 16) |
|
4997 pMAGN->iMB = mng_get_uint16 (pRawdata+16); |
|
4998 else |
|
4999 pMAGN->iMB = pMAGN->iMY; |
|
5000 |
|
5001 if (iRawlen > 18) |
|
5002 pMAGN->iMethodY = (mng_uint8)(mng_get_uint16 (pRawdata+18)); |
|
5003 else |
|
5004 pMAGN->iMethodY = pMAGN->iMethodX; |
|
5005 } |
|
5006 else /* proper layout !!!! */ |
|
5007 { |
|
5008 if (iRawlen > 0) /* get the fields */ |
|
5009 pMAGN->iFirstid = mng_get_uint16 (pRawdata); |
|
5010 else |
|
5011 pMAGN->iFirstid = 0; |
|
5012 |
|
5013 if (iRawlen > 2) |
|
5014 pMAGN->iLastid = mng_get_uint16 (pRawdata+2); |
|
5015 else |
|
5016 pMAGN->iLastid = pMAGN->iFirstid; |
|
5017 |
|
5018 if (iRawlen > 4) |
|
5019 pMAGN->iMethodX = *(pRawdata+4); |
|
5020 else |
|
5021 pMAGN->iMethodX = 0; |
|
5022 |
|
5023 if (iRawlen > 5) |
|
5024 pMAGN->iMX = mng_get_uint16 (pRawdata+5); |
|
5025 else |
|
5026 pMAGN->iMX = 1; |
|
5027 |
|
5028 if (iRawlen > 7) |
|
5029 pMAGN->iMY = mng_get_uint16 (pRawdata+7); |
|
5030 else |
|
5031 pMAGN->iMY = pMAGN->iMX; |
|
5032 |
|
5033 if (iRawlen > 9) |
|
5034 pMAGN->iML = mng_get_uint16 (pRawdata+9); |
|
5035 else |
|
5036 pMAGN->iML = pMAGN->iMX; |
|
5037 |
|
5038 if (iRawlen > 11) |
|
5039 pMAGN->iMR = mng_get_uint16 (pRawdata+11); |
|
5040 else |
|
5041 pMAGN->iMR = pMAGN->iMX; |
|
5042 |
|
5043 if (iRawlen > 13) |
|
5044 pMAGN->iMT = mng_get_uint16 (pRawdata+13); |
|
5045 else |
|
5046 pMAGN->iMT = pMAGN->iMY; |
|
5047 |
|
5048 if (iRawlen > 15) |
|
5049 pMAGN->iMB = mng_get_uint16 (pRawdata+15); |
|
5050 else |
|
5051 pMAGN->iMB = pMAGN->iMY; |
|
5052 |
|
5053 if (iRawlen > 17) |
|
5054 pMAGN->iMethodY = *(pRawdata+17); |
|
5055 else |
|
5056 pMAGN->iMethodY = pMAGN->iMethodX; |
|
5057 } |
|
5058 /* check field validity */ |
|
5059 if ((pMAGN->iMethodX > 5) || (pMAGN->iMethodY > 5)) |
|
5060 MNG_ERROR (pData, MNG_INVALIDMETHOD); |
|
5061 |
|
5062 *piRawlen = 0; |
|
5063 |
|
5064 return MNG_NOERROR; |
|
5065 } |
|
5066 #endif |
|
5067 |
|
5068 /* ************************************************************************** */ |
|
5069 |
|
5070 #ifndef MNG_SKIPCHUNK_MAGN |
|
5071 MNG_C_SPECIALFUNC (mng_special_magn) |
|
5072 { |
|
5073 #ifdef MNG_SUPPORT_DISPLAY |
|
5074 return mng_create_ani_magn (pData, pChunk); |
|
5075 #else |
|
5076 return MNG_NOERROR; |
|
5077 #endif /* MNG_SUPPORT_DISPLAY */ |
|
5078 } |
|
5079 #endif |
|
5080 |
|
5081 /* ************************************************************************** */ |
|
5082 |
|
5083 #ifndef MNG_SKIPCHUNK_evNT |
|
5084 MNG_F_SPECIALFUNC (mng_evnt_entries) |
|
5085 { |
|
5086 mng_evntp pEVNT = (mng_evntp)pChunk; |
|
5087 mng_uint32 iRawlen; |
|
5088 mng_uint8p pRawdata; |
|
5089 #if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG) |
|
5090 mng_retcode iRetcode; |
|
5091 #endif |
|
5092 mng_uint8p pNull; |
|
5093 mng_uint8 iEventtype; |
|
5094 mng_uint8 iMasktype; |
|
5095 mng_int32 iLeft; |
|
5096 mng_int32 iRight; |
|
5097 mng_int32 iTop; |
|
5098 mng_int32 iBottom; |
|
5099 mng_uint16 iObjectid; |
|
5100 mng_uint8 iIndex; |
|
5101 mng_uint32 iNamesize; |
|
5102 mng_uint32 iCount = 0; |
|
5103 mng_evnt_entryp pEntry = MNG_NULL; |
|
5104 mng_uint32 iX; |
|
5105 |
|
5106 for (iX = 0; iX < 2; iX++) |
|
5107 { |
|
5108 iRawlen = *piRawlen; |
|
5109 pRawdata = *ppRawdata; |
|
5110 |
|
5111 if (iX) /* second run ? */ |
|
5112 { |
|
5113 MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_evnt_entry))); |
|
5114 pEVNT->iCount = iCount; |
|
5115 pEVNT->pEntries = pEntry; |
|
5116 } |
|
5117 |
|
5118 while (iRawlen) /* anything left ? */ |
|
5119 { |
|
5120 if (iRawlen < 2) /* must have at least 2 bytes ! */ |
|
5121 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
5122 |
|
5123 iEventtype = *pRawdata; /* eventtype */ |
|
5124 if (iEventtype > 5) |
|
5125 MNG_ERROR (pData, MNG_INVALIDEVENT); |
|
5126 |
|
5127 pRawdata++; |
|
5128 |
|
5129 iMasktype = *pRawdata; /* masktype */ |
|
5130 if (iMasktype > 5) |
|
5131 MNG_ERROR (pData, MNG_INVALIDMASK); |
|
5132 |
|
5133 pRawdata++; |
|
5134 iRawlen -= 2; |
|
5135 |
|
5136 iLeft = 0; |
|
5137 iRight = 0; |
|
5138 iTop = 0; |
|
5139 iBottom = 0; |
|
5140 iObjectid = 0; |
|
5141 iIndex = 0; |
|
5142 |
|
5143 switch (iMasktype) |
|
5144 { |
|
5145 case 1 : |
|
5146 { |
|
5147 if (iRawlen > 16) |
|
5148 { |
|
5149 iLeft = mng_get_int32 (pRawdata); |
|
5150 iRight = mng_get_int32 (pRawdata+4); |
|
5151 iTop = mng_get_int32 (pRawdata+8); |
|
5152 iBottom = mng_get_int32 (pRawdata+12); |
|
5153 pRawdata += 16; |
|
5154 iRawlen -= 16; |
|
5155 } |
|
5156 else |
|
5157 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
5158 break; |
|
5159 } |
|
5160 case 2 : |
|
5161 { |
|
5162 if (iRawlen > 2) |
|
5163 { |
|
5164 iObjectid = mng_get_uint16 (pRawdata); |
|
5165 pRawdata += 2; |
|
5166 iRawlen -= 2; |
|
5167 } |
|
5168 else |
|
5169 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
5170 break; |
|
5171 } |
|
5172 case 3 : |
|
5173 { |
|
5174 if (iRawlen > 3) |
|
5175 { |
|
5176 iObjectid = mng_get_uint16 (pRawdata); |
|
5177 iIndex = *(pRawdata+2); |
|
5178 pRawdata += 3; |
|
5179 iRawlen -= 3; |
|
5180 } |
|
5181 else |
|
5182 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
5183 break; |
|
5184 } |
|
5185 case 4 : |
|
5186 { |
|
5187 if (iRawlen > 18) |
|
5188 { |
|
5189 iLeft = mng_get_int32 (pRawdata); |
|
5190 iRight = mng_get_int32 (pRawdata+4); |
|
5191 iTop = mng_get_int32 (pRawdata+8); |
|
5192 iBottom = mng_get_int32 (pRawdata+12); |
|
5193 iObjectid = mng_get_uint16 (pRawdata+16); |
|
5194 pRawdata += 18; |
|
5195 iRawlen -= 18; |
|
5196 } |
|
5197 else |
|
5198 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
5199 break; |
|
5200 } |
|
5201 case 5 : |
|
5202 { |
|
5203 if (iRawlen > 19) |
|
5204 { |
|
5205 iLeft = mng_get_int32 (pRawdata); |
|
5206 iRight = mng_get_int32 (pRawdata+4); |
|
5207 iTop = mng_get_int32 (pRawdata+8); |
|
5208 iBottom = mng_get_int32 (pRawdata+12); |
|
5209 iObjectid = mng_get_uint16 (pRawdata+16); |
|
5210 iIndex = *(pRawdata+18); |
|
5211 pRawdata += 19; |
|
5212 iRawlen -= 19; |
|
5213 } |
|
5214 else |
|
5215 MNG_ERROR (pData, MNG_INVALIDLENGTH); |
|
5216 break; |
|
5217 } |
|
5218 } |
|
5219 |
|
5220 pNull = pRawdata; /* get the name length */ |
|
5221 while (*pNull) |
|
5222 pNull++; |
|
5223 |
|
5224 if ((pNull - pRawdata) > (mng_int32)iRawlen) |
|
5225 { |
|
5226 iNamesize = iRawlen; /* no null found; so end of evNT */ |
|
5227 iRawlen = 0; |
|
5228 } |
|
5229 else |
|
5230 { |
|
5231 iNamesize = pNull - pRawdata; /* should be another entry */ |
|
5232 iRawlen = iRawlen - iNamesize - 1; |
|
5233 |
|
5234 if (!iRawlen) /* must not end with a null ! */ |
|
5235 MNG_ERROR (pData, MNG_ENDWITHNULL); |
|
5236 } |
|
5237 |
|
5238 if (!iX) |
|
5239 { |
|
5240 iCount++; |
|
5241 } |
|
5242 else |
|
5243 { |
|
5244 pEntry->iEventtype = iEventtype; |
|
5245 pEntry->iMasktype = iMasktype; |
|
5246 pEntry->iLeft = iLeft; |
|
5247 pEntry->iRight = iRight; |
|
5248 pEntry->iTop = iTop; |
|
5249 pEntry->iBottom = iBottom; |
|
5250 pEntry->iObjectid = iObjectid; |
|
5251 pEntry->iIndex = iIndex; |
|
5252 pEntry->iSegmentnamesize = iNamesize; |
|
5253 |
|
5254 if (iNamesize) |
|
5255 { |
|
5256 MNG_ALLOC (pData, pEntry->zSegmentname, iNamesize+1); |
|
5257 MNG_COPY (pEntry->zSegmentname, pRawdata, iNamesize); |
|
5258 } |
|
5259 |
|
5260 #if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG) |
|
5261 iRetcode = mng_create_event (pData, (mng_ptr)pEntry); |
|
5262 if (iRetcode) /* on error bail out */ |
|
5263 return iRetcode; |
|
5264 #endif |
|
5265 |
|
5266 pEntry++; |
|
5267 } |
|
5268 |
|
5269 pRawdata = pRawdata + iNamesize + 1; |
|
5270 } |
|
5271 } |
|
5272 |
|
5273 *piRawlen = 0; |
|
5274 |
|
5275 return MNG_NOERROR; |
|
5276 } |
|
5277 #endif |
|
5278 |
|
5279 /* ************************************************************************** */ |
|
5280 |
|
5281 #ifndef MNG_SKIPCHUNK_evNT |
|
5282 MNG_C_SPECIALFUNC (mng_special_evnt) |
|
5283 { |
|
5284 return MNG_NOERROR; |
|
5285 } |
|
5286 #endif |
|
5287 |
|
5288 /* ************************************************************************** */ |
|
5289 |
|
5290 #ifdef MNG_INCLUDE_MPNG_PROPOSAL |
|
5291 MNG_C_SPECIALFUNC (mng_special_mpng) |
|
5292 { |
|
5293 if ((pData->eImagetype != mng_it_png) && (pData->eImagetype != mng_it_jng)) |
|
5294 MNG_ERROR (pData, MNG_CHUNKNOTALLOWED); |
|
5295 |
|
5296 #ifdef MNG_SUPPORT_DISPLAY |
|
5297 return mng_create_mpng_obj (pData, pChunk); |
|
5298 #else |
|
5299 return MNG_NOERROR; |
|
5300 #endif |
|
5301 } |
|
5302 #endif |
|
5303 |
|
5304 /* ************************************************************************** */ |
|
5305 |
|
5306 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
5307 MNG_C_SPECIALFUNC (mng_special_ahdr) |
|
5308 { |
|
5309 #ifdef MNG_SUPPORT_DISPLAY |
|
5310 return mng_create_ang_obj (pData, pChunk); |
|
5311 #else |
|
5312 return MNG_NOERROR; |
|
5313 #endif |
|
5314 } |
|
5315 #endif |
|
5316 |
|
5317 /* ************************************************************************** */ |
|
5318 |
|
5319 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
5320 MNG_F_SPECIALFUNC (mng_adat_tiles) |
|
5321 { |
|
5322 if ((pData->eImagetype != mng_it_ang) || (!pData->pANG)) |
|
5323 MNG_ERROR (pData, MNG_CHUNKNOTALLOWED); |
|
5324 |
|
5325 { |
|
5326 mng_adatp pADAT = (mng_adatp)pChunk; |
|
5327 mng_ang_objp pANG = (mng_ang_objp)pData->pANG; |
|
5328 mng_uint32 iRawlen = *piRawlen; |
|
5329 mng_uint8p pRawdata = *ppRawdata; |
|
5330 mng_retcode iRetcode; |
|
5331 mng_uint8p pBuf; |
|
5332 mng_uint32 iBufsize; |
|
5333 mng_uint32 iRealsize; |
|
5334 mng_uint8p pTemp; |
|
5335 mng_uint8p pTemp2; |
|
5336 mng_int32 iX; |
|
5337 mng_int32 iSize; |
|
5338 |
|
5339 #ifdef MNG_SUPPORT_DISPLAY |
|
5340 mng_imagep pImage; |
|
5341 mng_int32 iTemplen; |
|
5342 mng_uint8p pSwap; |
|
5343 |
|
5344 mng_processobject pProcess; |
|
5345 |
|
5346 mng_uint32 iSavedatawidth; |
|
5347 mng_uint32 iSavedataheight; |
|
5348 |
|
5349 mng_fptr fSaveinitrowproc; |
|
5350 mng_fptr fSavestorerow; |
|
5351 mng_fptr fSaveprocessrow; |
|
5352 mng_fptr fSavedifferrow; |
|
5353 mng_imagep fSavestoreobj; |
|
5354 mng_imagedatap fSavestorebuf; |
|
5355 |
|
5356 #ifdef MNG_OPTIMIZE_FOOTPRINT_INIT |
|
5357 png_imgtype eSavepngimgtype; |
|
5358 #endif |
|
5359 |
|
5360 mng_uint8 iSaveinterlace; |
|
5361 mng_int8 iSavepass; |
|
5362 mng_int32 iSaverow; |
|
5363 mng_int32 iSaverowinc; |
|
5364 mng_int32 iSavecol; |
|
5365 mng_int32 iSavecolinc; |
|
5366 mng_int32 iSaverowsamples; |
|
5367 mng_int32 iSavesamplemul; |
|
5368 mng_int32 iSavesampleofs; |
|
5369 mng_int32 iSavesamplediv; |
|
5370 mng_int32 iSaverowsize; |
|
5371 mng_int32 iSaverowmax; |
|
5372 mng_int32 iSavefilterofs; |
|
5373 mng_int32 iSavepixelofs; |
|
5374 mng_uint32 iSavelevel0; |
|
5375 mng_uint32 iSavelevel1; |
|
5376 mng_uint32 iSavelevel2; |
|
5377 mng_uint32 iSavelevel3; |
|
5378 mng_uint8p pSaveworkrow; |
|
5379 mng_uint8p pSaveprevrow; |
|
5380 mng_uint8p pSaverGBArow; |
|
5381 mng_bool bSaveisRGBA16; |
|
5382 mng_bool bSaveisOpaque; |
|
5383 mng_int32 iSavefilterbpp; |
|
5384 |
|
5385 mng_int32 iSavedestl; |
|
5386 mng_int32 iSavedestt; |
|
5387 mng_int32 iSavedestr; |
|
5388 mng_int32 iSavedestb; |
|
5389 mng_int32 iSavesourcel; |
|
5390 mng_int32 iSavesourcet; |
|
5391 mng_int32 iSavesourcer; |
|
5392 mng_int32 iSavesourceb; |
|
5393 #endif /* MNG_SUPPORT_DISPLAY */ |
|
5394 |
|
5395 iRetcode = mng_inflate_buffer (pData, pRawdata, iRawlen, |
|
5396 &pBuf, &iBufsize, &iRealsize); |
|
5397 if (iRetcode) /* on error bail out */ |
|
5398 { /* don't forget to drop the temp buffer */ |
|
5399 MNG_FREEX (pData, pBuf, iBufsize); |
|
5400 return iRetcode; |
|
5401 } |
|
5402 /* get buffer for tile info in ADAT chunk */ |
|
5403 pADAT->iTilessize = pANG->iNumframes * sizeof(mng_adat_tile); |
|
5404 MNG_ALLOCX (pData, pADAT->pTiles, pADAT->iTilessize); |
|
5405 if (!pADAT->pTiles) |
|
5406 { |
|
5407 pADAT->iTilessize = 0; |
|
5408 MNG_FREEX (pData, pBuf, iBufsize); |
|
5409 MNG_ERROR (pData, MNG_OUTOFMEMORY); |
|
5410 } |
|
5411 |
|
5412 pTemp = pBuf; |
|
5413 pTemp2 = (mng_uint8p)pADAT->pTiles; |
|
5414 |
|
5415 if (!pANG->iStillused) |
|
5416 iSize = 12; |
|
5417 else |
|
5418 iSize = 13; |
|
5419 |
|
5420 for (iX = 0; iX < pANG->iNumframes; iX++) |
|
5421 { |
|
5422 MNG_COPY (pTemp2, pTemp, iSize); |
|
5423 pTemp += iSize; |
|
5424 pTemp2 += sizeof(mng_adat_tile); |
|
5425 } |
|
5426 |
|
5427 #ifdef MNG_SUPPORT_DISPLAY |
|
5428 /* get buffer for tile info in ANG object */ |
|
5429 pANG->iTilessize = pADAT->iTilessize; |
|
5430 MNG_ALLOCX (pData, pANG->pTiles, pANG->iTilessize); |
|
5431 if (!pANG->pTiles) |
|
5432 { |
|
5433 pANG->iTilessize = 0; |
|
5434 MNG_FREEX (pData, pBuf, iBufsize); |
|
5435 MNG_ERROR (pData, MNG_OUTOFMEMORY); |
|
5436 } |
|
5437 /* copy it from the ADAT object */ |
|
5438 MNG_COPY (pANG->pTiles, pADAT->pTiles, pANG->iTilessize); |
|
5439 |
|
5440 /* save IDAT work-parms */ |
|
5441 fSaveinitrowproc = pData->fInitrowproc; |
|
5442 fSavestorerow = pData->fDisplayrow; |
|
5443 fSaveprocessrow = pData->fProcessrow; |
|
5444 fSavedifferrow = pData->fDifferrow; |
|
5445 fSavestoreobj = pData->pStoreobj; |
|
5446 fSavestorebuf = pData->pStorebuf; |
|
5447 |
|
5448 #ifdef MNG_OPTIMIZE_FOOTPRINT_INIT |
|
5449 eSavepngimgtype = pData->ePng_imgtype; |
|
5450 #endif |
|
5451 |
|
5452 iSavedatawidth = pData->iDatawidth; |
|
5453 iSavedataheight = pData->iDataheight; |
|
5454 iSaveinterlace = pData->iInterlace; |
|
5455 iSavepass = pData->iPass; |
|
5456 iSaverow = pData->iRow; |
|
5457 iSaverowinc = pData->iRowinc; |
|
5458 iSavecol = pData->iCol; |
|
5459 iSavecolinc = pData->iColinc; |
|
5460 iSaverowsamples = pData->iRowsamples; |
|
5461 iSavesamplemul = pData->iSamplemul; |
|
5462 iSavesampleofs = pData->iSampleofs; |
|
5463 iSavesamplediv = pData->iSamplediv; |
|
5464 iSaverowsize = pData->iRowsize; |
|
5465 iSaverowmax = pData->iRowmax; |
|
5466 iSavefilterofs = pData->iFilterofs; |
|
5467 iSavepixelofs = pData->iPixelofs; |
|
5468 iSavelevel0 = pData->iLevel0; |
|
5469 iSavelevel1 = pData->iLevel1; |
|
5470 iSavelevel2 = pData->iLevel2; |
|
5471 iSavelevel3 = pData->iLevel3; |
|
5472 pSaveworkrow = pData->pWorkrow; |
|
5473 pSaveprevrow = pData->pPrevrow; |
|
5474 pSaverGBArow = pData->pRGBArow; |
|
5475 bSaveisRGBA16 = pData->bIsRGBA16; |
|
5476 bSaveisOpaque = pData->bIsOpaque; |
|
5477 iSavefilterbpp = pData->iFilterbpp; |
|
5478 iSavedestl = pData->iDestl; |
|
5479 iSavedestt = pData->iDestt; |
|
5480 iSavedestr = pData->iDestr; |
|
5481 iSavedestb = pData->iDestb; |
|
5482 iSavesourcel = pData->iSourcel; |
|
5483 iSavesourcet = pData->iSourcet; |
|
5484 iSavesourcer = pData->iSourcer; |
|
5485 iSavesourceb = pData->iSourceb; |
|
5486 |
|
5487 pData->iDatawidth = pANG->iTilewidth; |
|
5488 pData->iDataheight = pANG->iTileheight; |
|
5489 |
|
5490 pData->iDestl = 0; |
|
5491 pData->iDestt = 0; |
|
5492 pData->iDestr = pANG->iTilewidth; |
|
5493 pData->iDestb = pANG->iTileheight; |
|
5494 pData->iSourcel = 0; |
|
5495 pData->iSourcet = 0; |
|
5496 pData->iSourcer = pANG->iTilewidth; |
|
5497 pData->iSourceb = pANG->iTileheight; |
|
5498 |
|
5499 pData->fInitrowproc = MNG_NULL; |
|
5500 pData->fStorerow = MNG_NULL; |
|
5501 pData->fProcessrow = MNG_NULL; |
|
5502 pData->fDifferrow = MNG_NULL; |
|
5503 |
|
5504 /* clone image object to store the pixel-data from object 0 */ |
|
5505 iRetcode = mng_clone_imageobject (pData, 1, MNG_FALSE, MNG_FALSE, MNG_FALSE, |
|
5506 MNG_FALSE, 0, 0, 0, pData->pObjzero, &pImage); |
|
5507 if (iRetcode) /* on error, drop temp buffer and bail */ |
|
5508 { |
|
5509 MNG_FREEX (pData, pBuf, iBufsize); |
|
5510 return iRetcode; |
|
5511 } |
|
5512 |
|
5513 /* make sure we got the right dimensions and interlacing */ |
|
5514 iRetcode = mng_reset_object_details (pData, pImage, pANG->iTilewidth, pANG->iTileheight, |
|
5515 pImage->pImgbuf->iBitdepth, pImage->pImgbuf->iColortype, |
|
5516 pImage->pImgbuf->iCompression, pImage->pImgbuf->iFilter, |
|
5517 pANG->iInterlace, MNG_FALSE); |
|
5518 if (iRetcode) /* on error, drop temp buffer and bail */ |
|
5519 { |
|
5520 MNG_FREEX (pData, pBuf, iBufsize); |
|
5521 return iRetcode; |
|
5522 } |
|
5523 |
|
5524 pData->pStoreobj = pImage; |
|
5525 |
|
5526 #ifdef MNG_OPTIMIZE_FOOTPRINT_INIT |
|
5527 pData->fInitrowproc = (mng_fptr)mng_init_rowproc; |
|
5528 pData->ePng_imgtype = mng_png_imgtype(pData->iColortype,pData->iBitdepth); |
|
5529 #else |
|
5530 switch (pData->iColortype) /* determine row initialization routine */ |
|
5531 { |
|
5532 case 0 : { /* gray */ |
|
5533 switch (pData->iBitdepth) |
|
5534 { |
|
5535 #ifndef MNG_NO_1_2_4BIT_SUPPORT |
|
5536 case 1 : { |
|
5537 if (!pData->iInterlace) |
|
5538 pData->fInitrowproc = (mng_fptr)mng_init_g1_ni; |
|
5539 else |
|
5540 pData->fInitrowproc = (mng_fptr)mng_init_g1_i; |
|
5541 |
|
5542 break; |
|
5543 } |
|
5544 case 2 : { |
|
5545 if (!pData->iInterlace) |
|
5546 pData->fInitrowproc = (mng_fptr)mng_init_g2_ni; |
|
5547 else |
|
5548 pData->fInitrowproc = (mng_fptr)mng_init_g2_i; |
|
5549 |
|
5550 break; |
|
5551 } |
|
5552 case 4 : { |
|
5553 if (!pData->iInterlace) |
|
5554 pData->fInitrowproc = (mng_fptr)mng_init_g4_ni; |
|
5555 else |
|
5556 pData->fInitrowproc = (mng_fptr)mng_init_g4_i; |
|
5557 break; |
|
5558 } |
|
5559 #endif /* MNG_NO_1_2_4BIT_SUPPORT */ |
|
5560 case 8 : { |
|
5561 if (!pData->iInterlace) |
|
5562 pData->fInitrowproc = (mng_fptr)mng_init_g8_ni; |
|
5563 else |
|
5564 pData->fInitrowproc = (mng_fptr)mng_init_g8_i; |
|
5565 |
|
5566 break; |
|
5567 } |
|
5568 #ifndef MNG_NO_16BIT_SUPPORT |
|
5569 case 16 : { |
|
5570 if (!pData->iInterlace) |
|
5571 pData->fInitrowproc = (mng_fptr)mng_init_g16_ni; |
|
5572 else |
|
5573 pData->fInitrowproc = (mng_fptr)mng_init_g16_i; |
|
5574 |
|
5575 break; |
|
5576 } |
|
5577 #endif |
|
5578 } |
|
5579 |
|
5580 break; |
|
5581 } |
|
5582 case 2 : { /* rgb */ |
|
5583 switch (pData->iBitdepth) |
|
5584 { |
|
5585 case 8 : { |
|
5586 if (!pData->iInterlace) |
|
5587 pData->fInitrowproc = (mng_fptr)mng_init_rgb8_ni; |
|
5588 else |
|
5589 pData->fInitrowproc = (mng_fptr)mng_init_rgb8_i; |
|
5590 break; |
|
5591 } |
|
5592 #ifndef MNG_NO_16BIT_SUPPORT |
|
5593 case 16 : { |
|
5594 if (!pData->iInterlace) |
|
5595 pData->fInitrowproc = (mng_fptr)mng_init_rgb16_ni; |
|
5596 else |
|
5597 pData->fInitrowproc = (mng_fptr)mng_init_rgb16_i; |
|
5598 |
|
5599 break; |
|
5600 } |
|
5601 #endif |
|
5602 } |
|
5603 |
|
5604 break; |
|
5605 } |
|
5606 case 3 : { /* indexed */ |
|
5607 switch (pData->iBitdepth) |
|
5608 { |
|
5609 #ifndef MNG_NO_1_2_4BIT_SUPPORT |
|
5610 case 1 : { |
|
5611 if (!pData->iInterlace) |
|
5612 pData->fInitrowproc = (mng_fptr)mng_init_idx1_ni; |
|
5613 else |
|
5614 pData->fInitrowproc = (mng_fptr)mng_init_idx1_i; |
|
5615 |
|
5616 break; |
|
5617 } |
|
5618 case 2 : { |
|
5619 if (!pData->iInterlace) |
|
5620 pData->fInitrowproc = (mng_fptr)mng_init_idx2_ni; |
|
5621 else |
|
5622 pData->fInitrowproc = (mng_fptr)mng_init_idx2_i; |
|
5623 |
|
5624 break; |
|
5625 } |
|
5626 case 4 : { |
|
5627 if (!pData->iInterlace) |
|
5628 pData->fInitrowproc = (mng_fptr)mng_init_idx4_ni; |
|
5629 else |
|
5630 pData->fInitrowproc = (mng_fptr)mng_init_idx4_i; |
|
5631 |
|
5632 break; |
|
5633 } |
|
5634 #endif /* MNG_NO_1_2_4BIT_SUPPORT */ |
|
5635 case 8 : { |
|
5636 if (!pData->iInterlace) |
|
5637 pData->fInitrowproc = (mng_fptr)mng_init_idx8_ni; |
|
5638 else |
|
5639 pData->fInitrowproc = (mng_fptr)mng_init_idx8_i; |
|
5640 |
|
5641 break; |
|
5642 } |
|
5643 } |
|
5644 |
|
5645 break; |
|
5646 } |
|
5647 case 4 : { /* gray+alpha */ |
|
5648 switch (pData->iBitdepth) |
|
5649 { |
|
5650 case 8 : { |
|
5651 if (!pData->iInterlace) |
|
5652 pData->fInitrowproc = (mng_fptr)mng_init_ga8_ni; |
|
5653 else |
|
5654 pData->fInitrowproc = (mng_fptr)mng_init_ga8_i; |
|
5655 |
|
5656 break; |
|
5657 } |
|
5658 #ifndef MNG_NO_16BIT_SUPPORT |
|
5659 case 16 : { |
|
5660 if (!pData->iInterlace) |
|
5661 pData->fInitrowproc = (mng_fptr)mng_init_ga16_ni; |
|
5662 else |
|
5663 pData->fInitrowproc = (mng_fptr)mng_init_ga16_i; |
|
5664 break; |
|
5665 } |
|
5666 #endif |
|
5667 } |
|
5668 |
|
5669 break; |
|
5670 } |
|
5671 case 6 : { /* rgb+alpha */ |
|
5672 switch (pData->iBitdepth) |
|
5673 { |
|
5674 case 8 : { |
|
5675 if (!pData->iInterlace) |
|
5676 pData->fInitrowproc = (mng_fptr)mng_init_rgba8_ni; |
|
5677 else |
|
5678 pData->fInitrowproc = (mng_fptr)mng_init_rgba8_i; |
|
5679 |
|
5680 break; |
|
5681 } |
|
5682 #ifndef MNG_NO_16BIT_SUPPORT |
|
5683 case 16 : { |
|
5684 if (!pData->iInterlace) |
|
5685 pData->fInitrowproc = (mng_fptr)mng_init_rgba16_ni; |
|
5686 else |
|
5687 pData->fInitrowproc = (mng_fptr)mng_init_rgba16_i; |
|
5688 |
|
5689 break; |
|
5690 } |
|
5691 #endif |
|
5692 } |
|
5693 |
|
5694 break; |
|
5695 } |
|
5696 } |
|
5697 #endif /* MNG_OPTIMIZE_FOOTPRINT_INIT */ |
|
5698 |
|
5699 pData->iFilterofs = 0; /* determine filter characteristics */ |
|
5700 pData->iLevel0 = 0; /* default levels */ |
|
5701 pData->iLevel1 = 0; |
|
5702 pData->iLevel2 = 0; |
|
5703 pData->iLevel3 = 0; |
|
5704 |
|
5705 #ifdef FILTER192 /* leveling & differing ? */ |
|
5706 if (pData->iFilter == MNG_FILTER_DIFFERING) |
|
5707 { |
|
5708 switch (pData->iColortype) |
|
5709 { |
|
5710 case 0 : { |
|
5711 if (pData->iBitdepth <= 8) |
|
5712 pData->iFilterofs = 1; |
|
5713 else |
|
5714 pData->iFilterofs = 2; |
|
5715 |
|
5716 break; |
|
5717 } |
|
5718 case 2 : { |
|
5719 if (pData->iBitdepth <= 8) |
|
5720 pData->iFilterofs = 3; |
|
5721 else |
|
5722 pData->iFilterofs = 6; |
|
5723 |
|
5724 break; |
|
5725 } |
|
5726 case 3 : { |
|
5727 pData->iFilterofs = 1; |
|
5728 break; |
|
5729 } |
|
5730 case 4 : { |
|
5731 if (pData->iBitdepth <= 8) |
|
5732 pData->iFilterofs = 2; |
|
5733 else |
|
5734 pData->iFilterofs = 4; |
|
5735 |
|
5736 break; |
|
5737 } |
|
5738 case 6 : { |
|
5739 if (pData->iBitdepth <= 8) |
|
5740 pData->iFilterofs = 4; |
|
5741 else |
|
5742 pData->iFilterofs = 8; |
|
5743 |
|
5744 break; |
|
5745 } |
|
5746 } |
|
5747 } |
|
5748 #endif |
|
5749 |
|
5750 #ifdef FILTER193 /* no adaptive filtering ? */ |
|
5751 if (pData->iFilter == MNG_FILTER_NOFILTER) |
|
5752 pData->iPixelofs = pData->iFilterofs; |
|
5753 else |
|
5754 #endif |
|
5755 pData->iPixelofs = pData->iFilterofs + 1; |
|
5756 |
|
5757 if (pData->fInitrowproc) /* need to initialize row processing? */ |
|
5758 { |
|
5759 iRetcode = ((mng_initrowproc)pData->fInitrowproc) (pData); |
|
5760 if (iRetcode) |
|
5761 { |
|
5762 MNG_FREEX (pData, pBuf, iBufsize); |
|
5763 return iRetcode; |
|
5764 } |
|
5765 } |
|
5766 /* calculate remainder of buffer */ |
|
5767 pTemp = pBuf + (mng_int32)(pANG->iNumframes * iSize); |
|
5768 iTemplen = iRealsize - (mng_int32)(pANG->iNumframes * iSize); |
|
5769 |
|
5770 do |
|
5771 { |
|
5772 if (iTemplen > pData->iRowmax) /* get a pixel-row from the temp buffer */ |
|
5773 { |
|
5774 MNG_COPY (pData->pWorkrow, pTemp, pData->iRowmax); |
|
5775 } |
|
5776 else |
|
5777 { |
|
5778 MNG_COPY (pData->pWorkrow, pTemp, iTemplen); |
|
5779 } |
|
5780 |
|
5781 { /* image not completed yet ? */ |
|
5782 if (pData->iRow < (mng_int32)pData->iDataheight) |
|
5783 { |
|
5784 #ifdef MNG_NO_1_2_4BIT_SUPPORT |
|
5785 if (pData->iPNGdepth == 1) |
|
5786 { |
|
5787 /* Inflate Workrow to 8-bit */ |
|
5788 mng_int32 iX; |
|
5789 mng_uint8p pSrc = pData->pWorkrow+1; |
|
5790 mng_uint8p pDest = pSrc + pData->iRowsize - (pData->iRowsize+7)/8; |
|
5791 |
|
5792 for (iX = ((pData->iRowsize+7)/8) ; iX > 0 ; iX--) |
|
5793 *pDest++ = *pSrc++; |
|
5794 |
|
5795 pDest = pData->pWorkrow+1; |
|
5796 pSrc = pDest + pData->iRowsize - (pData->iRowsize+7)/8; |
|
5797 for (iX = pData->iRowsize; ;) |
|
5798 { |
|
5799 *pDest++ = (((*pSrc)>>7)&1); |
|
5800 if (iX-- <= 0) |
|
5801 break; |
|
5802 *pDest++ = (((*pSrc)>>6)&1); |
|
5803 if (iX-- <= 0) |
|
5804 break; |
|
5805 *pDest++ = (((*pSrc)>>5)&1); |
|
5806 if (iX-- <= 0) |
|
5807 break; |
|
5808 *pDest++ = (((*pSrc)>>4)&1); |
|
5809 if (iX-- <= 0) |
|
5810 break; |
|
5811 *pDest++ = (((*pSrc)>>3)&1); |
|
5812 if (iX-- <= 0) |
|
5813 break; |
|
5814 *pDest++ = (((*pSrc)>>2)&1); |
|
5815 if (iX-- <= 0) |
|
5816 break; |
|
5817 *pDest++ = (((*pSrc)>>1)&1); |
|
5818 if (iX-- <= 0) |
|
5819 break; |
|
5820 *pDest++ = (((*pSrc) )&1); |
|
5821 if (iX-- <= 0) |
|
5822 break; |
|
5823 pSrc++; |
|
5824 } |
|
5825 } |
|
5826 else if (pData->iPNGdepth == 2) |
|
5827 { |
|
5828 /* Inflate Workrow to 8-bit */ |
|
5829 mng_int32 iX; |
|
5830 mng_uint8p pSrc = pData->pWorkrow+1; |
|
5831 mng_uint8p pDest = pSrc + pData->iRowsize - (2*pData->iRowsize+7)/8; |
|
5832 |
|
5833 for (iX = ((2*pData->iRowsize+7)/8) ; iX > 0 ; iX--) |
|
5834 *pDest++ = *pSrc++; |
|
5835 |
|
5836 pDest = pData->pWorkrow+1; |
|
5837 pSrc = pDest + pData->iRowsize - (2*pData->iRowsize+7)/8; |
|
5838 for (iX = pData->iRowsize; ;) |
|
5839 { |
|
5840 *pDest++ = (((*pSrc)>>6)&3); |
|
5841 if (iX-- <= 0) |
|
5842 break; |
|
5843 *pDest++ = (((*pSrc)>>4)&3); |
|
5844 if (iX-- <= 0) |
|
5845 break; |
|
5846 *pDest++ = (((*pSrc)>>2)&3); |
|
5847 if (iX-- <= 0) |
|
5848 break; |
|
5849 *pDest++ = (((*pSrc) )&3); |
|
5850 if (iX-- <= 0) |
|
5851 break; |
|
5852 pSrc++; |
|
5853 } |
|
5854 } |
|
5855 else if (pData->iPNGdepth == 4) |
|
5856 { |
|
5857 /* Inflate Workrow to 8-bit */ |
|
5858 mng_int32 iX; |
|
5859 mng_uint8p pSrc = pData->pWorkrow+1; |
|
5860 mng_uint8p pDest = pSrc + pData->iRowsize - (4*pData->iRowsize+7)/8; |
|
5861 |
|
5862 for (iX = ((4*pData->iRowsize+7)/8) ; iX > 0 ; iX--) |
|
5863 *pDest++ = *pSrc++; |
|
5864 |
|
5865 pDest = pData->pWorkrow+1; |
|
5866 pSrc = pDest + pData->iRowsize - (4*pData->iRowsize+7)/8; |
|
5867 for (iX = pData->iRowsize; ;) |
|
5868 { |
|
5869 *pDest++ = (((*pSrc)>>4)&0x0f); |
|
5870 if (iX-- <= 0) |
|
5871 break; |
|
5872 *pDest++ = (((*pSrc) )&0x0f); |
|
5873 if (iX-- <= 0) |
|
5874 break; |
|
5875 pSrc++; |
|
5876 } |
|
5877 } |
|
5878 if (pData->iPNGdepth < 8 && pData->iColortype == 0) |
|
5879 { |
|
5880 /* Expand samples to 8-bit by LBR */ |
|
5881 mng_int32 iX; |
|
5882 mng_uint8p pSrc = pData->pWorkrow+1; |
|
5883 mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1}; |
|
5884 |
|
5885 for (iX = pData->iRowsize; iX > 0; iX--) |
|
5886 *pSrc++ *= multiplier[pData->iPNGdepth]; |
|
5887 } |
|
5888 #endif |
|
5889 #ifdef MNG_NO_16BIT_SUPPORT |
|
5890 if (pData->iPNGdepth > 8) |
|
5891 { |
|
5892 /* Reduce Workrow to 8-bit */ |
|
5893 mng_int32 iX; |
|
5894 mng_uint8p pSrc = pData->pWorkrow+1; |
|
5895 mng_uint8p pDest = pSrc; |
|
5896 |
|
5897 for (iX = pData->iRowsize; iX > 0; iX--) |
|
5898 { |
|
5899 *pDest = *pSrc; |
|
5900 pDest++; |
|
5901 pSrc+=2; |
|
5902 } |
|
5903 } |
|
5904 #endif |
|
5905 |
|
5906 #ifdef FILTER192 /* has leveling info ? */ |
|
5907 if (pData->iFilterofs == MNG_FILTER_DIFFERING) |
|
5908 iRetcode = init_rowdiffering (pData); |
|
5909 else |
|
5910 #endif |
|
5911 iRetcode = MNG_NOERROR; |
|
5912 /* filter the row if necessary */ |
|
5913 if ((!iRetcode) && (pData->iFilterofs < pData->iPixelofs ) && |
|
5914 (*(pData->pWorkrow + pData->iFilterofs)) ) |
|
5915 iRetcode = mng_filter_a_row (pData); |
|
5916 |
|
5917 /* additional leveling/differing ? */ |
|
5918 if ((!iRetcode) && (pData->fDifferrow)) |
|
5919 { |
|
5920 iRetcode = ((mng_differrow)pData->fDifferrow) (pData); |
|
5921 |
|
5922 pSwap = pData->pWorkrow; |
|
5923 pData->pWorkrow = pData->pPrevrow; |
|
5924 pData->pPrevrow = pSwap; /* make sure we're processing the right data */ |
|
5925 } |
|
5926 |
|
5927 if (!iRetcode) |
|
5928 { |
|
5929 { /* process this row */ |
|
5930 if ((!iRetcode) && (pData->fProcessrow)) |
|
5931 iRetcode = ((mng_processrow)pData->fProcessrow) (pData); |
|
5932 /* store in object ? */ |
|
5933 if ((!iRetcode) && (pData->fStorerow)) |
|
5934 iRetcode = ((mng_storerow)pData->fStorerow) (pData); |
|
5935 } |
|
5936 } |
|
5937 |
|
5938 if (iRetcode) /* on error bail out */ |
|
5939 { |
|
5940 MNG_FREEX (pData, pBuf, iBufsize); |
|
5941 MNG_ERROR (pData, iRetcode); |
|
5942 } |
|
5943 |
|
5944 if (!pData->fDifferrow) /* swap row-pointers */ |
|
5945 { |
|
5946 pSwap = pData->pWorkrow; |
|
5947 pData->pWorkrow = pData->pPrevrow; |
|
5948 pData->pPrevrow = pSwap; /* so prev points to the processed row! */ |
|
5949 } |
|
5950 /* adjust variables for next row */ |
|
5951 iRetcode = mng_next_row (pData); |
|
5952 |
|
5953 if (iRetcode) /* on error bail out */ |
|
5954 { |
|
5955 MNG_FREEX (pData, pBuf, iBufsize); |
|
5956 MNG_ERROR (pData, iRetcode); |
|
5957 } |
|
5958 } |
|
5959 } |
|
5960 |
|
5961 pTemp += pData->iRowmax; |
|
5962 iTemplen -= pData->iRowmax; |
|
5963 } /* until some error or EOI |
|
5964 or all pixels received */ |
|
5965 while ( (iTemplen > 0) && |
|
5966 ( (pData->iRow < (mng_int32)pData->iDataheight) || |
|
5967 ( (pData->iPass >= 0) && (pData->iPass < 7) ) ) ); |
|
5968 |
|
5969 mng_cleanup_rowproc (pData); /* cleanup row processing buffers !! */ |
|
5970 |
|
5971 /* restore saved work-parms */ |
|
5972 pData->iDatawidth = iSavedatawidth; |
|
5973 pData->iDataheight = iSavedataheight; |
|
5974 |
|
5975 pData->fInitrowproc = fSaveinitrowproc; |
|
5976 pData->fDisplayrow = fSavestorerow; |
|
5977 pData->fProcessrow = fSaveprocessrow; |
|
5978 pData->fDifferrow = fSavedifferrow; |
|
5979 pData->pStoreobj = fSavestoreobj; |
|
5980 pData->pStorebuf = fSavestorebuf; |
|
5981 |
|
5982 #ifdef MNG_OPTIMIZE_FOOTPRINT_INIT |
|
5983 pData->ePng_imgtype = eSavepngimgtype; |
|
5984 #endif |
|
5985 |
|
5986 pData->iInterlace = iSaveinterlace; |
|
5987 pData->iPass = iSavepass; |
|
5988 pData->iRow = iSaverow; |
|
5989 pData->iRowinc = iSaverowinc; |
|
5990 pData->iCol = iSavecol; |
|
5991 pData->iColinc = iSavecolinc; |
|
5992 pData->iRowsamples = iSaverowsamples; |
|
5993 pData->iSamplemul = iSavesamplemul; |
|
5994 pData->iSampleofs = iSavesampleofs; |
|
5995 pData->iSamplediv = iSavesamplediv; |
|
5996 pData->iRowsize = iSaverowsize; |
|
5997 pData->iRowmax = iSaverowmax; |
|
5998 pData->iFilterofs = iSavefilterofs; |
|
5999 pData->iPixelofs = iSavepixelofs; |
|
6000 pData->iLevel0 = iSavelevel0; |
|
6001 pData->iLevel1 = iSavelevel1; |
|
6002 pData->iLevel2 = iSavelevel2; |
|
6003 pData->iLevel3 = iSavelevel3; |
|
6004 pData->pWorkrow = pSaveworkrow; |
|
6005 pData->pPrevrow = pSaveprevrow; |
|
6006 pData->pRGBArow = pSaverGBArow; |
|
6007 pData->bIsRGBA16 = bSaveisRGBA16; |
|
6008 pData->bIsOpaque = bSaveisOpaque; |
|
6009 pData->iFilterbpp = iSavefilterbpp; |
|
6010 pData->iDestl = iSavedestl; |
|
6011 pData->iDestt = iSavedestt; |
|
6012 pData->iDestr = iSavedestr; |
|
6013 pData->iDestb = iSavedestb; |
|
6014 pData->iSourcel = iSavesourcel; |
|
6015 pData->iSourcet = iSavesourcet; |
|
6016 pData->iSourcer = iSavesourcer; |
|
6017 pData->iSourceb = iSavesourceb; |
|
6018 |
|
6019 /* create the animation directives ! */ |
|
6020 pProcess = (mng_processobject)pANG->sHeader.fProcess; |
|
6021 iRetcode = pProcess (pData, (mng_objectp)pData->pANG); |
|
6022 if (iRetcode) |
|
6023 return iRetcode; |
|
6024 |
|
6025 #endif /* MNG_SUPPORT_DISPLAY */ |
|
6026 |
|
6027 MNG_FREE (pData, pBuf, iBufsize); /* always free the temp buffer ! */ |
|
6028 } |
|
6029 |
|
6030 *piRawlen = 0; |
|
6031 |
|
6032 return MNG_NOERROR; |
|
6033 } |
|
6034 #endif |
|
6035 |
|
6036 /* ************************************************************************** */ |
|
6037 |
|
6038 #ifdef MNG_INCLUDE_ANG_PROPOSAL |
|
6039 MNG_C_SPECIALFUNC (mng_special_adat) |
|
6040 { |
|
6041 return MNG_NOERROR; |
|
6042 } |
|
6043 #endif |
|
6044 |
|
6045 /* ************************************************************************** */ |
|
6046 |
|
6047 MNG_C_SPECIALFUNC (mng_special_unknown) |
|
6048 { |
|
6049 /* critical chunk ? */ |
|
6050 if ((((mng_uint32)pData->iChunkname & 0x20000000) == 0) |
|
6051 #ifdef MNG_SKIPCHUNK_SAVE |
|
6052 && (pData->iChunkname != MNG_UINT_SAVE) |
|
6053 #endif |
|
6054 #ifdef MNG_SKIPCHUNK_SEEK |
|
6055 && (pData->iChunkname != MNG_UINT_SEEK) |
|
6056 #endif |
|
6057 #ifdef MNG_SKIPCHUNK_DBYK |
|
6058 && (pData->iChunkname != MNG_UINT_DBYK) |
|
6059 #endif |
|
6060 #ifdef MNG_SKIPCHUNK_ORDR |
|
6061 && (pData->iChunkname != MNG_UINT_ORDR) |
|
6062 #endif |
|
6063 ) |
|
6064 MNG_ERROR (pData, MNG_UNKNOWNCRITICAL); |
|
6065 |
|
6066 if (pData->fProcessunknown) /* let the app handle it ? */ |
|
6067 { |
|
6068 mng_bool bOke = pData->fProcessunknown ((mng_handle)pData, pData->iChunkname, |
|
6069 ((mng_unknown_chunkp)pChunk)->iDatasize, |
|
6070 ((mng_unknown_chunkp)pChunk)->pData); |
|
6071 if (!bOke) |
|
6072 MNG_ERROR (pData, MNG_APPMISCERROR); |
|
6073 } |
|
6074 |
|
6075 return MNG_NOERROR; /* done */ |
|
6076 } |
|
6077 |
|
6078 /* ************************************************************************** */ |
|
6079 |
|
6080 #endif /* MNG_INCLUDE_READ_PROCS || MNG_INCLUDE_WRITE_PROCS */ |
|
6081 #endif /* MNG_OPTIMIZE_CHUNKREADER */ |
|
6082 |
|
6083 /* ************************************************************************** */ |
|
6084 /* * end of file * */ |
|
6085 /* ************************************************************************** */ |
|
6086 |
|
6087 |
|
6088 |
|
6089 |
|
6090 |