/[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 65 - (hide annotations)
Fri Dec 15 01:16:43 2000 UTC (23 years, 3 months ago) by frodo
File MIME type: text/plain
File size: 23321 byte(s)
(Frodo) First typos eliminated. Word files seem to work now. Need to test
        other types.

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

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