implemented gradients
[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
35 typedef struct _textpage {
36     char*text;
37     int textpos;
38     struct _textpage*next;
39 } textpage_t;
40
41 typedef struct _internal {
42     gfxdevice_t*render;
43     int pages;
44     
45     textpage_t*first_page;
46     textpage_t*current_page;
47 } internal_t;
48
49 int ocr_setparameter(gfxdevice_t*dev, const char*key, const char*value)
50 {
51     internal_t*i = (internal_t*)dev->internal;
52     return i->render->setparameter(i->render,key,value);
53 }
54
55 void ocr_startpage(gfxdevice_t*dev, int width, int height) 
56
57     internal_t*i = (internal_t*)dev->internal;
58     if(i->render) {
59         fprintf(stderr, "Call endpage() before calling startpage()\n");
60         return;
61     }
62     i->render = malloc(sizeof(gfxdevice_t));
63     gfxdevice_render_init(i->render);
64     i->render->startpage(i->render,width,height); 
65     i->pages++;
66 }
67 /* passthrough */
68 void ocr_startclip(gfxdevice_t*dev, gfxline_t*line) { ((internal_t*)dev->internal)->render->startclip(((internal_t*)dev->internal)->render,line); }
69 void ocr_endclip(gfxdevice_t*dev) { ((internal_t*)dev->internal)->render->endclip(((internal_t*)dev->internal)->render); }
70 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); }
71 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); }
72 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); }
73 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); }
74 void ocr_addfont(gfxdevice_t*dev, gfxfont_t*font) { ((internal_t*)dev->internal)->render->addfont(((internal_t*)dev->internal)->render, font); }
75 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); }
76 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); }
77
78 void ocr_result_write(gfxresult_t*r, int filedesc)
79 {
80     textpage_t*i= (textpage_t*)r->internal;
81 }
82 int ocr_result_save(gfxresult_t*r, const char*filename)
83 {
84     textpage_t*i= (textpage_t*)r->internal;
85     if(!i) {
86         return 0; // no pages drawn
87     }
88     FILE*fi = fopen(filename, "wb");
89     if(!fi)
90         return 0;
91     while(i) {
92         fwrite(i->text, i->textpos, 1, fi);
93         i = i->next;
94     }
95     fclose(fi);
96     return 1;
97 }
98
99 void*ocr_result_get(gfxresult_t*r, const char*name)
100 {
101     textpage_t*i= (textpage_t*)r->internal;
102     if(!strcmp(name,"text")) {
103         textpage_t*j = i;
104         int len = 0;
105         while(j) {
106             len += i->textpos;
107             j = j->next;
108         }
109         char*text = (char*)malloc(len);
110         int pos = 0;
111         j = i;
112         while(j) {
113             memcpy(&text[pos], i->text, i->textpos);
114             pos += i->textpos;
115             j = j->next;
116         }
117         text[pos] = 0;
118         return text;
119     } else if(!strncmp(name,"page",4)) {
120         int pagenr = atoi(&name[4]);
121         if(pagenr<0)
122             pagenr=0;
123         while(pagenr>0) {
124             i = i->next;
125             if(!i)
126                 return 0;
127             pagenr++;
128         }
129         i->text[i->textpos] = 0;
130         return strdup(i->text);
131     }
132     return 0;
133 }
134 void ocr_result_destroy(gfxresult_t*r)
135 {
136     textpage_t*i= (textpage_t*)r->internal;
137     int t;
138     r->internal = 0;
139     while(i) {
140         textpage_t*next = i->next;
141         free(i->text);i->text = 0;
142         free(i);
143         i = next;
144     }
145     free(r);
146 }
147
148 job_t*JOB;
149
150 void ocr_endpage(gfxdevice_t*dev) 
151
152     internal_t*i = (internal_t*)dev->internal;
153     i->render->endpage(i->render); 
154
155     gfxdevice_t*out = i->render;
156     gfxresult_t* r = out->finish(out);
157     free(i->render);i->render = 0;
158
159     gfximage_t*img = (gfximage_t*)r->get(r, "page");
160
161     job_t job;
162     JOB = &job;
163     
164     job_init(&job);
165     job.cfg.out_format=UTF8;
166
167     job.src.fname = "<none>";
168     job.src.p.p = malloc(img->width*img->height);
169     job.src.p.bpp = 1;
170     job.src.p.x = img->width;
171     job.src.p.y = img->height;
172     int size=img->width*img->height;
173     int t;
174     for(t=0;t<size;t++) {
175         job.src.p.p[t] = (img->data[t].r+img->data[t].g+img->data[t].b)/3;
176     }
177
178     pgm2asc(&job);
179
180     int linecounter;
181     const char *line = 0;
182     int len = 0;
183     linecounter = 0;
184     line = getTextLine(linecounter++);
185     while (line) {
186       len += strlen(line)+1;
187       line = getTextLine(linecounter++);
188     }
189
190     textpage_t*page = malloc(sizeof(textpage_t));
191     page->next = 0;
192     page->text = malloc(len+1);
193     page->textpos = 0;
194     if(!i->first_page) {
195         i->first_page = i->current_page = page;
196     } else {
197         i->current_page->next = page;
198         i->current_page = page;
199     }
200
201     linecounter = 0;
202     line = getTextLine(linecounter++);
203     while (line) {
204       int l = strlen(line);
205       memcpy(&page->text[page->textpos], line, l);
206       page->textpos += l;
207       page->text[page->textpos++] = '\n';
208
209       line = getTextLine(linecounter++);
210     }
211     page->text[page->textpos++] = 0;
212
213     free_textlines();
214
215     job_free(&job);JOB=0;
216     
217     r->destroy(r);
218 }
219
220 gfxresult_t* ocr_finish(gfxdevice_t*dev)
221 {
222     internal_t*i = (internal_t*)dev->internal;
223     
224     gfxresult_t*r = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
225     
226     r->internal = i->first_page;
227     r->write = ocr_result_write;
228     r->save = ocr_result_save;
229     r->get = ocr_result_get;
230     r->destroy = ocr_result_destroy;
231
232     free(dev->internal); dev->internal = 0; i = 0;
233
234     return r;
235 }
236
237 void gfxdevice_ocr_init(gfxdevice_t*dev, gfxdevice_t*out)
238 {
239     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
240     memset(dev, 0, sizeof(gfxdevice_t));
241
242     dev->name = "ocr";
243
244     dev->internal = i;
245
246     dev->setparameter = ocr_setparameter;
247     dev->startpage = ocr_startpage;
248     dev->startclip = ocr_startclip;
249     dev->endclip = ocr_endclip;
250     dev->stroke = ocr_stroke;
251     dev->fill = ocr_fill;
252     dev->fillbitmap = ocr_fillbitmap;
253     dev->fillgradient = ocr_fillgradient;
254     dev->addfont = ocr_addfont;
255     dev->drawchar = ocr_drawchar;
256     dev->drawlink = ocr_drawlink;
257     dev->endpage = ocr_endpage;
258     dev->finish = ocr_finish;
259
260     i->pages = 0;
261 }
262