handle NULL (errorneous) polygons
[swftools.git] / lib / devices / ocr.c
1 /* ocr.c
2
3    Part of the swftools package.
4
5    Copyright (c) 2007 Matthias Kramm <kramm@quiss.org> 
6  
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <stdarg.h>
24 #include <unistd.h>
25 #include <memory.h>
26 #include "../types.h"
27 #include "../mem.h"
28 #include "../gfxdevice.h"
29 #include "../gfxtools.h"
30 #include "render.h"
31
32 #include "../gocr/pnm.h"
33 #include "../gocr/pgm2asc.h"
34 #include "../gocr/ocr0.h"
35
36 typedef struct _textpage {
37     char*text;
38     int textpos;
39     struct _textpage*next;
40 } textpage_t;
41
42 typedef struct _internal {
43     gfxdevice_t*render;
44     int pages;
45     
46     textpage_t*first_page;
47     textpage_t*current_page;
48 } internal_t;
49
50 int ocr_setparameter(gfxdevice_t*dev, const char*key, const char*value)
51 {
52     internal_t*i = (internal_t*)dev->internal;
53     return i->render->setparameter(i->render,key,value);
54 }
55
56 void ocr_startpage(gfxdevice_t*dev, int width, int height) 
57
58     internal_t*i = (internal_t*)dev->internal;
59     if(i->render) {
60         fprintf(stderr, "Call endpage() before calling startpage()\n");
61         return;
62     }
63     i->render = malloc(sizeof(gfxdevice_t));
64     gfxdevice_render_init(i->render);
65     i->render->startpage(i->render,width,height); 
66     i->pages++;
67 }
68 /* passthrough */
69 void ocr_startclip(gfxdevice_t*dev, gfxline_t*line) { ((internal_t*)dev->internal)->render->startclip(((internal_t*)dev->internal)->render,line); }
70 void ocr_endclip(gfxdevice_t*dev) { ((internal_t*)dev->internal)->render->endclip(((internal_t*)dev->internal)->render); }
71 void ocr_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit) { ((internal_t*)dev->internal)->render->stroke(((internal_t*)dev->internal)->render, line, width, color, cap_style, joint_style, miterLimit); }
72 void ocr_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) { ((internal_t*)dev->internal)->render->fill(((internal_t*)dev->internal)->render, line, color); }
73 void ocr_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) { ((internal_t*)dev->internal)->render->fillbitmap(((internal_t*)dev->internal)->render, line, img, matrix, cxform); }
74 void ocr_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) { ((internal_t*)dev->internal)->render->fillgradient(((internal_t*)dev->internal)->render, line, gradient, type, matrix); }
75 void ocr_addfont(gfxdevice_t*dev, gfxfont_t*font) { ((internal_t*)dev->internal)->render->addfont(((internal_t*)dev->internal)->render, font); }
76 void ocr_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) { ((internal_t*)dev->internal)->render->drawchar(((internal_t*)dev->internal)->render, font, glyphnr, color, matrix); }
77 void ocr_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action) { ((internal_t*)dev->internal)->render->drawlink(((internal_t*)dev->internal)->render, line, action); }
78
79 void ocr_result_write(gfxresult_t*r, int filedesc)
80 {
81     textpage_t*i= (textpage_t*)r->internal;
82 }
83 int ocr_result_save(gfxresult_t*r, const char*filename)
84 {
85     textpage_t*i= (textpage_t*)r->internal;
86     if(!i) {
87         return 0; // no pages drawn
88     }
89     FILE*fi = fopen(filename, "wb");
90     if(!fi)
91         return 0;
92     while(i) {
93         fwrite(i->text, i->textpos, 1, fi);
94         i = i->next;
95     }
96     fclose(fi);
97     return 1;
98 }
99
100 void*ocr_result_get(gfxresult_t*r, const char*name)
101 {
102     textpage_t*i= (textpage_t*)r->internal;
103     if(!strcmp(name,"text")) {
104         textpage_t*j = i;
105         int len = 0;
106         while(j) {
107             len += i->textpos;
108             j = j->next;
109         }
110         char*text = (char*)malloc(len);
111         int pos = 0;
112         j = i;
113         while(j) {
114             memcpy(&text[pos], i->text, i->textpos);
115             pos += i->textpos;
116             j = j->next;
117         }
118         text[pos] = 0;
119         return text;
120     } else if(!strncmp(name,"page",4)) {
121         int pagenr = atoi(&name[4]);
122         if(pagenr<0)
123             pagenr=0;
124         while(pagenr>0) {
125             i = i->next;
126             if(!i)
127                 return 0;
128             pagenr++;
129         }
130         i->text[i->textpos] = 0;
131         return strdup(i->text);
132     }
133     return 0;
134 }
135 void ocr_result_destroy(gfxresult_t*r)
136 {
137     textpage_t*i= (textpage_t*)r->internal;
138     int t;
139     r->internal = 0;
140     while(i) {
141         textpage_t*next = i->next;
142         free(i->text);i->text = 0;
143         free(i);
144         i = next;
145     }
146     free(r);
147 }
148
149 job_t*JOB;
150
151 void ocr_endpage(gfxdevice_t*dev) 
152
153     internal_t*i = (internal_t*)dev->internal;
154     i->render->endpage(i->render); 
155
156     gfxdevice_t*out = i->render;
157     gfxresult_t* r = out->finish(out);
158     free(i->render);i->render = 0;
159
160     gfximage_t*img = (gfximage_t*)r->get(r, "page");
161
162     job_t job;
163     JOB = &job;
164     
165     job_init(&job);
166     job.cfg.out_format=UTF8;
167
168     job.src.fname = "<none>";
169     job.src.p.p = malloc(img->width*img->height);
170     job.src.p.bpp = 1;
171     job.src.p.x = img->width;
172     job.src.p.y = img->height;
173     int size=img->width*img->height;
174     int t;
175     for(t=0;t<size;t++) {
176         job.src.p.p[t] = (img->data[t].r+img->data[t].g+img->data[t].b)/3;
177     }
178
179     pgm2asc(&job);
180
181     int linecounter;
182     const char *line = 0;
183     int len = 0;
184     linecounter = 0;
185     line = getTextLine(linecounter++);
186     while (line) {
187       len += strlen(line)+1;
188       line = getTextLine(linecounter++);
189     }
190
191     textpage_t*page = malloc(sizeof(textpage_t));
192     page->next = 0;
193     page->text = malloc(len+1);
194     page->textpos = 0;
195     if(!i->first_page) {
196         i->first_page = i->current_page = page;
197     } else {
198         i->current_page->next = page;
199         i->current_page = page;
200     }
201
202     linecounter = 0;
203     line = getTextLine(linecounter++);
204     while (line) {
205       int l = strlen(line);
206       memcpy(&page->text[page->textpos], line, l);
207       page->textpos += l;
208       page->text[page->textpos++] = '\n';
209
210       line = getTextLine(linecounter++);
211     }
212     page->text[page->textpos++] = 0;
213
214     free_textlines();
215
216     job_free(&job);JOB=0;
217     
218     r->destroy(r);
219 }
220
221 gfxresult_t* ocr_finish(gfxdevice_t*dev)
222 {
223     internal_t*i = (internal_t*)dev->internal;
224     
225     gfxresult_t*r = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
226     
227     r->internal = i->first_page;
228     r->write = ocr_result_write;
229     r->save = ocr_result_save;
230     r->get = ocr_result_get;
231     r->destroy = ocr_result_destroy;
232
233     free(dev->internal); dev->internal = 0; i = 0;
234
235     return r;
236 }
237
238 void gfxdevice_ocr_init(gfxdevice_t*dev, gfxdevice_t*out)
239 {
240     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
241     memset(dev, 0, sizeof(gfxdevice_t));
242
243     dev->name = "ocr";
244
245     dev->internal = i;
246
247     dev->setparameter = ocr_setparameter;
248     dev->startpage = ocr_startpage;
249     dev->startclip = ocr_startclip;
250     dev->endclip = ocr_endclip;
251     dev->stroke = ocr_stroke;
252     dev->fill = ocr_fill;
253     dev->fillbitmap = ocr_fillbitmap;
254     dev->fillgradient = ocr_fillgradient;
255     dev->addfont = ocr_addfont;
256     dev->drawchar = ocr_drawchar;
257     dev->drawlink = ocr_drawlink;
258     dev->endpage = ocr_endpage;
259     dev->finish = ocr_finish;
260
261     i->pages = 0;
262 }
263