/[public]/psiconv/trunk/lib/psiconv/parse_image.c
ViewVC logotype

Annotation of /psiconv/trunk/lib/psiconv/parse_image.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 163 - (hide annotations)
Sat Nov 22 22:17:04 2003 UTC (20 years, 4 months ago) by frodo
File MIME type: text/plain
File size: 21656 byte(s)
(Frodo) Some more work on objects:
  * Bumped up major library version
  * Corrected parsing of sketch_section, changed struct
  * parse_sketch_section does not have the is_object flag anymore

1 frodo 10 /*
2     parse_image.c - Part of psiconv, a PSION 5 file formats converter
3 frodo 63 Copyright (c) 1999, 2000 Frodo Looijaard <frodol@dds.nl>
4 frodo 10
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9    
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     GNU General Public License for more details.
14    
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     */
19    
20     #include "config.h"
21 frodo 71 #include "compat.h"
22    
23 frodo 10 #include <stdlib.h>
24    
25     #include "parse_routines.h"
26 frodo 71 #include "error.h"
27 frodo 10
28 frodo 142 #ifdef DMALLOC
29     #include <dmalloc.h>
30     #endif
31    
32    
33 frodo 42 int psiconv_parse_jumptable_section(const psiconv_buffer buf,int lev,
34     psiconv_u32 off, int *length,
35     psiconv_jumptable_section *result)
36 frodo 12 {
37     int res = 0;
38     int len = 0;
39     psiconv_u32 listlen,temp;
40     int i;
41    
42 frodo 42 psiconv_progress(lev+1,off+len,"Going to read the jumptable section");
43 frodo 64 if (!((*result) = psiconv_list_new(sizeof(psiconv_u32))))
44     goto ERROR1;
45 frodo 12
46     psiconv_progress(lev+2,off+len,"Going to read the list length");
47 frodo 64 listlen = psiconv_read_u32(buf,lev+2,off+len,&res);
48 frodo 65 if (res)
49 frodo 64 goto ERROR2;
50 frodo 12 psiconv_debug(lev+2,off+len,"List length: %08x",listlen);
51     len += 4;
52    
53     psiconv_progress(lev+2,off+len,"Going to read the list");
54     for (i = 0; i < listlen; i++) {
55 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
56 frodo 65 if (res)
57 frodo 64 goto ERROR2;
58     if ((res = psiconv_list_add(*result,&temp)))
59     goto ERROR2;
60 frodo 12 psiconv_debug(lev+3,off+len,"Offset: %08x",temp);
61     len += 4;
62     }
63    
64     if (length)
65     *length = len;
66    
67 frodo 42 psiconv_progress(lev+1,off+len-1,"End of jumptable section "
68 frodo 13 "(total length: %08x)", len);
69 frodo 12
70 frodo 64 return 0;
71    
72     ERROR2:
73     psiconv_list_free(*result);
74     ERROR1:
75     psiconv_warn(lev+1,off,"Reading of Jumptable Section failed");
76     if (length)
77     *length = 0;
78     if (!res)
79     return -PSICONV_E_NOMEM;
80     else
81     return res;
82 frodo 12 }
83    
84 frodo 25 static int decode_byte(int lev, psiconv_u32 off,
85 frodo 97 psiconv_paint_data_section data, psiconv_u32 *pixelnr,
86 frodo 25 psiconv_u8 byte, int bits_per_pixel, int linelen,
87     int *linepos,int picsize)
88     {
89     int mask = (bits_per_pixel << 1) -1;
90     int i;
91     if (*linepos < (data->xsize + (8/bits_per_pixel) - 1) / (8/bits_per_pixel))
92     for (i = 0; i < 8/bits_per_pixel; i ++) {
93     if ((i != 0) && ((*pixelnr % (data->xsize)) == 0)) {
94     psiconv_debug(lev+1,off,"Skipping padding: %02x",byte);
95     i = 8;
96     } else if (*pixelnr >= picsize) {
97     psiconv_warn(lev+1,off,"Corrupted picture data!");
98     psiconv_debug(lev+1,off,"Trying to write a pixel too far");
99     return -1;
100     } else {
101     data->red[*pixelnr] = data->green[*pixelnr] = data->blue[*pixelnr] =
102     ((float) (byte & mask)) / ((1 << bits_per_pixel) -1);
103     psiconv_debug(lev+1,off,"Pixel %04x: (%04x,%04x) value %02x, color %f",
104 frodo 64 *pixelnr,*pixelnr % data->xsize,
105     *pixelnr / data->xsize, byte&mask, data->red[*pixelnr]);
106 frodo 25 byte = byte >> bits_per_pixel;
107     (*pixelnr) ++;
108     }
109     }
110     else
111     psiconv_debug(lev+1,off,"Skipping padding byte");
112     (*linepos) ++;
113     if (*linepos == linelen)
114     *linepos = 0;
115     return 0;
116     }
117    
118    
119 frodo 10 int psiconv_parse_paint_data_section(const psiconv_buffer buf,int lev,
120 frodo 45 psiconv_u32 off, int *length,int isclipart,
121 frodo 10 psiconv_paint_data_section *result)
122     {
123     int res = 0;
124     int len = 0;
125 frodo 13 psiconv_u32 size,offset,picsize,temp,datasize,pixelnr,datanr,linelen;
126 frodo 11 psiconv_u8 marker;
127 frodo 25 int i,leng;
128     psiconv_u32 bits_per_pixel,compression;
129     int linepos = 0;
130 frodo 10
131     psiconv_progress(lev+1,off,"Going to read a paint data section");
132 frodo 64 if (!((*result) = malloc(sizeof(**result))))
133     goto ERROR1;
134 frodo 10
135     psiconv_progress(lev+2,off+len,"Going to read section size");
136 frodo 64 size = psiconv_read_u32(buf,lev+2,off+len,&res);
137     if (res)
138     goto ERROR2;
139 frodo 10 psiconv_debug(lev+2,off+len,"Section size: %08x",size);
140     len += 4;
141    
142     psiconv_progress(lev+2,off+len,"Going to read pixel data offset");
143 frodo 64 offset = psiconv_read_u32(buf,lev+2,off+len,&res);
144     if (res)
145     goto ERROR2;
146 frodo 13 if (offset != 0x28) {
147 frodo 10 psiconv_warn(lev+2,off+len,
148     "Paint data section data offset has unexpected value");
149     psiconv_debug(lev+2,off+len,
150     "Data offset: read %08x, expected %08x",offset,0x28);
151 frodo 12 res = -1;
152 frodo 10 }
153     len += 4;
154    
155     psiconv_progress(lev+2,off+len,"Going to read picture X size");
156 frodo 64 (*result)->xsize = psiconv_read_u32(buf,lev+2,off+len,&res);
157     if (res)
158     goto ERROR2;
159 frodo 10 psiconv_debug(lev+2,off+len,"Picture X size: %08x:",(*result)->xsize);
160     len += 4;
161    
162     psiconv_progress(lev+2,off+len,"Going to read picture Y size");
163 frodo 64 (*result)->ysize = psiconv_read_u32(buf,lev+2,off+len,&res);
164     if (res)
165     goto ERROR2;
166 frodo 10 psiconv_debug(lev+2,off+len,"Picture Y size: %08x:",(*result)->ysize);
167     len += 4;
168    
169 frodo 25 picsize = (*result)->ysize * (*result)->xsize;
170 frodo 10
171 frodo 25 psiconv_progress(lev+2,off+len,"Going to read the real picture x size");
172 frodo 64 (*result)->pic_xsize = psiconv_read_length(buf,lev+2,off+len,&leng,&res);
173     if (res)
174     goto ERROR2;
175 frodo 25 psiconv_debug(lev+2,off+len,"Picture x size: %f",(*result)->pic_xsize);
176     len += leng;
177    
178     psiconv_progress(lev+2,off+len,"Going to read the real picture y size");
179 frodo 64 (*result)->pic_ysize = psiconv_read_length(buf,lev+2,off+len,&leng,&res);
180     if (res)
181     goto ERROR2;
182 frodo 25 psiconv_debug(lev+2,off+len,"Picture y size: %f",(*result)->pic_ysize);
183     len += leng;
184    
185     psiconv_progress(lev+2,off+len,"Going to read the number of bits per pixel");
186 frodo 64 bits_per_pixel=psiconv_read_u32(buf,lev+2,off+len,&res);
187     if (res)
188     goto ERROR2;
189 frodo 25 if (bits_per_pixel > 8) {
190     psiconv_warn(lev+2,off+len,"Picture has too many colors");
191     psiconv_debug(lev+2,off+len,"Read %d colorbits",bits_per_pixel);
192 frodo 64 res = -PSICONV_E_PARSE;
193     goto ERROR2;
194 frodo 25 }
195     psiconv_debug(lev+2,off+len,"Bits per pixel: %d",bits_per_pixel);
196     len += 4;
197    
198     for (i = 0 ; i < 2; i++) {
199 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
200     if (res)
201     goto ERROR2;
202 frodo 25 if (temp != 00) {
203 frodo 10 psiconv_warn(lev+2,off+len,
204 frodo 64 "Paint data section prologue has unknown values (ignored)");
205 frodo 10 psiconv_debug(lev+2,off+len,
206 frodo 25 "offset %02x: read %08x, expected %08x",i,temp, 0x00);
207 frodo 10 }
208     len += 4;
209     }
210 frodo 25
211     psiconv_progress(lev+2,off+len,
212     "Going to read whether RLE compression is used");
213 frodo 64 compression=psiconv_read_u32(buf,lev+2,off+len,&res);
214     if (res)
215     goto ERROR2;
216 frodo 25 if (compression > 1) {
217     psiconv_warn(lev+2,off+len,"Paint data section has unknown "
218     "compression type, assuming RLE");
219     psiconv_debug(lev+2,off+len,"Read compression type %d",compression);
220     compression = 1;
221     }
222     psiconv_debug(lev+2,off+len,"Compression: %s",compression?"RLE":"none");
223 frodo 45 len += 4;
224 frodo 10
225 frodo 45 if (isclipart) {
226     psiconv_progress(lev+2,off+len,"Going to read an unknown long");
227 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
228     if (res)
229     goto ERROR2;
230 frodo 45 if (temp != 0xffffffff) {
231     psiconv_warn(lev+2,off+len,
232 frodo 64 "Paint data section prologue has unknown values (ignoring)");
233 frodo 45 psiconv_debug(lev+2,off+len,
234     "offset %02x: read %08x, expected %08x",i,temp, 0xffffffff);
235     }
236     len += 4;
237     psiconv_progress(lev+2,off+len,"Going to read a second unknown long");
238 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
239     if (res)
240     goto ERROR2;
241 frodo 45 if (temp != 0x44) {
242     psiconv_warn(lev+2,off+len,
243 frodo 64 "Paint data section prologue has unknown values (ignoring)");
244 frodo 45 psiconv_debug(lev+2,off+len,
245     "offset %02x: read %08x, expected %08x",i,temp, 0x44);
246     }
247     len += 4;
248     }
249    
250 frodo 64 if (!((*result)->red = malloc(sizeof(float) * picsize)))
251     goto ERROR2;
252     if (!((*result)->green = malloc(sizeof(float) * picsize)))
253     goto ERROR3;
254     if (!((*result)->blue = malloc(sizeof(float) * picsize)))
255     goto ERROR4;
256 frodo 10 len = offset;
257     datasize = size - len;
258 frodo 45 if (isclipart)
259     len += 8;
260 frodo 10
261 frodo 11 psiconv_progress(lev+2,off+len,"Going to read the pixel data");
262 frodo 10 pixelnr = 0;
263     datanr = 0;
264 frodo 25 if (!compression) {
265     linelen = datasize / (*result)->ysize;
266     psiconv_debug(lev+3,off+len,"Line length: %04x bytes",linelen);
267     while((datanr < datasize)) {
268 frodo 64 temp = psiconv_read_u8(buf,lev+2,off+len+datanr,&res);
269     if (res)
270     goto ERROR5;
271 frodo 25 if (decode_byte(lev+3,off+len+datanr,*result,&pixelnr,temp,bits_per_pixel,
272     linelen,&linepos,picsize)) {
273 frodo 64 res = -PSICONV_E_PARSE;
274 frodo 25 break;
275     }
276     datanr++;
277     }
278     } else {
279     psiconv_progress(lev+2,off+len,"First pass: determining line length");
280     datanr = 0;
281     i = 0;
282     while (datanr < datasize) {
283 frodo 64 marker = psiconv_read_u8(buf,lev+3,off+len+datanr,&res);
284     if (res)
285     goto ERROR5;
286 frodo 25 if (marker >= 0x80) {
287     datanr += 0x100 - marker + 1;
288     i += 0x100 - marker;
289 frodo 10 } else {
290 frodo 25 datanr += 2;
291     i += marker + 1;
292     }
293     }
294     linelen = i / (*result)->ysize;
295     datanr=0;
296     psiconv_debug(lev+2,off+len,"Linelen: %04x bytes",linelen);
297     while((datanr < datasize)) {
298 frodo 64 marker = psiconv_read_u8(buf,lev+3,off+len+datanr,&res);
299     if (res)
300     goto ERROR5;
301 frodo 25 psiconv_debug(lev+3,off+len+datanr,
302     "Pixelnr %08x, Datanr %08x: Read marker %02x",
303     pixelnr,datanr,marker);
304     datanr ++;
305     if (marker >= 0x80) {
306     /* 0x100 - marker bytes of data follow */
307     for (i = 0; i < 0x100-marker; i++,datanr++) {
308     if (datanr >= datasize) {
309 frodo 15 psiconv_warn(lev+3,off+len+datanr,"Corrupted picture data");
310     psiconv_debug(lev+3,off+len+datanr,
311     "Picsize: %08x, Datasize: %08x, Pixelnr: %08x,"
312     "Datanr: %08x, marker: %02x",picsize,datasize,pixelnr,
313     datanr,marker);
314 frodo 64 res = -PSICONV_E_PARSE;
315 frodo 25 break;
316     }
317 frodo 64 temp = psiconv_read_u8(buf,lev+2,off+len+datanr,&res);
318     if (res)
319     goto ERROR5;
320 frodo 25 if (decode_byte(lev+2,off+len+datanr,*result,&pixelnr,temp,
321     bits_per_pixel,linelen,&linepos,picsize)) {
322 frodo 64 res = -PSICONV_E_PARSE;
323 frodo 25 break;
324 frodo 15 }
325 frodo 25 }
326     } else {
327     if (datanr >= datasize) {
328     psiconv_warn(lev+3,off+len+datanr,"Corrupted picture data");
329     psiconv_debug(lev+3,off+len+datanr,
330     "Picsize: %08x, Datasize: %08x, Pixelnr: %08x,"
331     "Datanr: %08x, marker: %02x",picsize,datasize,pixelnr,
332     datanr,marker);
333 frodo 64 res = -PSICONV_E_PARSE;
334 frodo 25 } else {
335 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len+datanr,&res);
336     if (res)
337     goto ERROR5;
338 frodo 25 for (i = 0; i <= marker; i++) {
339     if (decode_byte(lev+2,off+len+datanr,*result,&pixelnr,temp,
340     bits_per_pixel,linelen,&linepos,picsize)) {
341 frodo 64 res = -PSICONV_E_PARSE;
342 frodo 25 break;
343     }
344     }
345     datanr ++;
346     }
347 frodo 10 }
348     }
349     }
350 frodo 25
351     if (linepos >= ((*result)->xsize + (8/bits_per_pixel) - 1) /
352     (8/bits_per_pixel))
353     datanr += (linelen - linepos);
354    
355 frodo 64 if (res || (datanr != datasize) || (pixelnr != picsize)) {
356 frodo 12 psiconv_warn(lev+2,off+len,"Corrupted picture data!");
357     psiconv_debug(lev+3,off+len+datanr,
358     "Picsize: %08x, Datasize: %08x, Pixelnr: %08x,"
359     "Datanr: %08x",picsize,datasize,pixelnr,datanr);
360 frodo 64 goto ERROR5;
361 frodo 12 }
362    
363 frodo 10 len += datanr;
364    
365     if (length)
366     *length = len;
367    
368     psiconv_progress(lev+1,off+len-1,"End of paint data section "
369 frodo 13 "(total length: %08x)", len);
370 frodo 10
371     return res;
372 frodo 64
373     ERROR5:
374     free((*result)->blue);
375     ERROR4:
376     free((*result)->green);
377     ERROR3:
378     free((*result)->red);
379     ERROR2:
380     free (*result);
381     ERROR1:
382     psiconv_warn(lev+1,off,"Reading of Paint Data Section failed");
383     if (length)
384     *length = 0;
385     if (!res)
386     return -PSICONV_E_NOMEM;
387     else
388     return res;
389 frodo 10 }
390    
391 frodo 24 int psiconv_parse_sketch_section(const psiconv_buffer buf, int lev,
392 frodo 163 psiconv_u32 off, int *length,
393 frodo 24 psiconv_sketch_section *result)
394     {
395     int res=0;
396     int len=0;
397     psiconv_u32 temp;
398     int leng;
399    
400     psiconv_progress(lev+1,off,"Going to read the sketch section");
401 frodo 64 if (!(*result = malloc(sizeof(**result))))
402     goto ERROR1;
403 frodo 24
404 frodo 163 psiconv_progress(lev+2,off+len,"Going to read the displayed hor. size");
405     (*result)->displayed_xsize = psiconv_read_u16(buf,lev+2,off + len,&res);
406     if (res)
407     goto ERROR2;
408     psiconv_debug(lev+2,off+len,"Displayed hor. size: %04x",
409     (*result)->displayed_xsize);
410     len += 0x02;
411     psiconv_progress(lev+2,off+len,"Going to read displayed ver. size");
412     (*result)->displayed_ysize = psiconv_read_u16(buf,lev+2,off + len,&res);
413     if (res)
414     goto ERROR2;
415     psiconv_debug(lev+2,off+len,"Displayed ver. size: %04x",
416     (*result)->displayed_ysize);
417     len += 0x02;
418 frodo 24
419 frodo 163 psiconv_progress(lev+2,off+len,"Going to read the data hor. offset");
420     (*result)->picture_data_x_offset = psiconv_read_u16(buf,lev+2,off + len,
421     &res);
422     if (res)
423     goto ERROR2;
424     psiconv_debug(lev+2,off+len,"Data hor. offset: %04x",
425     (*result)->picture_data_x_offset);
426     len += 0x02;
427     psiconv_progress(lev+2,off+len,"Going to read the data ver. offset");
428     (*result)->picture_data_y_offset = psiconv_read_u16(buf,lev+2,off + len,
429     &res);
430     if (res)
431     goto ERROR2;
432     psiconv_debug(lev+2,off+len,"Data ver. offset: %04x",
433     (*result)->picture_data_y_offset);
434     len += 0x02;
435    
436     psiconv_progress(lev+2,off+len,"Going to read the displayed hor. offset");
437     (*result)->displayed_size_x_offset = psiconv_read_u16(buf,lev+2,off + len,
438     &res);
439     if (res)
440     goto ERROR2;
441     psiconv_debug(lev+2,off+len,"Displayed hor. offset: %04x",
442     (*result)->displayed_size_x_offset);
443     len += 0x02;
444     psiconv_progress(lev+2,off+len,"Going to read the displayed ver. offset");
445     (*result)->displayed_size_y_offset = psiconv_read_u16(buf,lev+2,off + len,
446     &res);
447     if (res)
448     goto ERROR2;
449     psiconv_debug(lev+2,off+len,"Displayed ver. offset: %04x",
450     (*result)->displayed_size_y_offset);
451     len += 0x02;
452    
453     psiconv_progress(lev+2,off+len,"Going to read the form hor. size");
454     (*result)->form_xsize = psiconv_read_u16(buf,lev+2,off + len,&res);
455     if (res)
456     goto ERROR2;
457     psiconv_debug(lev+2,off+len,"Form hor. size: %04x",
458     (*result)->form_xsize);
459     len += 0x02;
460     psiconv_progress(lev+2,off+len,"Going to read form ver. size");
461     (*result)->form_ysize = psiconv_read_u16(buf,lev+2,off + len,&res);
462     if (res)
463     goto ERROR2;
464     psiconv_debug(lev+2,off+len,"Form ver. size: %04x",
465     (*result)->form_ysize);
466     len += 0x02;
467    
468     psiconv_progress(lev+2,off+len,"Going to skip 1 word of zeros");
469     temp = psiconv_read_u16(buf,lev+2,off+len,&res);
470     if (res)
471     goto ERROR2;
472     if (temp != 0) {
473     psiconv_warn(lev+2,off+len,
474     "Unexpected value in sketch section preamble (ignored)");
475     psiconv_debug(lev+2,off+len,"Read %04x, expected %04x",
476     temp,0);
477 frodo 24 }
478 frodo 163 off += 0x02;
479 frodo 24
480     psiconv_progress(lev+2,off+len,"Going to read the picture data");
481 frodo 64 if ((res = psiconv_parse_paint_data_section(buf,lev+2,off+len,&leng,0,
482     &((*result)->picture))))
483     goto ERROR2;
484 frodo 24 off += leng;
485    
486     psiconv_progress(lev+2,off+len,"Going to read the hor. magnification");
487 frodo 64 (*result)->magnification_x = psiconv_read_u16(buf,lev+2,off+len,&res)/1000.0;
488     if (res)
489     goto ERROR3;
490 frodo 24 psiconv_debug(lev+2,off+len,"Form hor. magnification: %f",
491     (*result)->magnification_x);
492     len += 0x02;
493     psiconv_progress(lev+2,off+len,"Going to read the ver. magnification");
494 frodo 64 (*result)->magnification_y = psiconv_read_u16(buf,lev+2,off+len,&res)/1000.0;
495     if (res)
496     goto ERROR3;
497 frodo 24 psiconv_debug(lev+2,off+len,"Form ver. magnification: %f",
498     (*result)->magnification_y);
499     len += 0x02;
500    
501     psiconv_progress(lev+2,off+len,"Going to read the left cut");
502 frodo 64 temp = psiconv_read_u32(buf,lev+2,off + len,&res);
503     if (res)
504     goto ERROR3;
505 frodo 163 (*result)->cut_left = (temp * 6.0) / (*result)->displayed_xsize;
506 frodo 24 psiconv_debug(lev+2,off+len,"Left cut: raw %08x, real: %f",
507     temp,(*result)->cut_left);
508     len += 0x04;
509     psiconv_progress(lev+2,off+len,"Going to read the right cut");
510 frodo 64 temp = psiconv_read_u32(buf,lev+2,off + len,&res);
511     if (res)
512     goto ERROR3;
513 frodo 163 (*result)->cut_right = (temp * 6.0) / (*result)->displayed_xsize;
514 frodo 24 psiconv_debug(lev+2,off+len,"Right cut: raw %08x, real: %f",
515     temp,(*result)->cut_right);
516     len += 0x04;
517     psiconv_progress(lev+2,off+len,"Going to read the top cut");
518 frodo 64 temp = psiconv_read_u32(buf,lev+2,off + len,&res);
519     if (res)
520     goto ERROR3;
521 frodo 163 (*result)->cut_top = (temp * 6.0) / (*result)->displayed_ysize;
522 frodo 24 psiconv_debug(lev+2,off+len,"Top cut: raw %08x, real: %f",
523     temp,(*result)->cut_top);
524     len += 0x04;
525     psiconv_progress(lev+2,off+len,"Going to read the bottom cut");
526 frodo 64 temp = psiconv_read_u32(buf,lev+2,off + len,&res);
527     if (res)
528     goto ERROR3;
529 frodo 163 (*result)->cut_bottom = (temp * 6.0) / (*result)->displayed_ysize;
530 frodo 24 psiconv_debug(lev+2,off+len,"Bottom cut: raw %08x, real: %f",
531     temp,(*result)->cut_bottom);
532     len += 0x04;
533    
534     if (length)
535     *length = len;
536    
537     psiconv_progress(lev,off+len-1,
538     "End of sketch section (total length: %08x)", len);
539    
540     return res;
541 frodo 64 ERROR3:
542     psiconv_free_paint_data_section((*result)->picture);
543     ERROR2:
544     free (*result);
545     ERROR1:
546     psiconv_warn(lev+1,off,"Reading of Sketch Section failed");
547     if (length)
548     *length = 0;
549     if (!res)
550     return -PSICONV_E_NOMEM;
551     else
552     return res;
553 frodo 24 }
554    
555 frodo 43
556     int psiconv_parse_clipart_section(const psiconv_buffer buf,int lev,
557     psiconv_u32 off, int *length,
558     psiconv_clipart_section *result)
559     {
560     int res=0;
561     int len=0;
562     int leng;
563     psiconv_u32 temp;
564    
565     psiconv_progress(lev+1,off+len,"Going to read the clipart section");
566 frodo 64 if (!(*result = malloc(sizeof(**result))))
567     goto ERROR1;
568 frodo 43
569     psiconv_progress(lev+2,off+len,"Going to read the section ID");
570 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
571     if (res)
572     goto ERROR2;
573 frodo 43 if (temp != PSICONV_ID_CLIPART_ITEM) {
574     psiconv_warn(lev+2,off+len,
575 frodo 64 "Unexpected value in clipart section preamble (ignored)");
576 frodo 43 psiconv_debug(lev+2,off+len,"Read %08x, expected %08x",temp,
577     PSICONV_ID_CLIPART_ITEM);
578     } else
579     psiconv_debug(lev+2,off+len,"Clipart ID: %08x", temp);
580     off += 4;
581    
582     psiconv_progress(lev+2,off+len,"Going to read an unknown long");
583 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
584     if (res)
585     goto ERROR2;
586 frodo 43 if (temp != 0x02) {
587     psiconv_warn(lev+2,off+len,
588 frodo 64 "Unexpected value in clipart section preamble (ignored)");
589 frodo 43 psiconv_debug(lev+2,off+len,"Read %08x, expected %08x",temp,
590     0x02);
591     } else
592     psiconv_debug(lev+2,off+len,"First unknown long: %08x", temp);
593     off += 4;
594    
595     psiconv_progress(lev+2,off+len,"Going to read a second unknown long");
596 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
597     if (res)
598     goto ERROR2;
599 frodo 43 if (temp != 0) {
600     psiconv_warn(lev+2,off+len,
601 frodo 64 "Unexpected value in clipart section preamble (ignored)");
602 frodo 43 psiconv_debug(lev+2,off+len,"Read %08x, expected %08x",temp, 0);
603     } else
604     psiconv_debug(lev+2,off+len,"Second unknown long: %08x", temp);
605     off += 4;
606    
607     psiconv_progress(lev+2,off+len,"Going to read a third unknown long");
608 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
609     if (res)
610     goto ERROR2;
611 frodo 43 if (temp != 0) {
612     psiconv_warn(lev+2,off+len,
613 frodo 64 "Unexpected value in clipart section preamble (ignored)");
614 frodo 43 psiconv_debug(lev+2,off+len,"Read %08x, expected %08x",temp, 0);
615     } else
616     psiconv_debug(lev+2,off+len,"Third unknown long: %08x", temp);
617     off += 4;
618    
619     psiconv_progress(lev+2,off+len,"Going to read a fourth unknown long");
620 frodo 64 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
621     if (res)
622     goto ERROR2;
623 frodo 43 if ((temp != 0x0c) && (temp != 0x08)) {
624     psiconv_warn(lev+2,off+len,
625 frodo 64 "Unexpected value in clipart section preamble (ignored)");
626 frodo 43 psiconv_debug(lev+2,off+len,"Read %08x, expected %08x or %08x",temp,
627     0x0c, 0x08);
628     } else
629     psiconv_debug(lev+2,off+len,"Fourth unknown long: %08x", temp);
630     off += 4;
631    
632     psiconv_progress(lev+2,off+len,"Going to read the Paint Data Section");
633 frodo 64 if ((res = psiconv_parse_paint_data_section(buf,lev+2,off+len,&leng,1,
634     &((*result)->picture))))
635     goto ERROR2;
636 frodo 43 len += leng;
637    
638     if (length)
639     *length = len;
640    
641     psiconv_progress(lev,off+len-1,
642     "End of clipart section (total length: %08x)", len);
643 frodo 64 return 0;
644 frodo 43
645 frodo 64 ERROR2:
646     free (*result);
647     ERROR1:
648     psiconv_warn(lev+1,off,"Reading of Font failed");
649     if (length)
650     *length = 0;
651     if (!res)
652     return -PSICONV_E_NOMEM;
653     else
654     return res;
655 frodo 43 }

frodo@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26